GnoseedGnoseed
Platform Engineer interview prep · Updated September 2026

Platform Engineer Interview Questions and Answers

Weighted toward what candidates report being asked

Most platform engineering prep online teaches the discourse — golden paths, developer portals, platform as a product. Candidates report being asked to debug a pod, read someone else's Terraform and explain what an inode holds. These 41 questions follow the second list, and you answer each one out loud before the model answer and its checklist appear.

  • Free, no sign-up
  • Works offline
  • Every answer sourced
Observability, SLOs & Reliability Craft Open answer

I'm showing you a dashboard for a service you've never seen. How do you read it, and what would you alert on?

A strong reply covers

  • Check what each panel measures and its time range before drawing conclusions from the shape
  • Read the four golden signals together — traffic, errors, latency, saturation — rather than one panel in isolation
  • Check whether latency is an average or a percentile; averages hide the tail, and percentiles cannot be averaged across instances
  • Page on user-visible symptoms tied to an SLO and error budget, not on causes like CPU — the exception is imminent unavoidable failure (disk filling, cert expiring), where waiting for the symptom means waiting for the outage
  • Keep resource and saturation metrics as diagnostic context for whoever gets paged

Common trap: narrating every panel you can see. They are testing prioritisation — say what you would look at first and why, and what you would deliberately ignore.

open-answer questions
41
modules
5
level range
Mid → Senior
every answer cites a source
Sourced
What every card gives you

What the reveal actually gives you

Every card names what a strong answer covers, what the interviewer is listening for, and the trap that catches people. The checklist is the part that matters: it tells you which half of your answer was vague, which is precisely where the follow-up goes.

The question alone

No options, no hints. It appears by itself, so you have to generate the answer — exactly as you will in the room.

A grading checklist

The points a strong reply covers. Missed two of five? That is a "didn't know", however familiar the answer felt.

What is being tested

Every card names what the interviewer is really checking, so you answer the question behind the question.

The common trap

The plausible answer that quietly costs you the round — named up front so you do not walk into it.

Try it now

12 of the questions, published in full

Answer each one out loud before you open it — that is the whole exercise. The reveal gives you the model answer, the points a strong reply covers, what the interviewer is really testing, and the trap to avoid. All 41 questions are free in the app.

Kubernetes Operational Depth

3 questions

A pod is stuck in CrashLoopBackOff. Walk me through how you'd troubleshoot it.

I'd start with the previous container's logs — kubectl logs --previous, because during the backoff no container is running for plain logs to read. Then the Events in describe, since image pull, mount and probe failures never reach the container's output. On exit codes I'm careful: 137 is 128+9, so it took SIGKILL — usually the OOM killer, but describe confirms that with Reason OOMKilled rather than me guessing. From there it's config, a dependency, a liveness probe, or an init container.

Key points you should have covered

  • Read the previous container's logs — during backoff nothing is running, so plain kubectl logs has nothing to show
  • Read the Events in describe: image pull, mount and probe failures never reach the container logs
  • 137 is 128+9 (SIGKILL) — confirm OOM via Reason: OOMKilled, don't infer it; codes below 128 are the application's own status
  • Separate the app crashing from a liveness probe killing a healthy process, and check init containers on their own
  • CrashLoopBackOff names the backoff delay, not the failure — the cause is always elsewhere

What the interviewer is checking: whether you have a method rather than a list of commands. Strong candidates narrow the space with each step; weak ones recite kubectl commands in a fixed order regardless of what they found.

Common trap: reading 137 as proof of an OOM kill. It only says the process was SIGKILLed — the kubelet also sends that to a container which outlives its termination grace period.

Source

kube-proxy stops running on a node. What breaks, and what keeps working?

Existing traffic mostly keeps flowing, because kube-proxy programs the node's iptables or IPVS rules rather than forwarding packets itself — the rules already in place stay there. What breaks is anything new: a Service whose endpoints change, a scaled or rescheduled pod, a newly created Service. Those rules never get written, so traffic to that Service keeps going to endpoints that may be gone. Pod-to-pod traffic by IP is unaffected, since that's the CNI's job, not kube-proxy's.

Key points you should have covered

  • kube-proxy writes routing rules (iptables/IPVS); it is not in the data path itself
  • Existing rules survive, so established Service routing continues to work
  • Endpoint changes stop propagating — scaled, rescheduled or new pods are not picked up
  • Traffic can be sent to dead endpoints because nothing updates the rules
  • Pod-to-pod networking is the CNI's responsibility and is unaffected

What the interviewer is checking: whether you can separate the control plane from the data path. The revealing part of the answer is what keeps working, not what breaks.

Common trap: saying all Service traffic stops immediately. That describes a component in the packet path, which kube-proxy is not.

Source

What are the pod QoS classes, and what do they actually decide?

There are three, and you don't set them — the kubelet derives them from your requests and limits. Guaranteed means every container has requests equal to limits for both CPU and memory; Burstable means requests are set but don't match limits; BestEffort means neither is set. What they decide is who dies first: under node memory pressure the kubelet evicts BestEffort pods before Burstable, and Guaranteed last. So it's an eviction ranking you get as a side effect of how you sized the pod.

Key points you should have covered

  • Guaranteed, Burstable, BestEffort — derived by the kubelet, never set directly
  • Guaranteed requires requests == limits for CPU and memory on every container
  • The class drives eviction order under node pressure: BestEffort first, Guaranteed last
  • It is a consequence of how you sized the pod, which is why platform defaults matter

What the interviewer is checking: whether you connect resource specs to what happens on a node under pressure — the practical reason a platform sets defaults and a LimitRange.

Common trap: describing QoS as a scheduling priority. Scheduling order comes from PriorityClass and preemption; QoS is about eviction once the node is already under pressure.

Source

Linux, Networking & Git Fundamentals

3 questions

What does an inode hold, and why does that matter when a disk fills up?

An inode holds a file's metadata — type, permissions, owner, timestamps, size, link count and the pointers to its data blocks — but not its name. The name lives in the directory entry that points at the inode, which is why a hard link is just a second name for the same inode. For a full disk that gives two cases beyond running out of blocks: on ext4 the inode pool is fixed at mkfs time so you can exhaust inodes while space remains, and a deleted file still held open by a process keeps its blocks, because the link count and the open descriptor both have to go before anything is freed.

Key points you should have covered

  • Metadata, link count and block pointers; the filename is NOT in the inode
  • The directory entry maps a name to an inode number, so a hard link is another entry for the same inode
  • On ext2/3/4 the inode pool is fixed at mkfs time and exhausts independently of free blocks (df -i shows it); XFS allocates dynamically and btrfs and ZFS have no fixed limit, so know your filesystem before trusting df -i
  • Space is reclaimed only when the last link and the last open descriptor are gone — a deleted-but-open file makes df and du disagree, and lsof +L1 finds it

What the interviewer is checking: whether you understand the filesystem a layer below the commands. It is a fast way to separate people who have debugged a full disk from people who have only read about one.

Common trap: answering "it's a file's metadata" and stopping. The interesting half is the consequence — and claiming inodes are always a fixed pool is wrong on XFS and btrfs.

Source

How many usable host addresses are in a /23, and how do you work that out?

A /23 leaves 9 host bits, so 512 addresses. In classic subnetting two are unusable — the network address and the broadcast — which gives 510 usable hosts. In a cloud VPC the number is lower again because the provider reserves several per subnet; AWS takes five, so a /23 there gives 507. The way I get to it is the host-bit count rather than a memorised table: 32 minus the prefix is the exponent.

Key points you should have covered

  • 32 − 23 = 9 host bits, so 2^9 = 512 addresses
  • Classic subnetting: minus network and broadcast = 510 usable
  • Cloud subnets reserve more — AWS reserves 5 per subnet, so 507 there
  • Show the method (host bits) rather than reciting a table

What the interviewer is checking: whether you can do subnet arithmetic on the spot, which is a standing screen question for infrastructure roles: employer-published screens routinely list networking and network security among their named topics.

Common trap: giving 512 as the usable count, or giving the textbook 510 for a cloud subnet where the provider's reservations make it wrong.

Source

How does git cherry-pick work, and can you cherry-pick a branch?

It takes the change a commit introduced and applies it on top of your current HEAD as a new commit — new SHA, new parent, same diff. You cannot cherry-pick a branch as such, because a branch is just a pointer to a commit; what you can do is give it a commit range and get each one applied in turn. The consequence worth stating is that the change now exists as two different commits, so a later merge can conflict or the fix can quietly appear twice in the history.

Key points you should have covered

  • It replays a commit's diff onto HEAD as a new commit with a new SHA
  • A branch is a pointer, so there is nothing to pick — but a commit range works and applies them in order
  • The same change now exists twice in history, which can conflict on a later merge
  • Fine for a hotfix onto a release branch; a sign of trouble if it is your normal integration mechanism

What the interviewer is checking: whether you understand commits as objects rather than as positions in a timeline. The duplicate-change consequence is the part that shows you have lived with it.

Common trap: saying yes to cherry-picking a branch. The question is worded that way on purpose — it is checking whether you know what a branch actually is.

Source

IaC, CI/CD & Containers

2 questions

Someone changed infrastructure by hand in the cloud console that Terraform manages. How do you deal with the drift?

First a plan, to see exactly what diverged — it refreshes its in-memory view against the real resources unless you pass -refresh=false, and shows the difference before anything changes. Then it's a decision rather than a reflex: if the change was wrong, apply brings the resource back to the declared state; if it was legitimate, I'd use a -refresh-only plan to accept it into state and write it into the configuration so the code is true again. The lasting fix is removing the ability to do it by hand, so the pipeline is the only writer.

Key points you should have covered

  • Run a plan first; it refreshes its in-memory view (unless -refresh=false) and shows the diff before changing anything
  • Decide whether the manual change was wrong (revert with apply) or right (accept and codify it)
  • Know plan/apply -refresh-only as the purpose-built way to take legitimate drift into state without applying config changes
  • Never hand-edit the state file to make a diff disappear
  • For a resource created entirely outside Terraform, use the config-driven import block (1.5+) so it appears in a plan, not the state-only import command

What the interviewer is checking: whether you reach for a decision or for a command. Both outcomes — revert and codify — are correct depending on the change, and saying so is the answer they want.

Common trap: answering only "apply to overwrite it". That is right about half the time and destroys a legitimate emergency fix the other half.

Source

What's the difference between CMD and ENTRYPOINT?

ENTRYPOINT is the command the container always runs; CMD supplies the default arguments to it. So arguments you pass to docker run replace CMD but are appended to ENTRYPOINT — overriding the entrypoint itself needs the --entrypoint flag. In practice I put the binary in ENTRYPOINT in exec form and the default flags in CMD, which gives an image that behaves like a command-line tool. Exec form matters too: shell form wraps the process in a shell, and then signals go to the shell instead of your application.

Key points you should have covered

  • ENTRYPOINT is the executable; CMD provides its default arguments
  • docker run arguments replace CMD but are appended to ENTRYPOINT; --entrypoint overrides the entrypoint
  • Exec form (JSON array) runs the binary as PID 1; shell form interposes a shell
  • With shell form, SIGTERM reaches the shell rather than your app, so graceful shutdown silently breaks

What the interviewer is checking: the signal-handling consequence. That is what turns this from trivia into the reason a pod takes 30 seconds to terminate.

Common trap: describing them as interchangeable ways to start a process. The override behaviour and PID 1 signalling are the whole answer.

Source

Observability, SLOs & Reliability Craft

2 questions

I'm showing you a dashboard for a service you've never seen. How do you read it, and what would you alert on?

Before reading any value I'd check what the panels actually measure and over what time range, because a five-minute window and a seven-day window tell different stories. Then the golden signals together — traffic, errors, latency and saturation — since errors rising while traffic drops means something quite different from both rising, and I'd check whether latency is an average or a percentile, because an average hides the tail users complain about. For paging I'd alert on user-visible symptoms against an SLO and its error budget, keeping cause metrics as context — with the exception of imminent, unavoidable failure like a disk projected to fill or a certificate expiring.

Key points you should have covered

  • Check what each panel measures and its time range before drawing conclusions from the shape
  • Read the four golden signals together — traffic, errors, latency, saturation — rather than one panel in isolation
  • Check whether latency is an average or a percentile; averages hide the tail, and percentiles cannot be averaged across instances
  • Page on user-visible symptoms tied to an SLO and error budget, not on causes like CPU — the exception is imminent unavoidable failure (disk filling, cert expiring), where waiting for the symptom means waiting for the outage
  • Keep resource and saturation metrics as diagnostic context for whoever gets paged

What the interviewer is checking: whether you can be handed unfamiliar telemetry and reason about it, which is most of the job. This is often run as a live exercise with a real dashboard rather than as a spoken question.

Common trap: narrating every panel you can see. They are testing prioritisation — say what you would look at first and why, and what you would deliberately ignore.

Source

A stakeholder asks you to guarantee 100% availability. How do you respond?

I'd say it is not purchasable at any budget, and explain why rather than just refusing: every dependency, network and deploy has a failure rate, and each additional nine costs more than the last while returning less. Then I'd redirect the conversation to what they actually want, which is usually that a specific critical flow does not fail visibly at a specific time. That is answerable — you can protect the checkout path with a tighter SLO, graceful degradation and a fallback, and accept less for the parts nobody notices.

Key points you should have covered

  • 100 % is unachievable: dependencies, networks and change all carry failure rates
  • Each extra nine costs disproportionately more and returns less
  • The user's own network and device already exceed your error budget, so they cannot perceive the difference
  • Redirect to the real requirement: which flow, at what time, and what does visible failure mean there
  • Differentiate by criticality rather than promising one number for everything

What the interviewer is checking: whether you can push back on an unreasonable requirement without being obstructive. The answer they want is a redirect, not a lecture and not a yes.

Common trap: agreeing and promising to try. It sets up a guaranteed breach and destroys the credibility of every number you quote afterwards.

Source

Interview Rounds & Platform Judgement

2 questions

Tell me about something you deliberately chose not to build into your platform.

One team asked us to run their bespoke data-reconciliation job as a platform service. I declined, because the first question is whether something off-the-shelf or an existing internal service already does it, and the second is leverage — this served one team and was really their domain logic wearing platform clothing, so owning it would have added surface everyone maintains and one team benefits from. What I offered instead was a namespace, a pipeline template and a runbook they own, and I said we would revisit if a second and third team asked for the same thing.

Key points you should have covered

  • Name one concrete request: who asked, what you decided, what you offered instead, and what happened next
  • Ask first whether a managed service or an existing internal team already provides it, before deciding to own anything
  • Then apply leverage: does this serve many teams or one? (a compliance or security mandate can override that and belong to the platform anyway)
  • Every capability the platform owns carries permanent maintenance, on-call and cognitive cost
  • Say no with an alternative, and let repeated demand from several teams be the trigger to reconsider

What the interviewer is checking: whether you understand that a platform's scope is a product decision with a cost, rather than a collection of everything anyone asked for. Saying no well is the senior signal here.

Common trap: answering with a framework and no example. Candidates prepare what they built and get caught by the inverse — have a specific instance ready.

Source

Walk me through a platform you built.

I'd frame it as a product story rather than a tour of the stack: who the users were, what specifically was slow or painful before, what we built first and why that, and what measurably changed — time to first deploy, or how many teams moved without being told to. Then the honest part, which is what I would do differently: where we abstracted too early, which capability nobody adopted, what we had to deprecate. The tooling gets a sentence, because the decisions are the interesting content and the tools are replaceable.

Key points you should have covered

  • Lead with users and the problem, not the technology stack
  • Say what you built first and why that was the first thing
  • Quantify the change: onboarding time, adoption, deploy frequency, incidents avoided
  • Include what failed or went unadopted, and what you deprecated
  • Be clear about your own contribution versus the team's

What the interviewer is checking: seniority. A list of tools reads as junior; a narrative of decisions with evidence and regrets reads as someone who has owned something. This is reported as the round candidates under-prepare most.

Common trap: describing the architecture in detail and never mentioning whether anyone used it. Adoption is the outcome they are listening for.

Source

That is 12 of 41. The rest are in the app, on a schedule that brings back the ones you fumble.

Practise all 41
The full set

41 questions across 5 modules

Junior through senior, scenario-led where a real interview would be. Drill one module on its own, or let the schedule mix them.

Practise all 41
9 questions

Kubernetes Operational Depth

The debugging and rollout questions platform interviews open with

8 questions

Linux, Networking & Git Fundamentals

The layer beneath the tooling — the second-most-asked area in real interviews

8 questions

IaC, CI/CD & Containers

Reading and running the delivery machinery — including someone else's Terraform

8 questions

Observability, SLOs & Reliability Craft

Reading unfamiliar telemetry and defending what you page on

8 questions

Interview Rounds & Platform Judgement

The design round, the take-home defence, and the senior questions about scope

Recently entered interviews
Go deeper

Interview prep tests the talking. The path builds the knowledge.

These questions tell you where you are thin. The Platform Engineer path is where you fix it — 8 decks in sequence, from the shell to observability.

Start the Platform Engineer path
Platform Engineer path8 topics · 834 cards
  1. 1Kubernetes Basics
  2. 2Terraform Associate: Fundamentals
  3. 3GitOps with Argo CD & Flux
  4. 4K8s Ops: Scheduling & Resources
  5. 5Platform Engineering
  6. 6Secrets Management
  7. 7Kyverno — Kubernetes Policy Engine
  8. 8OpenTelemetry
FAQ

Common questions

Are these the questions actually asked in platform engineering interviews? +

They follow the themes that recur in first-hand accounts — candidates writing up their own interviews, and the interview guides employers publish themselves. Across those sources the weight sits on Kubernetes debugging, Linux and systems fundamentals, networking, Terraform, containers and CI/CD, with observability and reliability close behind. That is what this deck is weighted toward. No list predicts a specific company's questions; what it can do is make sure none of the standard ground catches you cold.

Why is there so little about golden paths, Backstage and platform-as-a-product? +

Because candidate reports and employer-published interview guides barely mention them, while prep sites are full of them. Those ideas matter for doing the job and they carry the discipline's vocabulary, so the deck keeps a small amount of that material — but it is labelled as what the field argues about rather than as what you will be asked. If you want that side in depth, the DevOps interview set and the Platform Engineering deck both go further into it.

How is this different from the DevOps interview set? +

They barely overlap in practice. The DevOps set is about rationale and culture — why trunk-based development, when canary rather than blue-green, what DORA measures. This one is the operational layer that platform interviews actually probe: debugging a pod, reading a module someone else wrote, subnet arithmetic, and what you would look at first on an unfamiliar dashboard. Working through both is reasonable; they are not two versions of the same content.

Do I need to have run a platform to use this? +

No, but it assumes working Kubernetes and cloud familiarity — you should know what a Pod, a Service and a Deployment are before starting. The senior questions in the rounds module do ask about decisions you have made, so if you have never owned a platform, treat those as preparation for what to look for rather than as questions with a memorised answer.

Why is there no multiple choice? +

Because interviews have no multiple choice. Picking the right answer from four options is recognition; an interview demands you generate the answer from nothing, out loud, while someone watches. These cards hide everything until you commit, which trains the skill you are actually going to use.

How many questions are there in total? +

The full deck has 41 questions across 5 modules. A curated selection is published on this page in full; the rest are available free in the app.

Are the answers checked? +

Every card cites a primary source — the Kubernetes, Terraform, Docker, Git or Linux manual pages, or the Google SRE books — and each answer was reviewed against that source before publication. Where something is genuinely contested, such as whether an exhausted error budget should stop feature work, the card says so instead of picking a side.

Two weeks, twenty minutes a day

Answer out loud, then check yourself against the checklist. The questions you fumble keep coming back until they are no longer the ones you fumble. Free, no sign-up, works offline.

Start learning free