Platform Engineering Interview Questions
5 questions for junior, mid-level and senior Platform Engineering interviews, with model answers, code examples and common mistakes. Answer each one out loud first, then reveal the answer.
Internal Developer Platform Purpose
// interview question
Your team keeps filing tickets for things like creating new services, setting up databases, and getting access to staging environments. Your CTO asks you to fix this. What would you build, and why?
Sample answer
I would build an Internal Developer Platform (IDP) - a self-service layer that sits on top of your existing infrastructure and lets developers do common tasks without waiting on the platform team. The core idea is simple: instead of a developer opening a ticket that says 'I need a PostgreSQL database for my new service,' they go to a portal or run a CLI command and get one provisioned automatically, with the right security policies, backups, and monitoring already configured. The 'why' matters more than the 'what' here. Every ticket a developer files is blocked time. If it takes 2 days to get a database, that is 2 days of lost productivity. Multiply that across 50 engineers and you are burning weeks of engineering time on things that should take minutes. An IDP typically has these layers: a service catalog (what can I use?), a self-service portal or CLI (how do I get it?), golden paths (pre-approved ways to build things), and an orchestration backend that actually provisions resources through IaC tools like Terraform or Crossplane. The key principle is that you are not removing guardrails. You are encoding them. Developers get freedom to move fast, but every resource they create automatically meets your security, compliance, and cost policies.
Why this matters
This question tests whether a candidate understands the business problem behind IDPs, not just the technology. Weak candidates jump straight to tool names. Strong candidates start with the developer pain point and work backward to a solution. Listen for whether they mention the tension between speed and governance - that is the core challenge an IDP solves.
Code examples
Backstage service catalog entry showing a self-service database request
apiVersion: backstage.io/v1alpha1
kind: Resource
metadata:
name: postgres-standard
description: Standard PostgreSQL instance with backups and monitoring
annotations:
backstage.io/techdocs-ref: dir:.
spec:
type: database
owner: platform-team
lifecycle: production
dependsOn:
- resource:aws-rds-module
providesApis:
- postgres-connection-stringDeveloper self-service workflow before and after an IDP
# BEFORE: Developer opens a Jira ticket, waits 2 days
# "Hey platform team, I need a Postgres DB for my new service"
# Platform engineer manually runs Terraform, shares credentials
# AFTER: Developer runs one command, gets a database in 5 minutes
$ platform db create \
--name orders-db \
--engine postgres \
--size small \
--team checkout-squad
Creating PostgreSQL instance 'orders-db'...
✓ Instance provisioned (db.t3.medium, 20GB)
✓ Backup policy applied (daily, 7-day retention)
✓ Monitoring dashboard created
✓ Connection string stored in Vault at secret/checkout-squad/orders-db
✓ IAM roles configured for checkout-squad members
Connect: psql $(platform db connect orders-db)Common mistakes to avoid
- Describing an IDP as just a UI on top of Kubernetes - it is much broader than container orchestration
- Focusing only on the tools (Backstage, Humanitec, Kratix) without explaining the problem they solve
- Forgetting that an IDP needs to enforce governance, not just speed things up
Likely follow-ups
- How do you decide what to include in your IDP versus what stays as a manual process?
- How would you measure whether your IDP is actually saving developer time?
- What is the difference between an IDP and just writing more Terraform modules?
Answer out loud first, then check yourself against the model answer.
Designing Golden Paths
// interview question
We want our developers to follow best practices, but we do not want to slow them down with mandatory reviews for every infrastructure change. How would you design 'golden paths' in an internal developer platform?
Sample answer
Golden paths are pre-approved, opinionated templates that let developers build things the 'right way' by default. The trick is making the golden path the easiest path, not just the compliant one. Start by looking at what your teams build most often. If 80% of new services are REST APIs with a PostgreSQL database, build a template for exactly that. It should include the Dockerfile, CI/CD pipeline, Terraform for the database, monitoring dashboards, and alerting rules. A developer runs one command and gets a working, production-ready service in minutes. The key design principles: 1. Golden paths are optional, not mandatory. If a team needs something custom, they can go off-path. But going off-path should require more effort, not less. 2. Encode your standards into the template. Do not write a doc that says 'all services must have health checks.' Instead, bake the health check endpoint into the template so it exists from day one. 3. Keep templates versioned and upgradeable. When you update the base template (say, to add OpenTelemetry tracing), teams on older versions should be able to pull in the update without rewriting their service. 4. Use policy-as-code (OPA, Kyverno) as the safety net for off-path cases. If someone deploys without a health check, the admission controller catches it. The goal is that following best practices requires zero extra effort. Breaking them requires a deliberate choice.
Why this matters
This question gets at a fundamental platform engineering tension: how do you provide guardrails without creating bottlenecks? Candidates who have actually built platforms will talk about making the right thing easy, not making the wrong thing hard. Listen for whether they understand the difference between a template and a mandate. The best answers reference real trade-offs, like how to handle template versioning when you have 50 services on v3 of your template and you just shipped v5.
Code examples
Backstage scaffolder template for a golden path microservice
apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
name: golden-path-rest-api
title: REST API Service (Golden Path)
description: Production-ready REST API with database, CI/CD, and monitoring
spec:
owner: platform-team
type: service
parameters:
- title: Service Details
required: [name, team, database]
properties:
name:
title: Service Name
type: string
pattern: '^[a-z][a-z0-9-]*$'
team:
title: Owning Team
type: string
ui:field: OwnerPicker
database:
title: Database Type
type: string
enum: [postgres, mysql, none]
default: postgres
steps:
- id: fetch-skeleton
name: Fetch service skeleton
action: fetch:template
input:
url: ./skeleton
values:
name: ${{ parameters.name }}
team: ${{ parameters.team }}
- id: create-repo
name: Create GitHub repo
action: publish:github
input:
repoUrl: github.com?owner=myorg&repo=${{ parameters.name }}
defaultBranch: main
protectDefaultBranch: true
- id: provision-infra
name: Provision infrastructure
action: custom:terraform-apply
input:
module: modules/service-infra
vars:
service_name: ${{ parameters.name }}
database_type: ${{ parameters.database }}
- id: register
name: Register in catalog
action: catalog:registerOPA policy catching services that skip the golden path health check
# policy/require-healthcheck.rego
package kubernetes.admission
import data.kubernetes.deployments
# Deny deployments without a readiness probe
deny[msg] {
input.request.kind.kind == "Deployment"
container := input.request.object.spec.template.spec.containers[_]
not container.readinessProbe
msg := sprintf(
"Container '%s' in Deployment '%s' has no readiness probe. "
"Use the golden path template or add one manually. "
"Docs: https://platform.internal/docs/health-checks",
[container.name, input.request.object.metadata.name]
)
}Common mistakes to avoid
- Making golden paths mandatory and creating a bottleneck when teams need something the template does not support
- Building templates that are too rigid - every field hardcoded, no room for customization
- Not versioning templates, so updates to the golden path break existing services
Likely follow-ups
- How do you handle upgrading 50 services from template v3 to v5 without breaking them?
- A team says the golden path does not fit their use case. What do you do?
- How do you decide when a one-off request should become a new golden path?
- What metrics tell you whether your golden paths are actually being adopted?
Answer out loud first, then check yourself against the model answer.
Service Catalog and Ownership
// interview question
You are building a service catalog for your IDP. Your company has 200 microservices, and nobody knows who owns half of them. How do you fix this, and what does a good service catalog look like?
Sample answer
A service catalog is the single source of truth for 'what do we run, and who owns it?' Without one, every incident starts with 20 minutes of Slack threads asking 'does anyone know who owns this service?' Here is how I would fix the ownership mess: First, require every service to have a catalog-info.yaml in its repo. This file declares the service name, owning team, dependencies, and API specs. If a repo does not have one, it shows up as 'unowned' in the catalog, which creates social pressure to fix it. Second, automate catalog discovery. Do not rely on people manually registering services. Scan your GitHub org, pull in metadata from Kubernetes (what is actually running), and cross-reference with your cloud provider. If a service is running in production but is not in the catalog, flag it. Third, make the catalog useful, not just a registry. A good service catalog shows: who owns this, what it depends on, its current health, recent deployments, on-call rotation, API docs, and cost. If the catalog is just a list of names, nobody will maintain it. The ownership model matters too. Use team ownership, not individual ownership. People leave. Teams persist. And every service must have exactly one owning team. Shared ownership means no ownership. Tools like Backstage, Cortex, or OpsLevel do this well, but you can start with a simple YAML file per repo and a script that aggregates them.
Why this matters
This question tests real operational experience. Anyone who has dealt with a microservices mess knows that the catalog is the foundation of everything else in an IDP. Without knowing what you run and who owns it, you cannot build self-service, you cannot route incidents, and you cannot track costs. Listen for whether the candidate talks about keeping the catalog accurate over time, not just the initial setup.
Code examples
catalog-info.yaml that lives in each service repo
# catalog-info.yaml - every repo gets one of these
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
name: payments-api
description: Handles payment processing and refunds
annotations:
github.com/project-slug: myorg/payments-api
backstage.io/techdocs-ref: dir:.
pagerduty.com/service-id: P1234ABC
grafana/dashboard-selector: "payments-api"
tags:
- python
- fastapi
- tier-1
links:
- url: https://grafana.internal/d/payments-api
title: Grafana Dashboard
- url: https://myorg.atlassian.net/wiki/spaces/PAY
title: Team Wiki
spec:
type: service
lifecycle: production
owner: team-payments
system: checkout
providesApis:
- payments-api
consumesApis:
- stripe-gateway
- notifications-api
dependsOn:
- resource:payments-db
- resource:payments-redisScript to find unowned services running in production
#!/bin/bash
# Find services running in Kubernetes that are not in the catalog
echo "=== Services in Kubernetes but NOT in catalog ==="
# Get all deployments from Kubernetes
k8s_services=$(kubectl get deployments -A \
-o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' \
| sort -u)
# Get all services registered in Backstage catalog
catalog_services=$(curl -s \
'https://backstage.internal/api/catalog/entities?filter=kind=component' \
| jq -r '.[].metadata.name' \
| sort -u)
# Find the diff
comm -23 <(echo "$k8s_services") <(echo "$catalog_services")
# Example output:
# legacy-auth-proxy
# temp-data-migrator
# unknown-cronjob-handler
# ^^^ These 3 services are running but nobody claimed themCommon mistakes to avoid
- Building a catalog that requires manual registration and then wondering why it is always out of date
- Assigning ownership to individuals instead of teams, so it breaks when someone leaves
- Treating the catalog as a one-time project instead of something that needs ongoing data quality checks
Likely follow-ups
- How do you keep the catalog accurate when teams forget to update their catalog-info.yaml?
- How would you handle the 100 services that currently have no owner? You cannot just assign them randomly.
- What is the difference between a service catalog and a CMDB?
Answer out loud first, then check yourself against the model answer.
Measuring IDP Success and Adoption
// interview question
You have spent six months building an internal developer platform. Your VP of Engineering asks: 'Is this thing actually working? How do we know it was worth the investment?' What do you show them?
Sample answer
You need both quantitative metrics and qualitative signals. Here is what I would track: Developer productivity metrics: - Time from 'I need a new service' to 'it is running in staging.' If this went from 2 weeks to 30 minutes, that is your headline number. - Lead time for changes (DORA metric). How fast can a developer go from commit to production? - Number of self-service requests versus tickets filed to the platform team. If 90% of requests go through self-service, the platform is working. Platform health metrics: - Adoption rate: what percentage of teams are using the golden paths? If only 3 out of 20 teams use it, you have a product problem. - Platform reliability: what is the uptime of your self-service tools? If the platform itself is down, developers go back to filing tickets. - Time-to-onboard: how long does it take a new engineer to ship their first change? This is a killer metric for showing the IDP value. Cost and toil metrics: - Tickets per developer per month to the platform team. This should trend down. - Platform team size relative to total engineering headcount. A good IDP lets you support 200 developers with a team of 5, not 20. Developer satisfaction: - Run a quarterly developer experience survey. Ask: 'How easy is it to get your work done?' Score it 1-10. Track the trend. - Net Promoter Score for internal tools: 'Would you recommend this platform to a colleague at another company?' The most important thing: do not just show numbers. Show the story. 'Six months ago, creating a new service took 2 weeks and 4 tickets. Today it takes 30 minutes and zero tickets. Here is the chart.'
Why this matters
This is a leadership-level question that tests whether a candidate can connect platform work to business outcomes. Many platform engineers build great tools but cannot explain their value to non-technical stakeholders. The best answers include DORA metrics, developer satisfaction data, and a clear before/after narrative. Watch for candidates who only mention technical metrics (uptime, latency) without tying them to developer productivity.
Code examples
Grafana dashboard definition tracking key IDP metrics
# grafana-dashboard-platform-metrics.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: platform-metrics-dashboard
labels:
grafana_dashboard: "true"
data:
platform-metrics.json: |
{
"title": "IDP Health & Adoption",
"panels": [
{
"title": "Self-Service vs Ticket Requests (Weekly)",
"type": "timeseries",
"targets": [{
"expr": "sum(rate(platform_self_service_requests_total[7d]))",
"legendFormat": "Self-service"
}, {
"expr": "sum(rate(platform_ticket_requests_total[7d]))",
"legendFormat": "Manual tickets"
}]
},
{
"title": "Time to First Deploy (New Services)",
"type": "stat",
"targets": [{
"expr": "histogram_quantile(0.50, platform_service_creation_duration_seconds_bucket)",
"legendFormat": "p50 creation time"
}]
},
{
"title": "Golden Path Adoption Rate",
"type": "gauge",
"targets": [{
"expr": "sum(platform_services_on_golden_path) / sum(platform_services_total) * 100",
"legendFormat": "% on golden path"
}]
},
{
"title": "Developer Satisfaction (Quarterly Survey)",
"type": "stat",
"targets": [{
"expr": "platform_developer_satisfaction_score",
"legendFormat": "Satisfaction (1-10)"
}]
}
]
}Script to track platform adoption metrics from the catalog
#!/usr/bin/env python3
"""Weekly IDP adoption report."""
import requests
from datetime import datetime, timedelta
BACKSTAGE_API = "https://backstage.internal/api"
def get_adoption_metrics():
# Total services in catalog
entities = requests.get(
f"{BACKSTAGE_API}/catalog/entities?filter=kind=component"
).json()
total = len(entities)
on_golden_path = sum(
1 for e in entities
if e["metadata"].get("annotations", {})
.get("platform.io/golden-path-version")
)
has_owner = sum(
1 for e in entities
if e.get("spec", {}).get("owner") != "unknown"
)
# Self-service requests this week
week_ago = (datetime.now() - timedelta(days=7)).isoformat()
requests_data = requests.get(
f"{BACKSTAGE_API}/platform/requests?since={week_ago}"
).json()
self_service = sum(1 for r in requests_data if r["type"] == "self-service")
tickets = sum(1 for r in requests_data if r["type"] == "ticket")
print(f"=== IDP Adoption Report ({datetime.now():%Y-%m-%d}) ===")
print(f"Services in catalog: {total}")
print(f"On golden path: {on_golden_path}/{total} ({on_golden_path/total*100:.0f}%)")
print(f"With valid owner: {has_owner}/{total} ({has_owner/total*100:.0f}%)")
print(f"Self-service this week: {self_service}")
print(f"Tickets this week: {tickets}")
print(f"Self-service ratio: {self_service/(self_service+tickets)*100:.0f}%")
# Example output:
# === IDP Adoption Report (2026-04-09) ===
# Services in catalog: 187
# On golden path: 142/187 (76%)
# With valid owner: 179/187 (96%)
# Self-service this week: 34
# Tickets this week: 6
# Self-service ratio: 85%
if __name__ == "__main__":
get_adoption_metrics()Common mistakes to avoid
- Only tracking vanity metrics like 'number of services in the catalog' instead of outcome metrics like time-to-deploy
- Not surveying developers and assuming adoption equals satisfaction
- Presenting raw metrics without the before/after story that leadership needs to justify the investment
Likely follow-ups
- Your golden path adoption is at 40% after six months. What do you do?
- How do you separate the impact of the IDP from other improvements happening at the same time?
- A team lead says their developers hate the platform. How do you respond?
- At what point do you decide the IDP is not working and you should change direction?
Answer out loud first, then check yourself against the model answer.
Platform API and Orchestration Layer
// interview question
You are designing the orchestration layer for your IDP. A developer clicks 'Create New Service' and behind the scenes it needs to create a GitHub repo, provision a database, set up a CI/CD pipeline, configure monitoring, and register the service in the catalog. How do you architect this?
Sample answer
The orchestration layer is the engine of your IDP. It takes a high-level intent ('I want a new service') and breaks it into steps that talk to different systems. The architecture I would use: 1. Platform API: A single API that accepts requests from the UI, CLI, or Backstage. It validates the request, checks permissions, and kicks off a workflow. This should be a proper API with versioning, not a collection of scripts. 2. Workflow engine: Use something like Argo Workflows, Temporal, or even a simple state machine to orchestrate the steps. Each step (create repo, provision DB, set up CI) is an independent action. The workflow engine handles ordering, retries, and partial failures. 3. Resource providers: Each backend system (GitHub, AWS, ArgoCD) gets its own provider with a standard interface. This is where Crossplane or Terraform do the heavy lifting. The orchestrator does not talk to AWS directly - it tells the Terraform provider 'create this database' and the provider handles it. 4. State tracking: Every request gets a status page. The developer can see 'repo created, database provisioning, CI pipeline pending.' If something fails at step 3, you need to be able to retry from that point, not start over. The hard part is partial failures. What happens when the repo is created but the database fails? You need compensating actions (delete the repo) or the ability to resume from the failed step. Most teams get this wrong on v1 and have to rebuild it. For the Kubernetes-native approach, Crossplane with compositions works well. You define a composite resource that represents 'a service' and Crossplane reconciles all the child resources. The Kubernetes reconciliation loop handles retries for free.
Why this matters
This is a system design question that separates people who have built platforms from people who have read about them. The orchestration layer is where most IDP projects struggle. Weak candidates describe a linear script. Strong candidates immediately talk about partial failures, idempotency, and state tracking. The best candidates have battle scars from a workflow that failed halfway through and left orphaned resources everywhere.
Code examples
Crossplane Composition defining what 'a service' means in your platform
apiVersion: apiextensions.crossplane.io/v1
kind: Composition
metadata:
name: service.platform.example.com
spec:
compositeTypeRef:
apiVersion: platform.example.com/v1alpha1
kind: Service
resources:
# 1. GitHub repository
- name: repo
base:
apiVersion: repo.github.upbound.io/v1alpha1
kind: Repository
spec:
forProvider:
visibility: private
hasIssues: true
autoInit: true
template:
- owner: myorg
repository: service-template
patches:
- fromFieldPath: spec.name
toFieldPath: metadata.name
# 2. PostgreSQL database
- name: database
base:
apiVersion: rds.aws.upbound.io/v1beta1
kind: Instance
spec:
forProvider:
engine: postgres
engineVersion: "15"
instanceClass: db.t3.micro
allocatedStorage: 20
backupRetentionPeriod: 7
patches:
- fromFieldPath: spec.name
toFieldPath: "metadata.name"
transforms:
- type: string
string:
fmt: "%s-db"
- fromFieldPath: spec.database.size
toFieldPath: spec.forProvider.instanceClass
transforms:
- type: map
map:
small: db.t3.micro
medium: db.t3.medium
large: db.r6g.large
# 3. ArgoCD Application for GitOps
- name: argocd-app
base:
apiVersion: kubernetes.crossplane.io/v1alpha1
kind: Object
spec:
forProvider:
manifest:
apiVersion: argoproj.io/v1alpha1
kind: Application
spec:
project: default
source:
repoURL: "" # patched
path: k8s/
targetRevision: main
destination:
server: https://kubernetes.default.svc
patches:
- fromFieldPath: spec.name
toFieldPath: spec.forProvider.manifest.metadata.nameDeveloper creates a full service with one YAML file
# This is all the developer writes.
# The platform handles everything else.
apiVersion: platform.example.com/v1alpha1
kind: Service
metadata:
name: orders-api
namespace: checkout-team
spec:
name: orders-api
team: checkout
language: go
database:
enabled: true
engine: postgres
size: small
monitoring:
enabled: true
slo:
availability: "99.9"
latencyP99Ms: 200
# $ kubectl apply -f service.yaml
# service.platform.example.com/orders-api created
#
# $ kubectl get service.platform orders-api
# NAME REPO DATABASE CICD MONITORING READY
# orders-api True True True True TrueCommon mistakes to avoid
- Building a linear script that breaks halfway through and leaves orphaned resources with no way to clean up
- Not tracking the state of each step, so when something fails you have to manually figure out what was already created
- Trying to build the orchestration from scratch instead of using existing workflow engines like Temporal or Argo Workflows
Likely follow-ups
- The database provisioning step fails after the repo is already created. What happens next?
- How do you make this orchestration idempotent so retrying a failed request does not create duplicate resources?
- Why would you choose Crossplane over Terraform for this? When would Terraform be the better choice?
- How do you handle day-2 operations like scaling the database or rotating credentials through this same layer?
Answer out loud first, then check yourself against the model answer.
More interview topics
Also worth your time on this topic
Building an Internal Developer Platform from Scratch
A step-by-step guide to designing and building an internal developer platform that gives your teams self-service infrastructure, faster deployments, and fewer tickets to the platform team.
Internal Developer Platform Checklist
A step-by-step checklist for designing and building an internal developer platform (IDP) that gives your engineers self-service access to infrastructure, environments, and deployments without filing tickets.
60-120 minutes
Helm Charts and Kubernetes Package Management
Learn Kubernetes application deployment and management using Helm charts with templates, values, and lifecycle management.
90 minutes