18 real Canonical interview questions with full model answers — Technical, Behavioral, Coding, System design. Drawn from the same verified bank ChannelPulse drills from (18 Canonical questions in total).
Situation — My biggest achievement was improving the release reliability of a service owned by a team of eight engineers. We were shipping regularly, but releases often involved manual checks and late coordination; a failed deployment could consume several engineers’ time and delay work for dependent teams. The issue was not a lack of effort—it was that our process made failures difficult to detect and recover from quickly.
Task — I took responsibility for making releases safer and more predictable without slowing delivery or turning the team into a central operations bottleneck.
Action
I started by establishing a baseline from incident records and deployment data. We agreed on measures that mattered: change failure rate, rollback time, and the time engineers spent on release coordination.
I brought developers and the operations stakeholders together to map the release path. That surfaced a few high-risk manual steps and an unclear ownership boundary, rather than one dramatic technical defect.
I proposed incremental changes: automated pre-release checks, a staged rollout with health gates, and a documented rollback path. I deliberately kept the first version small so we could learn without blocking the roadmap.
I assigned owners for each change and paired engineers across the boundary where handoffs had previously caused delays. When a check produced noisy failures, I worked with the team to tune it instead of treating every alert as a reason to stop all releases.
I reviewed the metrics with the team after each rollout and used incidents as learning opportunities, not individual blame. That helped make the new process something engineers trusted and maintained.
Result — Over the following two quarters, deployment-related incidents fell by about 40%, and median rollback time dropped from roughly 45 minutes to under 15. We also reduced release coordination effort, giving engineers more time for planned work. I’m proudest that the improvement came from changing the system and building shared ownership—not from asking people to work harder. My lesson was to measure the pain first, then make reliability improvements in small, verifiable steps.
2. If you are asked to drop everything you are working on and switch to a completely different task, how do you react?
Model answer
Situation — On a service team, I was midway through a planned performance improvement when a release candidate began failing health checks in one deployment environment. The release was time-sensitive, and the failure affected a path customers needed, so the team had to decide whether to pause planned work and investigate. I was responsible for the performance change, but I also had enough context to help narrow down the release issue.
Task — I needed to respond quickly without abandoning my existing work in a way that created confusion or lost progress. The priority was to establish the impact, agree on an owner and next steps, then help resolve the urgent issue.
Action
I first asked the release lead to confirm severity, affected environments, and the decision deadline. That helped distinguish a release blocker from a lower-priority warning.
I wrote down the current state of my work: what was complete, what remained, and how to resume it. I pushed the in-progress changes to a clearly labeled branch and updated the ticket so another engineer could understand the status.
I coordinated with the release team and took a bounded investigation task: comparing the failing environment’s configuration with a known-good one and checking the health-check logs.
I found that the service was binding to an address that differed in the affected environment. I shared the evidence rather than making an unreviewed change, and worked with the owner to validate a small configuration fix.
Once the release was unblocked, I documented the finding, handed over any follow-up work, and agreed with my manager on when to return to the performance improvement.
Result — The team resolved the release blocker without losing track of the planned work, and the follow-up change made the environment difference easier to detect in testing. I learned to treat a priority switch as a coordination problem as well as a technical one: clarify urgency, leave a useful handoff, and make the return path explicit. I am comfortable changing direction when the impact warrants it, while making the cost and status of that change visible.
Situation — On a software team, a newer engineer joined while we were improving a service’s deployment and monitoring. They were capable, but unfamiliar with the codebase and hesitant to make changes in an area where mistakes could affect production. I had learned the service through earlier operational issues, so I understood both the implementation and the reasons behind some of its less-obvious safeguards.
Task — I wanted to help them become independently effective, not just complete one task for them. The challenge was to provide enough context and review to build confidence without becoming a bottleneck or taking ownership away from them.
Action
I asked what they wanted to learn and what was currently blocking them, then agreed on a small but meaningful first change: adding a missing operational metric and documenting how to verify it.
I gave them a map of the relevant components, deployment path, and runbooks, explaining why the metric mattered to operators rather than only pointing to files.
We used a pairing session to walk through the first test and change. I asked them to drive, and focused on explaining how I reasoned about failure cases and compatibility.
For the next change, I stepped back and let them propose the implementation. In review, I separated must-fix correctness issues from optional style suggestions, and explained the reasoning behind each important comment.
I encouraged them to present the result at the team’s engineering meeting and asked them to update the runbook, so their knowledge became useful to the wider team too.
Result — They completed the work, later took on related changes with less support, and became more comfortable explaining operational behavior to others. The updated metric and documentation also helped the team investigate the service more consistently. I see mentorship as a two-way investment: it accelerates someone’s growth, improves shared team knowledge, and often exposes assumptions in my own understanding. Good mentorship should increase the other person’s autonomy over time, not their dependence on me.
BehavioralMediumCanonicalSoftware Engineer
4. Among your peers at school who shared similar circumstances and opportunities, how did you stand out?
Model answer
Situation — At university, I had access to the same courses and computing resources as many of my peers, but I noticed that most coursework ended when an assignment passed its tests. I wanted to understand how software behaved when other people had to install, use, and maintain it.
Task — I set myself the goal of turning one class project into something other students could actually run, while balancing that work with my regular coursework.
Action
I chose a small Linux-based tool related to a recurring problem in our student group, and first spoke with potential users to check that the problem was real rather than just interesting to me.
I broke the work into weekly milestones and kept the scope deliberately narrow: a reliable core workflow, clear installation instructions, and tests for the behavior most likely to break.
I used Git issues and short design notes so others could follow the decisions. When a teammate suggested a broader feature set, I explained the delivery risk and proposed recording those ideas for a later release.
I asked classmates to try the tool on machines with different setups. Their feedback exposed missing dependency instructions and an assumption in my tests, so I fixed both before adding features.
I shared progress in our group and invited contributions, rather than treating the project as a solo exercise. That gave me practice incorporating feedback and reviewing changes constructively.
Result — By the end of the term, other students could install and use the tool from the README, and the project had a tested core and a small set of outside contributions. The bigger difference was my approach: I stood out by taking responsibility beyond the assignment, communicating trade-offs, and making the work useful to people besides myself. I learned that initiative matters most when it is paired with listening and dependable follow-through.
5. Twice a year, we travel for sprints, and sometimes the CEO might ask you questions about what you are working on.
The full question
Twice a year, we travel for sprints, and sometimes the CEO might ask you questions about what you are working on. Can you handle that kind of pressure?
Model answer
Situation — In a previous engineering role, I was working on a release-critical service when a senior leader asked for an update during a project review. The work involved a technical risk that was still being investigated, so I needed to be clear without overstating what we knew.
Task — My responsibility was to explain the status and its impact accurately, answer questions calmly, and make sure any follow-up commitments were realistic.
Action
I prepared a concise update: the goal, what was complete, the main risk, and the next milestone. For sprint travel, I would use the same approach and make sure I could explain my work without relying on a slide deck.
When asked a question, I listened to the full question and answered directly, using plain language before adding technical detail if it was useful.
I distinguished confirmed facts from estimates. For example, I would say, “We’ve reproduced the issue; we’re testing the suspected cause now,” rather than presenting the suspected cause as settled.
I connected technical choices to user and delivery impact, and explained the options and trade-offs when there was no single obvious answer.
If I didn’t know something, I said so, identified how I would verify it, and agreed on a specific follow-up rather than guessing.
I treated questions from the CEO as a chance to provide context and learn what mattered at the company level—not as an interruption or an exam.
Result — The conversation stayed focused, and the team had a shared understanding of the risk and next steps. I’m comfortable with that kind of pressure: I prepare, stay composed, and communicate honestly. A sprint setting is also a useful opportunity to build relationships and get decisions unstuck; I’d be glad to take part.
CodingEasyCanonicalSoftware Engineer
6. Divide a String Into Groups of Size k (LeetCode)
Model answer
The task
Split a string into consecutive groups of k characters. If the final group is short, pad it on the right with the supplied fill character.
Key idea
Walk through the string in steps of k and take a slice for each group. Only the last slice may need padding.
Approach
Create an empty list for the groups.
Iterate over the string in increments of k.
Take the next k characters as a group.
If that group is shorter than k, append enough fill characters to make it the required length.
Return the groups.
class Solution:
def divideString(self, s: str, k: int, fill: str) -> list[str]:
groups = []
for start in range(0, len(s), k):
group = s[start:start + k]
# Pad the final group, if it is shorter than k.
group += fill * (k - len(group))
groups.append(group)
return groups
Complexity:
Time: O(n), where n is the input string length; padding adds at most k - 1 characters.
Space: O(n), for the returned groups and any padding.
Common follow-ups
What if the string is empty? The loop runs zero times and returns an empty list.
How would you avoid storing all groups? Yield each padded group from a generator.
What if padding should use a multi-character string? Repeat it enough times, then truncate to the required padding length.
CodingMediumCanonicalEngineering ManagerTechnical Assessment (Home Take Assignment)
7. Implement a calculator that uses prefix notation.
The full question
Implement a calculator that uses prefix notation. The calculate function should take a string expression and return the numerical solution.
Model answer
function calculate(expression) {
if (typeof expression !== "string" || expression.trim() === "") {
throw new Error("Expression must be a non-empty string");
}
// Allow parentheses to be attached to tokens, e.g. (+ 1 (* 2 3)).
const tokens = expression.replace(/[()]/g, " $& ").trim().split(/\s+/);
const operators = new Set(["+", "-", "*", "/"]);
const numberPattern = /^[+-]?(?:\d+.?\d*|.\d+)(?:e[+-]?\d+)?$/i;
let position = 0;
function parseExpression() {
let parenthesized = false;
if (tokens[position] === "(") {
parenthesized = true;
position++;
}
const token = tokens[position++];
if (token === undefined) throw new Error("Unexpected end of expression");
let value;
if (operators.has(token)) {
const left = parseExpression();
const right = parseExpression();
switch (token) {
case "+": value = left + right; break;
case "-": value = left - right; break;
case "*": value = left * right; break;
case "/":
if (right === 0) throw new Error("Division by zero");
value = left / right;
break;
}
} else if (numberPattern.test(token)) {
value = Number(token);
if (!Number.isFinite(value)) throw new Error(`Invalid number: ${token}`);
} else {
throw new Error(`Unexpected token: ${token}`);
}
if (parenthesized) {
if (tokens[position] !== ")") throw new Error("Expected closing parenthesis");
position++;
}
return value;
}
const result = parseExpression();
if (position !== tokens.length) {
throw new Error(`Unexpected token: ${tokens[position]}`);
}
return result;
}
// Examples:
// calculate("+ 1 2") // 3
// calculate("* + 2 3 4") // 20
// calculate("(+ 1 (* 2 3))") // 7
Parse recursively: each operator consumes exactly two expressions, supporting nested prefix expressions.
Accepts optional parentheses and signed decimal or scientific-notation numbers; throws on malformed input and division by zero.
Complexity: O(n) time and O(d) space, where n is the number of tokens and d is the expression's nesting depth.
CodingMediumCanonicalSoftware Engineer
8. Evaluate Reverse Polish Notation (LeetCode)
Model answer
The task
Evaluate an arithmetic expression whose operators follow their operands, using a stack. Return the integer result, with division truncated toward zero.
Key idea
When an operator appears, its two operands are the top two stack values. Compute their result and push it back; the final stack value is the answer.
Approach
Create an empty stack.
Scan the tokens from left to right.
Push numbers onto the stack.
For an operator, pop the right operand and then the left operand, apply the operation, and push the result.
Return the remaining value.
from typing import List
class Solution:
def evalRPN(self, tokens: List[str]) -> int:
stack = []
for token in tokens:
if token not in {"+", "-", "*", "/"}:
stack.append(int(token))
continue
right = stack.pop()
left = stack.pop()
if token == "+":
result = left + right
elif token == "-":
result = left - right
elif token == "*":
result = left * right
else:
# Use integer arithmetic to truncate toward zero,
# including when the operands have different signs.
result = abs(left) // abs(right)
if (left < 0) != (right < 0):
result = -result
stack.append(result)
return stack[-1]
Complexity:
Time: O(n), where n is the number of tokens; each token is processed once.
Space: O(n) for the stack in the worst case.
Common follow-ups
How would you support additional operators? Add each operator’s computation to the dispatch logic.
Why not use Python’s // for division? It rounds down, while this task requires truncation toward zero.
What if tokens arrive as a stream? Process each token immediately and keep only the stack.
System designHardCanonicalSoftware EngineerWritten interview
9. What are the important considerations when choosing between a monolithic, service-oriented, and microservice-based architecture?
Model answer
1. Requirements & scale
Functional: choose an architecture that supports the product’s domain, team structure, delivery cadence, and expected growth. Preserve clear ownership of business capabilities and reliable interfaces between them.
Non-functional: meet availability, latency, security, and operability requirements without creating more operational burden than the team can sustain.
Scale example: for a Canonical-style fleet-management control plane with 1 million machines reporting every five minutes, average ingest is 1,000,000 / 300 ≈ 3,300 requests/s; allow roughly 10,000 requests/s at peak. At 1 KB per report, that is about 3.3 MB/s average ingress. Retaining every raw report for a year would exceed 100 TB before replication and indexes, so retention and aggregation matter whichever architecture is selected.
These numbers do not by themselves justify microservices: a well-partitioned monolith can scale horizontally too.
2. High-level architecture
The request path below is deliberately compatible with either a modular monolith or independently deployed services. The choice changes deployment and ownership boundaries, not the need for sound API, data, and failure design.
flowchart TD
subgraph Client
A["Web UI and machine agents"]
end
subgraph Edge["Edge/CDN"]
B["TLS termination and rate limits"]
end
subgraph LB["Load Balancer"]
C["Regional traffic routing"]
end
subgraph API["API / Services"]
D["API gateway"]
E["Modular monolith"]
F["Independent domain services"]
end
subgraph Cache
G["Redis cache"]
end
subgraph Datastores
H["PostgreSQL metadata"]
I["Time-series reports"]
J["Object storage"]
end
subgraph Queue["Message Queue"]
K["Durable event queue"]
end
subgraph Workers
L["Ingest and notification workers"]
end
A -->|"HTTPS requests"| B
B -->|"filtered traffic"| C
C -->|"API traffic"| D
D -->|"one deployment option"| E
D -->|"alternative service routing"| F
E -->|"cache reads and writes"| G
F -->|"cache reads and writes"| G
E -->|"transactions"| H
F -->|"owned data access"| H
E -->|"enqueue events"| K
F -->|"enqueue events"| K
K -->|"asynchronous work"| L
L -->|"aggregated reports"| I
L -->|"large artifacts"| J
Diagram
A monolith can still have internal modules and a queue; microservices are not synonymous with good modularity. Likewise, a service-oriented architecture (SOA) can use coarser-grained services and shared enterprise infrastructure, while microservices usually emphasize smaller, independently deployable services with stronger team and data ownership.
3. API design
Keep external contracts stable regardless of internal architecture:
POST /v1/machines/{id}/reports — submit a machine report; return an acknowledgement and report ID.
GET /v1/machines/{id} — retrieve machine metadata and current status.
GET /v1/fleets/{id}/compliance — retrieve an aggregated compliance view.
POST /v1/fleets/{id}/actions — request a fleet operation, returning an operation ID for asynchronous completion.
Use authentication, idempotency keys for retried writes, explicit API versioning, and pagination for collection endpoints.
4. Data model & storage
Use PostgreSQL for transactional entities such as Machine, Fleet, Policy, and Operation; index by tenant and resource ID. It provides constraints and transactions that simplify correctness.
Store high-volume, time-stamped reports in a time-series or partitioned analytical store, partitioned by time and potentially tenant. Define retention and downsampling policies up front.
Keep large logs, images, or diagnostic bundles in object storage; store their metadata and access controls in PostgreSQL.
Use Redis for short-lived, rebuildable reads such as fleet summaries. Do not make it the source of truth.
In services, prefer each service to own its data and expose it through a contract. Avoid multiple services writing directly to the same tables; that creates hidden coupling even if deployment is independent.
5. Deep dive
Choose based on change boundaries and team autonomy, not fashion or a single throughput estimate. Start by mapping domain capabilities—for example, machine inventory, policy evaluation, reporting, and billing—and ask whether each has distinct ownership, scaling needs, security boundaries, and release cadence.
A monolith is usually the best starting point for a small team, a new product, tightly coupled workflows, or uncertain boundaries. It offers simple local development, transactions, testing, and deployment. Structure it as modules with explicit interfaces and dependency rules; otherwise, fast initial delivery can turn into a tangled codebase.
Choose SOA when the organization needs a smaller number of coarse-grained capabilities integrated across products or legacy systems, often with shared governance and messaging. Choose microservices when multiple teams genuinely need independent delivery and scaling, and can own production operation, observability, and data for their services. The cost is distributed failure, network latency, versioned contracts, eventual consistency, and more complex debugging and security.
A practical evolution path is to establish module boundaries first, measure bottlenecks and coordination pain, then extract one capability whose boundary and ownership are clear. Use an outbox to publish committed changes reliably; make consumers idempotent; define timeouts, retries with jitter, and dead-letter handling. Avoid a big-bang rewrite.
sequenceDiagram
participant Team
participant Module as Modular monolith
participant Outbox
participant Service as Extracted service
participant Metrics
Team->>Module: Define and enforce domain boundary
Module->>Metrics: Measure load and change friction
Team->>Outbox: Add reliable event publication
Outbox->>Service: Deliver events for one capability
Service->>Metrics: Report latency, errors, and saturation
Team->>Service: Shift traffic gradually and validate
Diagram
6. Scale, bottlenecks & trade-offs
Scale and availability: replicate stateless application instances behind a load balancer. A monolith can scale out as a unit, potentially wasting resources; services allow targeted scaling but add network hops and more failure points.
Consistency: a monolith can use one SQL transaction across modules. Across services, prefer explicit asynchronous workflows and eventual consistency where acceptable; use a saga or compensating action when a business process spans services. Do not promise a global transaction without a concrete mechanism.
Operations: microservices require mature CI/CD, service discovery, tracing, metrics, secrets management, on-call ownership, and capacity planning. Without these, the team pays complexity costs before gaining autonomy.
Decision rule: begin with a modular monolith unless independent deployment, scaling, or isolation is a demonstrated requirement. Split when the benefit exceeds the added operational and coordination cost, and retain a monolith when its simpler consistency and operations better serve the product. There is no universal size threshold; team count, domain coupling, and operational maturity are stronger signals than request volume alone.
TechnicalEasyCanonicalSoftware EngineerHiring Lead interview
10. What is the difference between Python and Go?
Model answer
Design and execution - Python is dynamically typed and interpreted, with a concise syntax and a large ecosystem for scripting, data science, automation, and web services. - Go is statically typed and compiled. Its explicit types and compiler checks catch many errors before runtime, and its straightforward language design supports maintainable systems code.
Concurrency - Python commonly uses asyncio, threads, or processes. In standard CPython builds, the Global Interpreter Lock (GIL) limits parallel execution of Python bytecode across threads, though threads remain useful for I/O-bound work and processes for CPU-bound work. - Go has lightweight goroutines and channels built into the language. The runtime schedules goroutines across OS threads, which makes it convenient to write concurrent network services. Concurrency still requires care: shared state can race, so use synchronization or communicate through channels appropriately.
Performance and deployment - Go generally offers faster startup and execution for CPU-intensive services, and compiles to a native binary that is often simple to deploy. - Python can be faster to develop in and has excellent libraries, but may need more runtime dependencies and can be slower for CPU-heavy work. Actual performance depends on the workload and libraries; I would benchmark before choosing based on performance alone.
When I’d choose each - I’d favor Python for rapid prototyping, automation, data workflows, or when its ecosystem is the main advantage. - I’d favor Go for concurrent services, infrastructure tools, or long-running applications where static typing, predictable deployment, and runtime efficiency matter.
The practical distinction is not that one is universally better: Python emphasizes expressiveness and ecosystem, while Go emphasizes simple compiled services and built-in concurrency. Both can be reliable production choices with good testing, observability, and operational practices.
TechnicalEasyCanonicalSoftware EngineerLinux system skills
11. I get “permission denied” when trying to execute a script.
The full question
I get “permission denied” when trying to execute a script. How do I fix this?
Model answer
Check the file and permissions:ls -l ./script shows whether the file exists and has an execute bit. If it is your script and you’re allowed to change it, run chmod u+x ./script, then execute it with ./script.
Check how it is run: You can also invoke the intended interpreter directly, for example python3 script.py or bash script.sh; this does not require the script itself to be executable. For direct execution, ensure the first line has a valid shebang, such as #!/usr/bin/env python3.
If it still fails, diagnose the specific cause: Check that you have read permission and execute permission on each parent directory. A noexec mount can prohibit execution from that filesystem; copy the file to an executable location or ask an administrator about the mount policy. On Windows-created scripts, convert CRLF line endings if the shebang produces an interpreter error.
Avoid a reflexive sudo: Only use elevated privileges when the task genuinely requires them; changing ownership or permissions broadly can create security problems.
flowchart TD
A[Permission denied] --> B{Can you read the file?}
B -- No --> C[Request appropriate read access]
B -- Yes --> D{Does it need direct execution?}
D -- No --> E[Run with the intended interpreter]
D -- Yes --> F{Is the execute bit set?}
F -- No --> G[Add execute permission if authorized]
F -- Yes --> H{Is the filesystem mounted noexec?}
H -- Yes --> I[Use an approved executable location]
H -- No --> J[Check parent directory permissions and policy]
12. Which of these are not Python logging levels: URGENT, CRITICAL, INFO, FATAL, TRACE, …?
Model answer
Python’s standard logging levels are DEBUG, INFO, WARNING, ERROR, and CRITICAL.
URGENT is not a standard level name.
TRACE is not a standard level name, although applications can define it as a custom level.
FATAL is an alias for CRITICAL in Python’s logging module, so it is recognized, but it is not a distinct severity level.
Similarly, WARN is an alias for WARNING. Custom levels can be added with logging.addLevelName(), so the distinction is between Python’s built-in levels and names an application or library chooses to define.
Start with compatibility, not just a version number. I keep an API backward-compatible by default: add optional fields or endpoints rather than changing existing meanings, removing fields, or tightening validation unexpectedly. I document which behavior is guaranteed and test representative older clients.
Choose an explicit versioning strategy. For a public REST API, a major version in the path—such as /v1/ and /v2/—is easy to discover, route, document, and support simultaneously. Header or media-type versioning can keep URLs cleaner, but is less visible to users and tooling. I would choose one convention and apply it consistently.
Make breaking changes deliberate. A breaking change gets a new major version, migration documentation, and an overlap period when feasible. I announce a deprecation date, include a replacement path, monitor usage by version, and retire the old version only after the stated support window and usage checks. For internal APIs, I may coordinate a shorter migration, but still avoid silently breaking consumers.
Automate the contract. Maintain OpenAPI specifications, compatibility checks in CI, and contract or integration tests. Track requests by client and version so the team knows who is affected. Use feature flags or staged rollout for risky behavior changes.
Be precise about semantics. A version should represent a meaningful compatibility boundary, not every small release. PATCH and MINOR changes can remain within a major version when they preserve the contract; removing fields or changing their meaning is a breaking change even if the code change looks small.
flowchart TD
A[Propose API change] --> B{Backward compatible?}
B -- Yes --> C[Add change to current version]
C --> D[Update contract and tests]
B -- No --> E[Create new major version]
E --> F[Publish migration and deprecation plan]
F --> G[Run versions in parallel where needed]
G --> H[Measure old-version usage]
H --> I[Retire after support window and checks]
14. When would you choose Python over Go for a project?
Model answer
I choose based on the problem and the team’s ability to operate the result, rather than treating either language as universally better.
Choose Python when delivery speed, a rich domain library, or ease of experimentation is the main constraint. It is a strong fit for automation, data processing, machine-learning workflows, and services where the ecosystem provides a substantial advantage. Its readability also helps teams iterate quickly.
Choose Go when I need a small, self-contained binary, predictable runtime behavior, efficient concurrency, or a service that must be straightforward to deploy across varied environments. Those properties can be useful for infrastructure agents, networking tools, and long-running services.
Compare the workload, not just benchmarks. I would measure representative latency, throughput, memory use, and startup time. Python can be entirely adequate for I/O-bound services; CPU-heavy work may need native libraries, multiprocessing, or a different implementation. Go’s concurrency primitives help, but do not remove the need for backpressure, cancellation, and resource limits.
Factor in the existing ecosystem and team. A Python library that is mature and well-supported may outweigh Go’s deployment simplicity. Conversely, if the project needs a single artifact with few runtime dependencies, Go may reduce operational friction.
Consider maintenance and integration. I check support lifetimes, security patching, build and test tooling, observability, and how the language fits the surrounding system. In a Canonical-style infrastructure project, packaging, reproducible builds, and deployment targets matter alongside application code.
I would prototype the riskiest part in the likely candidates, define measurable acceptance criteria, and choose the simplest option that meets them. I would avoid introducing a second language without a concrete benefit, because that adds hiring, tooling, and maintenance costs.
15. What techniques do you use for zero-downtime deployments?
Model answer
Make changes backward-compatible. I use an expand-and-contract sequence for database or API changes: add the new field or endpoint, deploy code that can read both old and new forms, migrate data, then remove the old form in a later release. This avoids requiring every instance to change at once.
Use a rolling, canary, or blue-green rollout. I choose based on risk and infrastructure. A canary sends a small share of traffic to the new version first; blue-green keeps the old version ready for fast traffic switching. For a rolling rollout, I maintain enough healthy capacity while replacing instances.
Make readiness and draining meaningful. Readiness checks should verify that an instance can serve real requests, not just that its process started. Before stopping an old instance, I stop sending it new work and allow in-flight requests and jobs to finish, with bounded timeouts.
Separate deployment from activation. Feature flags let me deploy code safely without exposing a feature immediately. I can enable it for internal users or a small cohort, monitor behavior, and disable it quickly without rebuilding or redeploying.
Automate verification and rollback. I watch error rates, latency, saturation, and service-specific indicators during rollout. If a threshold is breached, the rollout pauses or rolls back. I also test that rollback is possible; database changes and irreversible migrations need special care.
flowchart LR
A[Build and test] --> B[Deploy compatible version]
B --> C[Health checks]
C --> D[Canary traffic]
D --> E{Metrics healthy?}
E -->|Yes| F[Expand rollout]
E -->|No| G[Stop and roll back]
F --> H[Remove old version later]
Diagram
The key principle is that old and new versions must coexist safely during the transition. Zero downtime is a property of the whole change—application, data, traffic management, and operational response—not just the deployment tool.
Ubuntu packaging is based on Debian packaging, with Ubuntu-specific archive workflows and release policies. A package typically has an upstream source and Debian packaging metadata that describes how to build and install it as a .deb.
Source and metadata: The source package includes the upstream code plus a debian/ directory. Key files include control for package metadata and dependencies, rules for build steps, and changelog for version history and Ubuntu release targeting.
Build: Tools such as dpkg-buildpackage and debhelper build binary packages in a controlled environment. Build dependencies are declared so the package can be rebuilt consistently.
Review and upload: A package is uploaded to an archive or a PPA. Launchpad builds it for supported architectures; build logs and test results help identify failures.
Publication and maintenance: Packages move through Ubuntu archive pockets such as -proposed and, after validation and approval, -updates. Security fixes follow the security team's processes and may be backported to supported releases rather than relying on a newer upstream version.
flowchart LR
A[Upstream source] --> B[Debian packaging metadata]
B --> C[Source package upload]
C --> D[Launchpad build farm]
D --> E[Architecture builds and checks]
E --> F[Ubuntu archive pocket]
F --> G[Users receive package updates]
Diagram
As an engineering manager, I would pay particular attention to reproducibility, dependency correctness, architecture coverage, upgrade behavior, and clear ownership of security updates. A package that builds successfully is not necessarily ready: it also needs to install, upgrade, and behave correctly in the supported Ubuntu environment.
TechnicalMediumCanonicalSoftware EngineerLinux system skills
17. What is the difference between a GNU license and an Apache license?
Model answer
“GNU license” usually refers to one of the licenses published by the GNU Project, rather than one single license. The most common comparison is GPL versus Apache License 2.0.
GNU GPL (copyleft): You may use, modify, and redistribute the software, including commercially. If you distribute a work covered by the GPL, you generally must provide the corresponding source under the GPL’s terms. GPLv3 also addresses certain patent and anti-lockdown concerns. The exact obligations depend on the GPL version and how the software is combined and distributed.
Apache 2.0 (permissive): You may use, modify, distribute, and include the software in proprietary products, subject to conditions such as preserving notices and providing the license. It includes an express patent license from contributors and a patent-termination provision if a licensee initiates certain patent litigation.
Practical distinction: GPL is designed to preserve users’ freedoms in distributed derivative works; Apache 2.0 permits broader reuse with fewer source-sharing obligations, while still including patent terms and attribution requirements.
Neither license means “no rules.” For a real project, check the exact license version, dependency licenses, how components are combined, and distribution model. If the consequences are material, get legal advice rather than relying on a one-line summary.
My favourite is git bisect, because it turns a vague regression hunt into a systematic search.
I mark a known-good commit and a known-bad commit, then Git checks out commits between them. I run a reliable test at each step and mark the result good or bad; Git narrows the range until it identifies the first commit that introduced the problem.
For example, if a regression appeared sometime in the last 200 commits, bisect can usually locate the culprit in about log₂(200), or eight, checks rather than requiring me to inspect every commit. If the test is deterministic and easy to automate, git bisect run can perform those checks for me.
The important caveat is that the test must give a trustworthy good/bad result. If it is flaky, depends on external services, or cannot run at older revisions, I use manual checks or narrow the range first.
Practice these out loud, don't memorise them
Reading an answer is not the same as being able to give one under pressure. ChannelPulse plays the interviewer, asks the follow-ups, and scores each answer with feedback and a model answer so you can hear the gap between what you said and what lands.