Appearance
Your Project, Told Well
Every DevOps interview opens here. The interviewer is not testing facts yet. They are testing whether you have really built and run something, and whether you can explain it clearly. The answers below use one realistic example project, so you can see a complete answer. Swap in your own facts. An interviewer will push on every detail, and a borrowed story falls apart on the second follow-up question.
The example project is an online shop. It is the same shop the book builds in 14.4.3 One App, Three Environments.
1. Walk me through your current project architecture from a developer's code change to production traffic.
The short answer
Tell two short stories in order. First, how a request from a customer travels through the system to the database and back. Second, how a developer's change travels from a pull request to running in production. Then name the cross-cutting pieces: secrets, monitoring and security. Finish with the part you owned.
This question is really two questions glued together. One is "what does the running system look like?" The other is "how does new code get into it?" Most candidates mix the two and the answer turns into a fog of tool names. Keep them apart and the interviewer can follow you easily.
Start with one sentence about the product and its size. For example: "We run an online shop. It serves about forty thousand orders a day, with peaks around eight in the evening."
Then follow one customer request. The figure shows the path for the example shop.
Walk the figure out loud, one hop per sentence:
- The customer's browser looks up
shop.example.comand reaches the edge. The edge is a content delivery network (a set of servers close to users that cache files) with a web application firewall (a filter that blocks known attack patterns). - The edge forwards the request to the cloud load balancer, the one public address of the cluster.
- The load balancer hands it to the gateway inside the cluster. The gateway decrypts HTTPS and picks a service by the URL path.
- The
webpods serve the shop's pages. Requests that start with/api/go on tocheckout-api. checkout-apireads and writes orders in a managed PostgreSQL database, caches product prices in Redis, and puts an "order placed" event on a queue.- The worker pods read that queue and send the receipt email.
Then follow one code change. Question 5 below draws this second story in full. In one breath: a developer opens a pull request, and the CI pipeline builds and checks it. A reviewer approves it, and the merge builds one container image. The image is scanned and pushed to the registry. Then a GitOps tool rolls it out to staging, and then to production.
Then name the cross-cutting pieces in three sentences. Secrets come from a cloud key vault at runtime, never from the image. Metrics go to Prometheus and Grafana, logs go to a central log store, and alerts page the on-call engineer. Every image is scanned and signed, and the cluster refuses images that are not.
End with your part. "I owned the pipeline and the Kubernetes setup. I can go deeper into any part of this." That last line hands control back to the interviewer, which is exactly what they want.
Why they ask: they want to see whether you understand the whole system or only the corner you touched. Two clean stories prove you see the whole thing.
2. What are the main services in your project, and what does each service do?
The short answer
Name each service by the job it does for the business, not by its technology. For each one, say what data it owns, who calls it, and how it behaves under load. Keep it to one or two sentences per service.
A list of names like "web, checkout, catalog, worker" tells the interviewer nothing. What they want to hear is what each service is responsible for, because responsibilities decide everything else: how it scales, how it fails, and how it is deployed.
Use the same four facts for every service:
- Its job. What it does, in business words.
- Its data. Which data it owns. A service that owns data is the only one allowed to change that data.
- Who talks to it, and how. A direct request that waits for a reply (synchronous), or a message on a queue that is handled later (asynchronous).
- Its load and failure profile. Does it spike? What happens to customers if it is down?
A model answer (swap in your own facts):
"We have five services.
webserves the shop's pages. It is stateless, so it scales easily and we run two copies.checkout-apitakes orders and payments. It owns the orders table in PostgreSQL, so it is the most critical service, and it autoscales from three to ten copies.catalog-apiserves product data. It is read-heavy, so it sits behind a Redis cache.payments-adaptertalks to the payment provider. It is the one place that holds payment credentials, so it has the tightest network rules.notification-workerreads order events from a queue and sends emails. If it goes down, emails are delayed but nobody's order fails, because the messages wait in the queue."
Notice what this answer does. Every service gets a reason for its design. That invites good follow-up questions, like "why a queue for notifications?" And you already know the answer: a slow email provider must never slow down a checkout.
Why they ask: to see whether you understand why the system is split the way it is. If you can only say what a service is called, you probably only deployed it.
3. What were your personal responsibilities in designing, building, securing, and operating the deployment platform?
The short answer
Answer in four parts that match the question: what you designed, what you built, what you secured, and what you operate. Use "I" for your own work and give one concrete result for each part.
The question lists four verbs on purpose: design, build, secure, operate. Answer all four, in that order. It shows you have touched the whole life of a platform and not only one slice of it.
Design means you made choices and can defend them. Example: "I proposed moving from one pipeline per environment to build-once-promote, so the image tested in staging is the exact image in production."
Build means you wrote real things. Example: "I wrote the shared GitHub Actions workflow that all five services use, and the Helm chart they deploy with."
Secure means you closed real gaps. Example: "I replaced the stored cloud keys in CI with short-lived OIDC tokens, and I added image scanning that blocks critical vulnerabilities."
Operate means you were on call and fixed things in production. Example: "I am in the on-call rotation. I wrote the runbooks for our five most common alerts."
A model answer (swap in your own facts):
"I was one of two engineers on the platform. On design, I proposed build-once-promote and GitOps with Argo CD, and wrote the design document the team agreed on. On build, I wrote the reusable pipeline, the base Dockerfile pattern and the Helm chart, which cut a new service's setup from two days to about an hour. On security, I moved CI to OIDC so no long-lived cloud keys exist anymore, and added Trivy scans that block critical findings. On operations, I am on the on-call rotation, and I own the dashboards for deployment health."
Each part has a result. Results are what make an answer believable. "I worked on CI" is vague. "Setup went from two days to an hour" is a fact the interviewer can ask about.
Why they ask: to measure the size of your role. Interviewers have heard many people describe a team's work as their own, so they listen carefully for specifics.
4. Which parts of the build and release process are automated, and which still require manual work?
The short answer
Walk the pipeline from commit to production and say which steps run by themselves and which need a person. Then explain why each manual step is still manual. A manual step with a good reason is fine. A manual step nobody can explain is a problem you plan to fix.
A good answer here is honest. Every real company has manual steps. What the interviewer wants to know is whether the manual steps are deliberate or accidental.
Usually automated:
- Running checks on every pull request: formatting, linting, type checking, unit tests, and security scans.
- Building the container image once, tagging it, and pushing it to the registry.
- Deploying to development and staging after a merge.
- Health checks after a deploy, and an automatic rollback when the new version fails them.
Often still manual, and why:
- The production approval. A person clicks "approve". This is common in regulated industries, where an audit trail must show a named person accepted the change.
- Destructive database changes. Dropping a column cannot be undone. Many teams have a person confirm these, even when the rest is automated. Question 286 explains why.
- Some secret rotation. Changing a password that a third party issued sometimes needs a person to log in to that third party's website.
- Incident decisions. Choosing to roll back during an outage is a human judgment, even if the rollback itself is one command.
A model answer (swap in your own facts):
"Everything up to staging is automatic. A merge to main builds the image, scans it, and deploys it to staging, where smoke tests run. Production needs one approval in the pipeline, because our auditors require a named approver. After approval the rollout and the health check are automatic, and a failed health check rolls back by itself. Two things are still manual by accident, not by choice: renewing one partner's API key, and cleaning up old preview environments. Both are on our backlog."
That last sentence is the strongest part. It shows you see the gaps and plan to close them.
5. Draw the end-to-end flow from a pull request to a running application instance.
The short answer
It starts with a pull request, CI checks, review and merge. Then one image is built and pushed to the registry by its digest. A change to the deployment configuration follows, and the deployment tool rolls it out. Probes confirm the new pods are healthy before traffic moves to them. Finally, real metrics are checked before the release is called done.
When an interviewer says "draw", they usually hand you a whiteboard or a shared document. Draw boxes in order, number them, and talk while you draw. This is the picture to practise until you can draw it in under two minutes.
Talk through each box like this:
- Pull request. A developer pushes a branch and opens a pull request. That event starts the pipeline.
- CI checks. The CI system checks out the code, installs dependencies, and runs fast checks first: formatting, linting, type checks, unit tests. It then builds the code and runs security scans.
- Review and merge. Branch protection rules block the merge until a reviewer approves and every required check is green. Question 186 covers these rules.
- Build once. The merge to
mainbuilds the container image a single time. It is tagged with the commit ID and pushed to the registry. From now on we refer to it by its digest, thesha256:fingerprint of its exact bytes. Question 35 explains digests. - Config change. The pipeline writes the new digest into the deployment configuration, which lives in Git.
- Sync. A GitOps tool such as Argo CD notices that the configuration changed and applies it to the cluster. (GitOps means the cluster pulls its desired state from Git, instead of the pipeline pushing commands into the cluster.)
- Rolling update. Kubernetes starts new pods next to the old ones. A new pod gets traffic only after its readiness probe passes. Old pods are removed one by one. Question 350 covers rolling updates.
- Verify. A smoke test (a short check of the most important user paths) hits the real service, and we watch error rate and latency for a few minutes. If they are healthy, the same digest is promoted to production through steps 5 to 8 again. If not, we roll back.
The detail that impresses: step 4 happens once. Staging and production receive the same digest. Nothing is rebuilt per environment, so what was tested is exactly what ships.
6. Which source-control, build, artifact, registry, CI/CD, deployment, and monitoring tools does your team use, and why?
The short answer
Go category by category, and for each tool give one reason the team chose it. Reasons beat names. "We use GitHub Actions because our code already lives on GitHub, so there is no extra server to run" is a complete answer for one category.
The interviewer is checking two things. Do you know what each category is for? And can you defend a choice? A table keeps your answer organised. Here is the example shop's toolchain:
| Category | Tool | Main reason |
|---|---|---|
| Source control | GitHub | Pull requests, branch rules |
| CI | GitHub Actions | Next to the code, no server |
| Build | Docker with BuildKit | Fast cached builds |
| Packages | Azure Artifacts | Private npm packages |
| Registry | Azure Container Registry | Same cloud as the cluster |
| Scanning | Trivy | Free, scans images and config |
| Deployment | Argo CD with Helm | Git is the source of truth |
| Infrastructure | Terraform | Whole cloud setup as code |
| Monitoring | Prometheus, Grafana | Standard for Kubernetes |
| Logs | Azure Monitor | Managed, no cluster to run |
Under the table, give the reasoning in sentences, because the reasons are the real answer:
- GitHub Actions runs where the code already lives. Nobody has to patch or back up a CI server. The trade-off is less control over the machines that run the jobs. Question 182 compares hosted and self-hosted runners.
- Azure Container Registry sits in the same cloud region as the cluster, so image pulls are fast and stay on the private network. The cluster can pull with its own cloud identity, so no registry password is stored anywhere.
- Argo CD keeps the cluster matched to what Git says. If someone changes the cluster by hand, Argo CD shows the difference and can undo it. Git history then doubles as the history of every deployment.
- Terraform describes the cloud resources, such as networks, the cluster and databases, as code. A change to infrastructure gets a pull request and a review, just like application code.
- Prometheus and Grafana are the most widely used monitoring pair for Kubernetes. Prometheus collects numbers over time. Grafana draws them as dashboards.
A sentence that helps: mention one tool you would change and why. For example: "If I started again, I would look at moving logs to a cheaper store, because log costs grew faster than traffic." It shows you judge tools instead of just using them.
7. How many applications, environments, developers, and deployments does your pipeline support?
The short answer
Give real, rounded numbers for all four: applications, environments, developers and deployments per week. Then add one sentence on what that scale forced you to build. The numbers matter less than showing you know them and what they mean.
This sounds like small talk. It is not. Scale decides design. A platform for three services and five developers is a very different job from one for two hundred services and a thousand developers. The interviewer uses your numbers to judge every other answer you give.
Have the four numbers ready:
- Applications. How many deployable services?
- Environments. Which ones? Development, testing, staging, production? Are there short-lived preview environments for each pull request?
- Developers. How many people push code into this pipeline?
- Deployments. How many per day or per week, to production and in total?
A model answer (swap in your own facts):
"Five services and two shared libraries. Three long-lived environments: development, staging and production, plus a preview environment for each open pull request. About twenty-five developers across three teams. Around thirty deployments a week reach production, and about two hundred pipeline runs a day across all branches."
Then add the consequence. For example: "With two hundred runs a day, build time became a real cost. That is why I spent a month on caching, which brought a typical run from fourteen minutes down to five." Now your numbers explain one of your design decisions, and that is exactly what a senior answer sounds like.
If you are unsure of a number, say it is approximate. "About thirty a week" is fine. Inventing a precise number is dangerous, because the next question is often "how did you measure that?"
8. How frequently do you deploy, and how long does a typical change take to reach production?
The short answer
Give your deployment frequency and your lead time. Lead time is the time from a developer committing a change to that change running in production. Say how you measure both, and name the slowest step in the path, because that is where the next improvement lives.
These are two of the four DORA metrics. DORA (DevOps Research and Assessment) is a research group that studied thousands of teams and found a few numbers that predict how well a team delivers software. Question 294 covers all of them. Here you only need two.
Deployment frequency is how often you deploy to production. "Several times a day" and "once every two weeks" describe very different teams.
Lead time for changes is the time between a commit and that commit running in production. It includes everything in between: waiting for review, waiting in a queue, the pipeline itself, waiting for an approval, and the rollout.
How to measure lead time. Every production deployment records which commits it contains. For each commit, subtract the commit time from the deployment time. Take the median, which is the middle value, so one odd week does not distort the number.
A model answer (swap in your own facts):
"We deploy to production about six times a day on weekdays. The median lead time is around three hours. The pipeline itself is only about twenty minutes of that. Most of the time is waiting for code review. So the biggest win was not a faster pipeline. It was smaller pull requests, which get reviewed faster."
This answer shows real understanding. It breaks lead time into parts and finds where the time actually goes. Many people assume a slow pipeline is the problem, measure, and discover the waiting is the problem.
9. What is the most difficult Docker, pipeline, or Kubernetes issue you personally resolved?
The short answer
Tell one real story in four parts: the situation, the symptom, how you found the cause, and what you changed so it never came back. Pick a story where the cause was not obvious, and keep the focus on your reasoning, not on the tools.
This is the most important question on the page. The interviewer wants to watch you think. Prepare one story so well that you can tell it in three minutes and answer any follow-up about it.
Use this shape, often called STAR (Situation, Task, Action, Result):
- Situation. What was happening, and why it mattered.
- Task. What you had to find out or fix.
- Action. How you investigated. This is the longest part. Say what you checked, what you ruled out, and what the evidence showed.
- Result. What changed, with a number, and what you did so it would not happen again.
A model story (swap in your own):
Situation. Every time we deployed
checkout-api, about two hundred customers got "502 Bad Gateway" errors in the first minute. Deploying several times a day made this a daily customer problem.Task. Find why a normal rolling update dropped requests, when Kubernetes is meant to replace pods gracefully.
Action. First I checked whether the errors came from new pods or old pods. The gateway logs showed they came from old pods that were shutting down. So new pods were fine. Something was wrong with how old pods stopped. Second, I read the container's start command. It was written in the "shell form",
CMD npm start. That runs the app as a child of a shell. When Kubernetes sent the stop signal, the shell received it and did not pass it on. The app never knew it should stop, and was killed hard thirty seconds later in the middle of requests. Third, I found a second, smaller cause. Even after the stop signal, the gateway kept sending new requests to the old pod for a few seconds, because the news that the pod was leaving takes a moment to reach every node.Result. I changed the start command to the exec form, so the app itself receives the signal. I added shutdown code that stops taking new requests and finishes the ones in flight. I added a short
preStoppause of five seconds, so the gateway learns about the change before the app starts closing. 502 errors during deploys went from about two hundred per deploy to zero. I also added a check to our pipeline that fails a Dockerfile written with a shell-form start command.
Why this story works: it has two causes, each found by evidence, not guessing. It crosses Docker (how a process receives signals), Kubernetes (how pods are removed) and CI/CD (a new automated check). Questions 49, 103 and 488 explain each piece in depth.
What the interviewer is checking: whether you debug by evidence or by trying random fixes, and whether you fix causes or only symptoms. Question 10 is usually the next question.
10. How did you find the root cause of that issue, rather than just applying a workaround?
The short answer
I collected evidence before changing anything, wrote down what each possible cause would predict, and tested those predictions one by one. I knew I had the root cause when I could make the problem appear and disappear on purpose by changing one thing.
A workaround hides a symptom. A root cause fix removes the reason the symptom happens. In the story from question 9, a workaround would have been "retry failed requests at the gateway". Errors would have dropped, but the app would still be killed mid-request, and the payment calls it was making could be cut in half.
Here is a method you can describe, step by step:
- Collect evidence first. Logs, metrics, events, and the exact time of each failure. Do not change anything yet, because every change destroys some evidence.
- Build a timeline. Line up when the deploy started, when errors began, and when they stopped. In the story, errors began exactly when old pods received the stop signal. That pointed at shutdown, not startup.
- List the possible causes. For each one, write what it would predict. "If new pods were not ready, errors would come from new pods." The logs said old pods. One cause eliminated.
- Ask "why" until you reach a design decision. Why were requests failing? The app was killed mid-request. Why? It never got the stop signal. Why? The shell swallowed it. Why? The Dockerfile used shell form. That last answer is something you can change.
- Prove it. Reproduce the failure in a test environment. Apply the fix. Watch the failure disappear. Remove the fix. Watch it come back. Now you know for certain.
- Prevent it. Add a check, a test or an alert so the same cause cannot come back quietly.
Step 4 is often called the "five whys". It is a habit more than a rule. Stop when the next "why" leaves your control.
A sentence worth saying: "I treat a fix as unproven until I can turn the bug on and off." It tells the interviewer you know the difference between a correlation and a cause.
11. What deployment or reliability metrics do you track, and what have you improved?
The short answer
I track the DORA delivery metrics: how often we deploy, lead time, change failure rate and recovery time. I also track pipeline health, such as run time and flaky test rate, and service health against our SLOs. Then I give one before-and-after number for something I improved.
Group your metrics into three families, so the answer is easy to follow.
1. Delivery metrics (the DORA family). Question 294 explains each one in depth.
- Deployment frequency. How often we ship to production.
- Lead time for changes. Commit to production.
- Change failure rate. What share of deployments cause a problem that needs a fix or a rollback.
- Failed deployment recovery time. How long it takes to recover when a deployment does fail.
2. Pipeline health metrics. These tell you whether the pipeline helps or slows people down.
- Median pipeline duration, and the slow end of it, such as the 90th percentile run.
- Queue time, which is how long a job waits for a machine before it starts.
- Pipeline failure rate, split into "real failures" and "infrastructure failures".
- Flaky test rate, which is tests that pass and fail on the same code.
3. Service reliability metrics. These tell you whether customers are happy.
- Error rate and latency, measured against an SLO (service level objective). An SLO is a target you set, such as "99.9% of checkout requests succeed in under 500 milliseconds over 30 days". Question 630 covers SLOs in full, and question 631 covers the error budgets that come with them.
A model answer (swap in your own facts):
"I report the four DORA metrics monthly. The one I am proudest of is change failure rate. It was around 18%, mostly from config mistakes. We added a schema check for our Helm values and a canary step. Six months later it was around 6%. On the pipeline side, I cut median run time from fourteen minutes to five with layer caching and parallel test jobs."
Always give a before, an after, and the action in between. That is what turns a list of metric names into evidence of impact.
12. How do you separate your own contribution from work done by the rest of the team?
The short answer
I say "we" for decisions the team made together and "I" for the parts I personally designed, wrote or ran. I can point to evidence for my parts, such as the pull requests, the design document or the incident report I wrote.
Interviewers ask this because many candidates blur the line, in both directions. Some take credit for a whole team's work. Others are so modest that they never say what they did. Both make you hard to hire.
Use a simple rule. "We" for choices. "I" for actions.
- "We decided to move to Kubernetes." That was a team decision.
- "I wrote the migration plan and moved the first three services." That was you.
It also helps to name roles honestly:
- "I led this." You drove it and made the main decisions.
- "I built this." You wrote most of it.
- "I contributed to this." You did a clear, smaller part. Say which part.
- "I reviewed this." You were not the author.
A model answer (swap in your own facts):
"The move to GitOps was a team decision. My part was the pilot. I set up Argo CD, moved our first service onto it, and wrote the guide the other teams followed. The other two engineers moved the remaining services. I can walk you through the pilot in detail, and I can explain the rest at a higher level."
That last sentence is powerful. It sets honest expectations about where your deep knowledge is, which makes everything you claim more believable.
13. What happens when a change passes testing but fails in production?
The short answer
First, limit the damage: roll back or switch off the feature flag, and tell people what is happening. Second, find out why production behaved differently from testing, because that gap is the real bug. Third, close the gap with a check, a more realistic test environment, or a safer rollout such as a canary.
Every team meets this. Testing environments are never exactly like production. The answer has three phases, and the order matters.
Phase 1: Stop the harm. Customers come first, the investigation comes second.
- Notice it fast. Alerts on error rate and latency should fire within minutes.
- Roll back to the previous version, or turn off the new code with a feature flag. A feature flag is a switch in configuration that turns a piece of code on or off without a new deployment. Question 285 covers flags.
- Tell people. Post in the incident channel what you know and what you are doing.
Phase 2: Find the gap. Ask: "what is true in production that was not true in testing?" The usual suspects are:
- Data. Production has more data, older data, and stranger data. A query that is fast on a thousand rows is slow on fifty million.
- Configuration. A different environment variable, feature flag, or secret.
- Traffic. More users at once, real usage patterns, and retries.
- Dependencies. A real payment provider instead of a test one, with its own limits.
- Infrastructure. Different resource limits, more replicas, different network rules.
Phase 3: Prevent it. Turn the lesson into something automatic.
- If the gap was data, add a realistic data set to testing, or test the migration on a copy of production data.
- If it was configuration, check configuration in the pipeline and keep environments as alike as possible. Question 453 covers this.
- If it was scale, release to a small share of traffic first. That is a canary release, covered in question 282.
The one-line principle: testing reduces risk, but it cannot remove it. So the real safety net is a fast, practised rollback plus releases that reach a few users before they reach everyone.
14. How do you prevent secrets, vulnerable dependencies, and unsafe configuration from reaching production?
The short answer
With layers of checks at different points. Scanners run on the developer's machine and on every pull request. The built image is scanned. Policy checks run on the deployment configuration. And a final gate in the cluster rejects anything unsafe. No single check catches everything, so each layer covers the gaps of the others.
The idea is called defence in depth. Imagine slices of cheese with holes in them. One slice lets some things through. Stack several slices, and the holes rarely line up. Each check below is one slice.
Secrets (passwords, keys, tokens):
- A pre-commit hook runs a secret scanner on the developer's machine before a commit is even created. A hook is a small script Git runs automatically at certain moments.
- The CI pipeline runs a secret scanner again on every pull request, because hooks can be skipped.
- The source control platform scans every push. GitHub, for example, can block a push that contains a known kind of token.
- Design removes the reason to have secrets in code at all. Applications read secrets at runtime from a vault, and pipelines use short-lived tokens instead of stored keys. Question 268 explains why.
Vulnerable dependencies:
- Software composition analysis (SCA) checks the libraries you use against databases of known vulnerabilities on every pull request. Question 214 defines SCA.
- Image scanning checks the built container image, including the operating system packages inside it.
- Scheduled rescans check images already in production, because new vulnerabilities are found every day in old code.
- Automated update pull requests, from tools like Dependabot or Renovate, keep libraries current so fixes arrive in small steps.
Unsafe configuration:
- Policy checks in CI read Kubernetes files and Terraform code and reject things like containers running as root, or a database open to the internet.
- Admission control in the cluster is the last gate. The cluster itself refuses a pod that breaks the rules, even if it was applied by hand. Question 418 covers this.
The strongest part of the answer is the cluster gate plus image signing. Even if someone skips the pipeline entirely, the cluster only runs images that were signed by the approved pipeline. Question 147 explains how that verification works.
15. If you had to redesign your current delivery process from scratch, what would you keep and what would you change?
The short answer
Keep the parts that proved themselves, and say why. Change the parts that cause the most pain, and say what pain. A good answer names two or three keeps and two or three changes, each tied to a real problem you saw.
This question checks judgment. Anyone can list new tools. The interviewer wants to hear what worked, what hurt, and what you learned.
Things worth keeping (explain why each earned its place):
- Build once, promote the same image. It removed a whole class of "it worked in staging" problems.
- Everything in Git. Application code, pipeline code, deployment configuration and infrastructure all go through review. Any change can be traced and undone.
- Automatic rollback on failed health checks. It turned many bad deployments into non-events.
Things worth changing (each tied to a pain):
- Long-lived shared staging. If teams fight over one staging environment, change to short-lived preview environments, one per pull request, created and destroyed automatically.
- Manual canary watching. If someone stares at dashboards during every release, change to automated canary analysis. A tool compares the new version's error rate and latency with the old one and decides by itself.
- Copy-pasted pipelines. If every repository has its own slightly different pipeline, change to one shared, versioned pipeline template. Question 259 covers this.
- Stored cloud keys in CI. If they still exist, change to short-lived identity federation (OIDC). Question 269 explains how it works.
A model answer (swap in your own facts):
"I would keep build-once-promote, GitOps and our automatic rollbacks. Those three solved real problems and nobody has complained about them since. I would change two things. First, our single shared staging environment. Three teams queue for it, and it is the biggest single delay in our lead time, so I would move to per-pull-request environments. Second, our canary step is a person watching Grafana for fifteen minutes. I would automate the decision with a metrics comparison, so releases stop depending on who happens to be watching."
Close the answer by saying what you would measure to know the redesign worked, for example lead time and change failure rate. It shows you treat changes to a process as experiments, not as opinions.