Senior DevOps Engineer Interview Preparation Guide - FAANG Standards

DevOps Engineer

Senior

7 rounds

Updated 6/16/2026

This guide is based on general FAANG interview practices and may not reflect specific company procedures.

The Senior DevOps Engineer interview at FAANG-standard companies typically follows a multi-round process designed to assess technical depth, system design thinking, infrastructure architecture expertise, leadership and mentorship capabilities, and cultural alignment. The process evaluates not only hands-on technical skills but also the ability to design and own large-scale infrastructure projects, mentor junior team members, and drive technical decisions within the team.

Interview Rounds

Recruiter Screening Call

30 min3 focus topicsbehavioral

Technical Phone Screen - Infrastructure and Scripting

60 min5 focus topicstechnical

What to Expect

Technical assessment conducted by a senior engineer or technical lead to evaluate your core DevOps technical skills. This round focuses on your hands-on experience with infrastructure, scripting, automation, and problem-solving abilities. You may be asked to discuss infrastructure design decisions, walk through your automation scripts, explain how you've solved infrastructure challenges, or discuss your experience with specific tools and technologies. This may involve live coding or problem-solving exercises on a shared platform.

Tips & Advice

Be prepared to write or discuss infrastructure-as-code in languages like Python, Bash, or Go. Expect questions about cloud platform APIs, infrastructure automation patterns, and how you'd solve specific infrastructure problems. Think out loud when problem-solving. Ask clarifying questions before diving into solutions. Focus on scalability, reliability, and maintainability in your responses. Discuss trade-offs between different approaches. Be ready to explain your shell scripting and automation code in detail. Demonstrate knowledge of error handling and edge cases.

Focus Topics

API Integration and Infrastructure Orchestration

Understanding of cloud platform APIs, how to programmatically interact with infrastructure, and how to orchestrate complex infrastructure workflows using APIs and SDKs.

Practice Interview

Study Questions

Problem-Solving and Infrastructure Troubleshooting

Systematic approach to diagnosing and resolving infrastructure problems. Experience with monitoring, logging, and troubleshooting tools. Ability to think through complex failure scenarios and identify root causes efficiently.

Practice Interview

Study Questions

Infrastructure as Code Implementation (Terraform, CloudFormation, ARM Templates)

Deep understanding of IaC tools and practices including state management, module design, version control integration, and best practices for maintaining IaC. Ability to write idempotent, reusable infrastructure code.

Practice Interview

Study Questions

Cloud Platform Fundamentals (AWS, Azure, or GCP)

Deep knowledge of at least one major cloud platform including compute, networking, storage, databases, security, and management services. Understanding of platform-specific tools, SDKs, and APIs.

Practice Interview

Study Questions

Shell Scripting and Automation (Bash, Python, Go)

Proficiency in writing robust automation scripts with proper error handling, logging, and performance optimization. Experience automating common infrastructure tasks and understanding scripting best practices for production use.

Practice Interview

Study Questions

Technical Round 1 - CI/CD Pipeline Design and Automation

60 min5 focus topicstechnical

What to Expect

This round focuses on your expertise in designing, implementing, and managing continuous integration and continuous deployment pipelines. You'll be evaluated on your understanding of CI/CD best practices, experience with CI/CD tools (Jenkins, GitLab CI, GitHub Actions, CircleCI, etc.), ability to design resilient pipelines, and how you've automated the software delivery process in your previous roles. Expect questions about pipeline architecture, failure handling, security practices in pipelines, and optimization for developer productivity.

Tips & Advice

Come prepared with detailed examples of CI/CD pipelines you've designed or significantly improved. Discuss the reasoning behind your architectural choices and trade-offs you considered. Be ready to talk about failure scenarios and how your pipeline handles them gracefully. Discuss integration with version control, artifact management, and deployment strategies. Explain how you ensure security throughout the pipeline, handle secrets securely, and implement compliance checks. Think about edge cases like rollback scenarios, concurrent deployments, and deployments at high scale. Demonstrate understanding of improving developer feedback loops and deployment frequency.

Focus Topics

Artifact Management and Versioning

Understanding of artifact repositories (Docker Registry, Artifactory, Nexus, etc.), versioning strategies, semantic versioning, artifact promotion through environments, and integration with version control systems.

Practice Interview

Study Questions

Security and Secrets Management in CI/CD

Implementation of security controls throughout the pipeline including secret management strategies, credential rotation, artifact scanning, vulnerability assessment, and compliance checks without exposing sensitive data.

Practice Interview

Study Questions

CI/CD Pipeline Architecture and Design Patterns

Ability to design resilient, scalable CI/CD pipelines supporting various application types. Understanding of different pipeline patterns (monolithic vs. modular), stage organization, dependency management, and how to structure pipelines for different deployment scenarios.

Practice Interview

Study Questions

Deployment Strategies and Release Management

Deep knowledge of deployment strategies including blue-green, canary, rolling deployments, and feature flags. Understanding of orchestrating deployments across multiple environments and ensuring zero-downtime deployments with rollback capabilities.

Practice Interview

Study Questions

CI/CD Tools and Platforms (Jenkins, GitLab CI, GitHub Actions)

Hands-on experience with modern CI/CD tools and platforms. Understanding of tool selection criteria, configuration best practices, plugin ecosystems, scalability considerations, and integration with other infrastructure tools.

Practice Interview

Study Questions

Technical Round 2 - Containerization and Kubernetes Orchestration

60 min6 focus topicstechnical

What to Expect

This round evaluates your expertise with containerization technologies (Docker) and container orchestration platforms, primarily Kubernetes. You'll discuss container architecture, image building and management, Kubernetes cluster design, networking, storage, resource management, and how you've used these technologies in production at scale. Expect hands-on questions about troubleshooting containerized systems, optimizing container deployments, and designing container-based infrastructure. May include practical exercises related to Kubernetes troubleshooting or configuration.

Tips & Advice

Be deeply familiar with Docker and Kubernetes fundamentals and advanced concepts. Be prepared to discuss container image best practices, security considerations, optimization, and multi-architecture builds. Discuss your experience running containers in production at scale. Explain how you handle networking, storage persistence, logging, and monitoring in containerized environments. Be ready to discuss Kubernetes concepts like deployments, stateful sets, ingress, network policies, resource management, and cluster upgrades. Share specific production incidents and how you resolved them. Understand Kubernetes security models and best practices.

Focus Topics

Kubernetes Storage and Persistent State

Knowledge of Kubernetes storage solutions, persistent volumes, storage classes, CSI drivers, and how to manage stateful applications in Kubernetes. Understanding of backup strategies and disaster recovery for Kubernetes data.

Practice Interview

Study Questions

Container and Kubernetes Security Best Practices

Understanding of container security including image scanning, runtime security, network policies, RBAC, pod security policies, admission controllers, and compliance in containerized environments.

Practice Interview

Study Questions

Kubernetes Networking and Service Management

Understanding of Kubernetes networking model, services, ingress controllers, network policies, and service mesh concepts (Istio, Linkerd). Ability to design networking for complex Kubernetes deployments with security in mind.

Practice Interview

Study Questions

Kubernetes Architecture and Cluster Design

Comprehensive understanding of Kubernetes architecture including control plane components, worker nodes, etcd, and how they work together. Knowledge of cluster design, multi-cluster strategies, cluster upgrades, and high-availability cluster setup.

Practice Interview

Study Questions

Kubernetes Workload Management and Deployments

Proficiency with Kubernetes workload resources including Pods, Deployments, StatefulSets, DaemonSets, and Jobs. Understanding of rolling updates, autoscaling, horizontal pod autoscaling, resource requests, limits, and workload scheduling.

Practice Interview

Study Questions

Docker and Container Image Management

Deep expertise in Docker including image building, optimization for size and performance, layer caching strategies, security scanning, and best practices. Understanding of multi-stage builds, image registries, and container image versioning and tagging strategies.

Practice Interview

Study Questions

System Design Round - Large-Scale Infrastructure Architecture

90 min6 focus topicssystem design

What to Expect

This is a comprehensive system design round where you're given a complex infrastructure problem and asked to design a solution from scratch. You might be asked to design a large-scale deployment platform, build a disaster recovery solution, architect a multi-region infrastructure, design an observability system, or optimize infrastructure costs. The interviewer will focus on your ability to think holistically about infrastructure, consider multiple dimensions, understand trade-offs, make sound architectural decisions, and communicate your thinking clearly. This round evaluates your senior-level system design and infrastructure architecture capabilities.

Tips & Advice

Start by asking clarifying questions to understand requirements, scale expectations, constraints, budget, and SLAs. Draw detailed diagrams to communicate your architecture. Break down the problem into logical components and discuss how they interact. Discuss trade-offs explicitly: cost vs. performance, complexity vs. reliability, consistency vs. availability, time-to-market vs. technical perfection. Consider non-functional requirements including scalability, reliability, security, maintainability, and cost. Discuss monitoring, logging, alerting, and disaster recovery as integral parts from the start. Be prepared to dig deeper on specific components if asked. Mention relevant cloud services and open-source tools. Think about operational aspects: deployment, upgrades, troubleshooting, and incident response. Consider capacity planning, growth projections, and cost optimization throughout.

Focus Topics

Operational Excellence and Cost Optimization

Design of infrastructure that is operationally efficient and cost-effective. Understanding of automation, self-healing, resource optimization, cost monitoring, and right-sizing strategies.

Practice Interview

Study Questions

Security and Compliance in Infrastructure Design

Incorporation of security principles in infrastructure architecture. Understanding of encryption strategies, network segmentation, access control, compliance requirements, and security best practices.

Practice Interview

Study Questions

Cloud Platform Architecture and Trade-offs

Understanding of architectural trade-offs across different cloud platforms and services. Ability to evaluate cost, performance, complexity, maintenance overhead, and long-term implications of different approaches.

Practice Interview

Study Questions

Observability and Monitoring Architecture at Scale

Design of comprehensive monitoring, logging, and alerting systems. Understanding of metrics, logs, traces, and how to build effective observability at scale without creating alert fatigue or high costs.

Practice Interview

Study Questions

Scalable Infrastructure Design and Capacity Planning

Ability to design infrastructure that scales horizontally to handle growing load. Understanding of horizontal vs. vertical scaling trade-offs, load balancing strategies, auto-scaling mechanisms, capacity planning, and cost implications of scaling decisions.

Practice Interview

Study Questions

High Availability and Disaster Recovery Architecture

Design of systems for high availability across zones and regions. Understanding of RTO/RPO requirements, backup strategies, failover mechanisms, multi-region architectures, and recovery procedures.

Practice Interview

Study Questions

Behavioral and Leadership Round

60 min5 focus topicsbehavioral

What to Expect

This round evaluates your soft skills, leadership capabilities, decision-making approach, collaboration style, communication abilities, and how you handle challenges and ambiguity. The interviewer will ask about past situations where you demonstrated leadership, mentorship of junior engineers, influence within your team, conflict resolution, and technical decision-making. You'll discuss how you've handled failure, learned from mistakes, and contributed to team and organizational success. This round also evaluates cultural alignment with the company values and leadership principles.

Tips & Advice

Use the STAR method (Situation, Task, Action, Result) to structure your answers with specific metrics and outcomes. Prepare specific examples from your career that demonstrate leadership, mentorship, technical decision-making, influence, conflict resolution, and measurable impact. Focus on situations where you influenced others, led by example, or drove positive change in processes or technology. Discuss how you handle disagreements and make decisions when there's no clear right answer. Provide examples of significant mistakes you've made and concrete lessons learned. Show how you've grown as a leader and engineer over your 5-12 years. Discuss your philosophy and approach to mentoring junior team members with specific success stories.

Focus Topics

Driving Process Improvement and Organizational Impact

Examples of how you've identified inefficiencies and driven improvements at team or organizational scale. Projects where you introduced new tools, practices, or technologies that had measurable positive impact.

Practice Interview

Study Questions

Cross-functional Collaboration and Communication

Examples of working effectively with development teams, product managers, security teams, other DevOps engineers, and leadership. How you communicate complex technical concepts clearly to non-technical stakeholders.

Practice Interview

Study Questions

Learning from Failure and Continuous Improvement

Specific examples of significant failures or mistakes you've experienced, your response, what you learned, and how you've prevented similar issues. Your approach to post-incident analysis and blameless postmortems.

Practice Interview

Study Questions

Technical Decision-Making and Architectural Influence

Examples of significant technical decisions you've made, how you evaluated options, involved stakeholders, and justified your choices. How you've influenced architectural decisions and consensus-building on technical direction.

Practice Interview

Study Questions

Leadership and Mentorship of Engineers

Concrete examples of how you've led team members, mentored junior engineers, and helped them grow in their careers. Your philosophy on mentorship, specific strategies you use, and success stories of engineers you've helped develop.

Practice Interview

Study Questions

Hiring Manager Round

45 min4 focus topicsbehavioral

What to Expect

Final round with the hiring manager or team lead who would be your direct manager. This round focuses on role-specific fit, your ability to solve the team's current challenges, how you'd approach the specific responsibilities of the position, and mutual fit between you and the team. The hiring manager will assess your understanding of the role, your relevant experience, enthusiasm for the opportunity, and whether you'd contribute positively to team dynamics. They'll also discuss team structure, current projects, technical challenges, growth opportunities, and answer your detailed questions about the role and career path.

Tips & Advice

Research the team's current infrastructure challenges and ongoing projects before the interview. Ask thoughtful questions about the team's current pain points, technical direction, and where you could contribute immediately. Discuss specifically how your experience aligns with their stated needs. Be honest about your strengths and areas where you'd like to grow. Show enthusiasm for solving their specific problems and contributing to the team's success. Discuss your working style and how you'd collaborate with team members. Ask about professional development opportunities, career growth within the role, and how success is measured. Show interest in understanding team dynamics and culture fit.

Focus Topics

Career Development and Learning Opportunities

Your approach to continuous learning, specific areas where you'd like to grow, how the role and team can support that growth, and your long-term career aspirations.

Practice Interview

Study Questions

Team Dynamics and Collaboration Style

Your understanding of team composition, collaboration style, how you'd integrate with existing team members and processes, and your approach to contributing to positive team dynamics.

Practice Interview

Study Questions

Understanding Team's Current Technical Challenges

Your understanding of the team's current technical challenges, infrastructure pain points, deployment bottlenecks, and how you could help address them based on your experience.

Practice Interview

Study Questions

Role-Specific Responsibilities and Expected Impact

Clear understanding of the specific responsibilities of this role, the immediate problems you'd solve, key success metrics, and how your experience directly applies to the team's needs and challenges.

Practice Interview

Study Questions

Frequently Asked DevOps Engineer Interview Questions

High Availability and Disaster RecoveryMediumTechnical

68 practiced

Describe leader election techniques used by distributed systems (consensus algorithms, leases, Zookeeper/etcd). Explain split-brain and present at least three mitigation strategies (quorum-based, fencing, lease expirations). When is fencing necessary versus quorum-only approaches?

Infrastructure Automation and ProvisioningEasyTechnical

65 practiced

In Terraform HCL, how would you manage variables and outputs across modules and environments? Explain use cases for input variable defaults, type constraints, sensitive variables, workspace-specific overrides, and how outputs can be consumed by other modules or consumed via remote state in pipelines without leaking secrets.

Sample Answer

**Approach (brief)**Manage inputs with clear defaults, types and sensitivity; use workspaces or per-environment variable files for overrides; expose only non-secret outputs from modules and consume secrets via secure remote state or parameter stores.

**Examples**

- input variable with default, type and sensitive

hcl

variable "instance_count" {
  type    = number
  default = 2
  description = "Number of app instances"
}

variable "db_password" {
  type      = string
  sensitive = true
}

- workspace-specific overrides (terraform.tfvars or -var-file per env)terraform.tfvars (prod)

hcl

instance_count = 6
db_password    = "REDACTED"

- module outputs (non-sensitive)

hcl

output "app_lb_dns" {
  value = aws_lb.app.dns_name
}

- mark output sensitive if it contains secrets

hcl

output "db_password" {
  value     = aws_db_instance.main.password
  sensitive = true
}

**Consuming outputs**- From another module: pass module.<name>.<output> as input to another module.- From pipelines: use terraform_remote_state data source pointing to a secure backend (state encrypted) to read non-sensitive outputs.

hcl

data "terraform_remote_state" "network" {
  backend = "s3"
  config = { bucket = "tf-state", key = "network/terraform.tfstate", region = "us-east-1" }
}

**Security best-practices**- Never output secrets unless necessary; mark outputs sensitive to prevent logging.- Store secrets in vault/SSM/KeyVault and reference them at runtime instead of storing in state.- Use encrypted backends (S3 + KMS) and restrict access via IAM.- Use type constraints to catch wrong values early and defaults for safe local dev.

This balances safety, reusability, and environment-specific configuration for Terraform in CI/CD pipelines.

Docker Fundamentals and Image ManagementMediumTechnical

89 practiced

Given a Debian-based Dockerfile that runs `apt-get` to install packages, describe concrete Dockerfile strategies to minimize final image size and reduce layer count. Provide example `RUN` lines that combine update, install, and cleanup, and explain implications for layer caching.

Sample Answer

**Approach (DevOps lens)** Minimize image size and layers by: 1) combining apt operations into single RUN so temporary files aren’t persisted across layers, 2) avoiding recommended/suggested packages, 3) cleaning apt lists and caches, 4) using multi-stage builds or slimmer base images. Be mindful of build-cache trade-offs: larger combined RUNs reduce layers but make cache reuse coarser — any change invalidates the whole step.

**Concrete RUN examples**- Simple generic:

dockerfile

RUN apt-get update && \
    apt-get install -y --no-install-recommends ca-certificates curl build-essential && \
    rm -rf /var/lib/apt/lists/*

- With apt-get clean/purge and noninteractive frontend:

dockerfile

ARG DEBIAN_FRONTEND=noninteractive
RUN apt-get update && \
    apt-get install -y --no-install-recommends --no-install-suggests tzdata git && \
    apt-get purge -y --auto-remove && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

- When building a language runtime: use multi-stage to compile in builder then copy only artifacts:

dockerfile

# Builder stage
FROM debian:bookworm AS builder
RUN apt-get update && apt-get install -y build-essential --no-install-recommends && rm -rf /var/lib/apt/lists/*
# compile...
# Final stage
FROM debian:bookworm-slim
COPY --from=builder /app/bin /app/bin

**Layer caching implications**- Single combined RUN: fewer layers, no leftover apt lists, smaller final size. But if you change any command in that RUN, cache for that entire step is invalidated — longer rebuilds.- To maximize cache reuse: separate stable steps (e.g., install OS deps) from frequently-changing steps (e.g., COPY app code). Use ARGs wisely (placing ARGs before RUN that should be invalidated).- Multi-stage builds: keep build-time tools out of final image entirely, improving both size and security.

**Best practices**- Use --no-install-recommends and --no-install-suggests.- Remove /var/lib/apt/lists/* in same RUN.- Prefer debian:bookworm-slim or alpine (if compatible).- Pin versions where reproducibility matters; use build cache strategy to minimize rebuilds.

Kubernetes Architecture and Core ComponentsEasyTechnical

58 practiced

Explain liveness and readiness probes in Kubernetes. Provide concrete examples of when to use each, how probe failures influence pod lifecycle and traffic handling, and how they interact with rolling updates and Service endpoint membership.

Sample Answer

**Overview — what they are**- Liveness probe: tells Kube whether a container is alive. If it fails, kubelet restarts the container (or follows configured failurePolicy).- Readiness probe: tells Kube whether a container is ready to serve traffic. If it fails, pod is removed from Service Endpoints (no new traffic), but container is not restarted.

**When to use (concrete)**- Liveness: detect deadlocks, hung threads, or stuck workers. Example: app that can deadlock—use an HTTP GET /healthz that returns 200 only when event loop is responsive.- Readiness: long startup, warm caches, or dependency outages. Example: return 503 from /ready until DB migration completes.

**YAML examples**

yaml

# Liveness - restart if unhealthy
livenessProbe:
  httpGet: { path: /healthz, port: 8080 }
  initialDelaySeconds: 30
  periodSeconds: 10

# Readiness - control endpoint membership
readinessProbe:
  httpGet: { path: /ready, port: 8080 }
  initialDelaySeconds: 5
  periodSeconds: 5

**Effect of failures**- Liveness fail -> kubelet restarts container; during restart pod remains in Endpoints? Generally removed while not Ready until readiness passes.- Readiness fail -> pod removed from Service Endpoints immediately; traffic routed elsewhere; container stays running.

**Interaction with rolling updates & Services**- During rolling update, Deployment waits for new pod to become Ready before killing old pod (ensures zero-downtime). Proper readiness prevents sending traffic to pods not prepared yet.- Services use Endpoint objects reflecting pod readiness; only Ready pods receive load-balanced traffic.

**Best practices**- Make liveness strict (only when truly unrecoverable); make readiness include transient dependency checks.- Use separate endpoints and sensible timeouts to avoid false restarts or premature traffic removal.

Deployment and Release StrategiesMediumSystem Design

95 practiced

You're asked to implement GitOps for deployment at your company. What automation and approval steps do you need to add to the Pull Request workflow to ensure safe production rollouts while maintaining developer velocity?

Sample Answer

Requirements / constraints:- Safe, auditable production rollouts; keep fast developer feedback and high velocity; use GitOps (declarative infra in git); integrate CI/CD, policy, and observability.

High‑level architecture:Developer PR → CI checks (build/tests/security/IaC plan) → Policy engine → Manual approvers (if needed) → Merge (or promotion) → GitOps operator (ArgoCD/Flux) reconciles → Progressive deploy + observability gates → Auto rollback / alerting.

Automations to add in PR workflow:1. Pre-merge automated gates (fast feedback): - Build + unit tests + integration tests in CI (GitHub Actions/Jenkins). - Image build + immutable artifact push with provenance (container registry + Sigstore). - Static analysis / linting (eslint, terraform fmt). - SCA / vulnerability scanning (Snyk/Trivy) and secret scanning. - IaC plan posted as PR comment (terraform plan or kubectl diff) so reviewers see exact changes. - Policy-as-code checks (OPA/Conftest, Checkov) blocking disallowed changes (open ports, privileged containers).

2. Required approvals and rules: - CODEOWNERS enforced: code reviewers for app, infra owners for IaC, security reviewer for flagged findings. - Tiered approvals: allow automated merge for low-risk changes (non-prod, config behind feature flag) but require 1–2 human approvals for prod-impacting PRs (changes to production manifests, infra, RBAC). - Signed commits/tags for release artifacts.

3. Promotion and deployment automation: - Merge to environment branch or create release tag triggers GitOps operator to apply manifests. - Use progressive delivery (canary/blue-green) orchestrated by Flagger or Argo Rollouts; percentage ramps automated. - Automated observability gates: synthetic smoke tests, latency/error SLO checks (Prometheus + Alertmanager). Only continue ramp if metrics pass. - Automatic rollback on threshold breach and emit incident with reproducible commit metadata.

4. Safety and auditing: - Audit log of merges, approvals, and deployed commit SHA stored in git + CI logs. - Immutable artifact registry and signed manifests for provenance. - Emergency fast-path: documented and RBAC-protected “hotfix” approval process (expedited approver with stricter post-deploy validation).

Balancing velocity:- Fast feedback for developer iteration (heavy checks run in parallel, caching).- Allow low-risk automatic merges (feature-flagged code, docs) to avoid gating.- Shift-left policies and running scans in pull requests reduce rework.- Automate mundane approval work (bots to post terraform plan, label merges) so humans focus only on policy/risk decisions.

Trade-offs:- More approvals & scans increase latency; mitigate with parallelization, caching, and risk-based exemption.- Strict policy enforcement requires maintenance of policy rules and false-positive tuning.

This workflow ensures merges are safe, auditable, and deployable with progressive delivery and automated rollback, while preserving developer velocity through fast feedback and risk-based exemptions.

Cross Functional Collaboration and CoordinationEasyTechnical

52 practiced

You need to request additional budget from finance to expand CI runner capacity because build queues are causing release delays. Draft (or describe) the structure of the budget request: key metrics to include, stakeholders to loop in, cost vs benefit analysis, and suggested payback or success criteria to convince finance.

High Availability and Disaster RecoveryHardSystem Design

123 practiced

Design a multi-region active-active architecture for a stateful application that must survive a full-region outage with the lowest possible RTO. Discuss data replication strategies (multi-master vs sharded failover), conflict resolution (CRDTs, last-write-wins, app-level), global load balancing, and operational challenges (testing, consistency validation).

Sample Answer

**Clarify requirements & constraints**- Must survive full-region outage with minimal RTO; stateful app; multi-region active-active; tolerate network partitions; acceptable consistency model (strict vs eventual).

**High-level architecture**- Deploy identical k8s clusters in each region running app pods + local DB clusters.- Global load balancing via GSLB (AWS Route53 latency + health checks) or Anycast + global proxy (Contour/Envoy/Cloud CDN) for fast failover.- Service mesh for observability and cross-region routing; control plane replicas per region.

**Data replication strategies**- Multi-master (geo-distributed consensus or multi-leader DB): low RTO, writes accepted in any region. Use databases supporting multi-master with conflict controls (CockroachDB, Cosmos DB multi-master) or CRDT-backed stores for specific data types. - Pros: seamless failover, single logical DB. - Cons: complexity, higher latency if synchronous, higher chance of conflicts.- Sharded failover (regional primary, failover promotion): each region owns shard(s); on full outage promote replica in surviving region. - Pros: simpler, strong consistency per shard, lower cross-region write latency. - Cons: RTO includes promotion time; cross-shard transactions complex.

**Conflict resolution**- Prefer CRDTs for commutative/mergeable state (counters, sets) — automatic, convergent.- For general records: - Application-level resolution: attach business rules (merge customer carts, reconcile transactions). - Last-write-wins only if timestamps strictly monotonic (use hybrid logical clocks) and stale-writes acceptable.- Use causal metadata (vector clocks/HLC) to enable deterministic merges.

**Consistency & durability**- Use quorum-based replication for critical data (write quorum across N replicas) balancing latency vs durability.- Async replication for lower latency; ensure tail-latency protections and change data capture for repair.

**Global load balancing & routing**- Health checks + low DNS TTL; use active health probes to avoid blackholed DNS.- Sticky sessions: avoid by using stateless front ends + session store replicated via CRDT or global cache (Redis Active-Active or DynamoDB).- Emergency routing: preconfigured failover policies and automation to reconfigure traffic rapidly (IaC templates).

**Operational challenges & mitigations**- Testing: automated chaos engineering (region blackhole, AZ/region kill tests) in staging and occasional controlled in prod.- Consistency validation: continuous data verification jobs, checksum-based anti-entropy, CDC pipelines to compare replicas.- Schema migrations: zero-downtime multi-region migration patterns (expand-contract, feature flags).- Monitoring & alerting: cross-region dashboards, SLOs for RTO/RPO, alert on replication lag, conflict rates.- Runbooks & automation: scripted promotion, rollback procedures, playbooks for conflict resolution, CI/CD gated by canary metrics.

**Trade-offs**- Multi-master reduces RTO but increases complexity and conflict management; sharded failover simplifies consistency but increases RTO.- Choose per-data-class approach: multi-master/CRDT for session/soft-state; sharded/strong-consistency for financial transactions.

This design balances low RTO with pragmatic operational controls — implement incrementally: start with sharded primaries + regional replicas, add multi-master/CRDT where needed, and validate via automated failure drills.

Infrastructure Automation and ProvisioningHardTechnical

63 practiced

Explain the design and implementation of self-healing infrastructure where an automated controller reconciles desired IaC-defined state with actual cloud state and executes corrective actions. Discuss reconciliation loop frequency, idempotency, rate-limiting and backoff, auditing corrective actions, and safe limits to prevent destructive thrash.

Sample Answer

**Design overview**Build a controller that continuously reconciles the desired state (IaC: Terraform/CloudFormation/Helm/K8s manifests stored in git) with actual cloud state via cloud provider APIs. Controller reads desired manifests, diffs against live state, plans corrective actions, and executes idempotent operations through a change-execution layer (Terraform apply, k8s client, or cloud SDKs).

**Reconciliation frequency**- Default: event-driven (webhooks, cloud config-change notifications) + periodic poll.- Poll interval: conservative default 1–5 minutes for infra; shorter (15–60s) for cluster control-plane objects.- Make intervals configurable per-resource class and allow on-demand reconcile.

**Idempotency**- Ensure every action is safe to retry: use declarative APIs, "apply" semantics, or check-and-set (resource versions/tags).- Use optimistic concurrency: include resourceVersion/etag in update calls.- Encode intent via annotations/tags so controller can detect who owns resource.

**Rate-limiting & backoff**- Global and per-resource rate limits to avoid API throttling (e.g., token bucket).- Exponential backoff with jitter on failures; escalate to exponential-slowdown for repeated failures.- Circuit breaker: pause retries for a failing resource after N attempts and alert.

**Auditing & observability**- Record planned vs executed actions, before/after snapshots, and operator identity in an audit log (immutable store like S3 or ELK).- Emit metrics (reconciles/sec, success/fail, retries) and structured events to monitoring/alerting.- Provide dry-run mode and human-approval gates for high-risk changes.

**Safe limits & anti-thrash**- Concurrency caps: max parallel changes globally and per-resource-type.- Change-rate thresholds: max X destructive ops/hour; blocks further destructive actions beyond limit.- Safe-mode: when detecting thrash (flapping state), enter cooldown window and notify SRE with remediation hints.- Require explicit escalation for broad-impact corrective actions (mass replacement, DB restarts).

**Example**For a Terraform-based controller: run plan, persist plan hash, apply only if plan matches desired hash, use state locking, rate-limit applies, and store plan/apply logs and diffs for audit.

This design balances automated recovery with safety: idempotent operations, bounded execution, observability, and human-in-the-loop controls for destructive scenarios.

Docker Fundamentals and Image ManagementHardTechnical

83 practiced

You inherit a 2GB monolithic Docker image containing build tools, caches, and the runtime app. Propose a refactoring plan to reduce image size and runtime overhead. Describe concrete steps (multi-stage builds, remove build-time deps, split services), measurements/metrics to track (image size, startup time, memory), and trade-offs with splitting into multiple services.

Sample Answer

**Approach (summary)** As a DevOps Engineer I’d shrink the image by removing build-time artifacts, using multi-stage builds, switching to slim/base runtime images, pruning caches, and considering service-splitting where appropriate. Measure before/after and iterate.

**Concrete steps**- Baseline metrics (image size, startup latency, peak RSS, cold start time, CI build time).- Convert Dockerfile to multi-stage: build in a heavyweight image, copy only runtime artifacts to a minimal runtime image (e.g., distroless or alpine). Example:

dockerfile

# build stage
FROM golang:1.20 AS builder
WORKDIR /app
COPY . .
RUN go build -o app ./...

# runtime stage
FROM gcr.io/distroless/base
COPY --from=builder /app/app /usr/local/bin/app
ENTRYPOINT ["/usr/local/bin/app"]

- Remove package manager caches, dev tool installations, unused locales, docs.- Use language-specific optimizations (pip wheel + --no-cache-dir, npm ci + prune, gradle --no-daemon).- Strip binaries, enable upx only if safe.- Use layered caching wisely: reorder Dockerfile so rarely-changing layers are above.- Split out large non-core components (e.g., background workers, cron jobs, asset builders) into separate services/sidecars with their own images.- Add CI gate: fail if image > X MB or startup time regresses.

**Metrics to track**- Image size (docker images / registry)- Build time and cache hit rate- Container startup (cold & warm)- Memory and CPU usage under load- Vulnerability scan count

**Trade-offs of splitting**- Pros: smaller images, faster deploys, independent scaling, improved fault isolation.- Cons: increased operational complexity (networking, service discovery), more releases to coordinate, possible latency from RPC. Mitigate via automation (Helm, k8s Deployments), observability, and contract/versioning.

**Result expectation**- Typical reductions: 50–90% image size cut depending on tools/caches removed; faster CI and reduced runtime memory.

Kubernetes Architecture and Core ComponentsEasyTechnical

57 practiced

Compare ConfigMap and Secret in Kubernetes: what they are designed for, how they differ in storage and access semantics, and best practices for handling sensitive data including encryption at rest and avoiding common mistakes.

Practice DevOps Engineer questions across all topics

Additional Information

Want to create your own tailored preparation guide using our deep research?

Get Started for Free

Interview-Ready Courses

Visual-first, interactive, structured learning paths

Browse DevOps Engineer jobs

AI-enriched listings across hundreds of company career pages

Explore Jobs

Senior DevOps Engineer Interview Preparation Guide - FAANG Standards

Interview Process Overview

Interview Rounds

Recruiter Screening Call

What to Expect

Tips & Advice

Focus Topics

Motivation and Cultural Fit

Practice Interview

Study Questions

Career Trajectory and Experience Summary

Practice Interview

Study Questions

Key Infrastructure Projects and Measurable Impact

Practice Interview

Study Questions

Technical Phone Screen - Infrastructure and Scripting

What to Expect

Tips & Advice

Focus Topics

API Integration and Infrastructure Orchestration

Practice Interview

Study Questions

Problem-Solving and Infrastructure Troubleshooting

Practice Interview

Study Questions

Infrastructure as Code Implementation (Terraform, CloudFormation, ARM Templates)

Practice Interview

Study Questions

Cloud Platform Fundamentals (AWS, Azure, or GCP)

Practice Interview

Study Questions

Shell Scripting and Automation (Bash, Python, Go)

Practice Interview

Study Questions

Technical Round 1 - CI/CD Pipeline Design and Automation

What to Expect

Tips & Advice

Focus Topics

Artifact Management and Versioning

Practice Interview

Study Questions

Security and Secrets Management in CI/CD

Practice Interview

Study Questions

CI/CD Pipeline Architecture and Design Patterns

Practice Interview

Study Questions

Deployment Strategies and Release Management

Practice Interview

Study Questions

CI/CD Tools and Platforms (Jenkins, GitLab CI, GitHub Actions)

Practice Interview

Study Questions

Technical Round 2 - Containerization and Kubernetes Orchestration

What to Expect

Tips & Advice

Focus Topics

Kubernetes Storage and Persistent State

Practice Interview

Study Questions

Container and Kubernetes Security Best Practices

Practice Interview

Study Questions

Kubernetes Networking and Service Management

Practice Interview

Study Questions

Kubernetes Architecture and Cluster Design

Practice Interview

Study Questions

Kubernetes Workload Management and Deployments

Practice Interview

Study Questions

Docker and Container Image Management

Practice Interview

Study Questions

System Design Round - Large-Scale Infrastructure Architecture

What to Expect

Tips & Advice

Focus Topics