Skip to main content

DevOps Interview Preparation

Comprehensive preparation for DevOps engineering interviews with real-world scenarios and technical depth.

Learning Resources

Before interviews, study the foundational concepts in DevOps Fundamentals, DevOps Practices, and the Tools Landscape.

Core Concepts​

What is DevOps?​

DevOps is a set of practices that combines software development (Dev) and IT operations (Ops) to shorten the development lifecycle while delivering features, fixes, and updates frequently in close alignment with business objectives.

Key Topics to Master​

AreaTopics
CI/CDPipeline design, blue-green deployments, canary releases, rollbacks
IaCTerraform, CloudFormation, immutable infrastructure
ContainersDocker internals, orchestration, microservices
CloudAWS/Azure/GCP core services, architecture patterns
MonitoringObservability, metrics, logs, traces, alerting strategies
SecurityShift-left, secrets management, supply chain security
CultureBlameless postmortems, collaboration, continuous improvement

Core Interview Topics​

Prepare deep technical knowledge in these areas:

TopicKey ConceptsCloudCaptain Resources
DevOps Culture & PracticesCALMS, Three Ways, blameless postmortems, DORA metricsFundamentals
CI/CD PipelinesPipeline stages, testing strategies, artifact management, deployment frequencyPractices
Deployment StrategiesBlue-green, canary, rolling, feature flags, shadow deploymentsPractices
Infrastructure as CodeTerraform, CloudFormation, Ansible, idempotence, state managementTools Overview
Containers & OrchestrationDocker, Kubernetes, microservices, networking, storageDocker, Kubernetes
Monitoring & ObservabilityMetrics, logs, traces, alerting, observability pillarsPractices
Incident ManagementSeverity levels, response procedures, postmortems, on-callPractices
Security & ComplianceShift-left, secrets management, container scanning, GitOpsTools Overview

Common Interview Questions with Answers​

1. Explain the difference between CI and CD​

Answer: CI/CD are related but distinct practices:

  • Continuous Integration (CI): Developers integrate code multiple times per day. Every commit triggers automated tests. Goal: catch integration issues early.

    • Small, frequent commits
    • Automated testing on every commit
    • Fast feedback (< 10 minutes)
    • Build once, test multiple times

  • Continuous Delivery (CD): Code is always in a deployable state. Release to production manually when ready.

    • Automated build and test pipeline
    • Every commit could go to production
    • Manual approval before production release
    • Reduces risk per change

  • Continuous Deployment: Extends CD—every commit automatically deployed to production.

    • Fully automated pipeline
    • No manual approvals
    • Requires excellent testing and monitoring

Follow-up: "Which do you prefer?" → Answer based on requirements (regulated industries need Continuous Delivery; tech startups often do Continuous Deployment).

2. How would you design a deployment pipeline for a microservices application?​

Answer: Explain a complete pipeline with stages:

Developer Push → Compile & Unit Tests → Integration Tests →
Build Docker Image → Push to Registry → Deploy to Staging →
Smoke Tests → Manual Approval → Canary Deploy (5%) →
Monitor → Full Deploy (100%) → Production Verification

Key considerations:

  • Parallelization: Run tests in parallel to reduce build time
  • Artifact Versioning: Tag Docker images with commit SHA + version
  • Environment Parity: Staging matches production exactly
  • Automated Rollback: Detect failures and automatically rollback
  • Monitoring Integration: Link pipeline to observability (see deployment in metrics)
  • Secrets Management: Never hardcode credentials (use Vault or cloud provider)
  • Database Migrations: Handle schema changes safely
  • Service Dependencies: Account for inter-service communication

Tools: Jenkins/GitHub Actions for CI, Helm/ArgoCD for Kubernetes deployment, Prometheus for verification.

3. What is Infrastructure as Code and why is it important?​

Answer: IaC means managing infrastructure (servers, networks, databases) through code, not manual configuration.

Benefits:

  • Reproducibility: Create identical environments consistently
  • Version Control: Infrastructure changes tracked in Git
  • Auditability: Who changed what, when, why
  • Scalability: Deploy 100 instances as easily as 1
  • Testing: Validate infrastructure changes before applying
  • Speed: Provision infrastructure in minutes, not hours
  • Disaster Recovery: Rebuild infrastructure from code

Approaches:

  • Declarative (Terraform, CloudFormation): Describe desired state
  • Imperative (Ansible, Chef): Describe steps to reach desired state

Example: Terraform code to create AWS infrastructure is version-controlled alongside application code.

4. Describe blue-green vs canary deployment strategies​

Answer: Two strategies for reducing deployment risk:

Blue-Green:

  • Two identical production environments: Blue (current) and Green (new)
  • Deploy to Green, test thoroughly
  • Switch all traffic from Blue to Green
  • Instant rollback: switch back to Blue if problems
  • Zero downtime, but double infrastructure cost

Canary:

  • Deploy to small percentage of servers (5-10%)
  • Monitor for errors and performance issues
  • Gradually increase percentage (25% → 50% → 100%)
  • Instant rollback if issues detected
  • Lower cost than blue-green, but slower rollout
  • Requires excellent monitoring

Comparison:

  • Speed: Blue-green faster (instant switch)
  • Cost: Canary cheaper (no duplicate infrastructure)
  • Risk: Canary lower (detect issues early with small blast radius)
  • Complexity: Canary requires more sophisticated traffic routing

Tools: AWS Route 53, Kubernetes service meshes (Istio), Spinnaker

5. How do you handle secrets in a CI/CD pipeline?​

Answer: Critical security question. Never commit secrets to Git.

Best Practices:

  1. External Secrets Management: Use Vault, AWS Secrets Manager, or Azure Key Vault
  2. Principle of Least Privilege: Grant only necessary secrets per service
  3. Rotation: Regularly rotate secrets (passwords, API keys)
  4. Audit: Log all secret access
  5. Encryption: Encrypt secrets at rest and in transit

Example Workflow:

CI/CD Pipeline → 1. Authenticate to Vault
              → 2. Request database password
              → 3. Vault returns secret (time-limited)
              → 4. Deploy with secret
              → 5. Never stored in pipeline logs

Anti-patterns to avoid:

  • Secrets in environment variables exposed in logs
  • Secrets in Git history (hard to remove)
  • Hardcoded credentials in code

6. What is the difference between monitoring and observability?​

Answer: Related but different concepts.

Monitoring: "Is the system working?"

  • Predefined metrics and alerts
  • Watches for known failure modes
  • Examples: CPU < 80%, error rate < 1%
  • Reactive: alerts when metrics cross thresholds

Observability: "Why is it not working?"

  • Ability to understand system behavior from outputs
  • Answers any question about system state
  • Three pillars: metrics, logs, traces
  • Proactive: drill into data to find root cause

Example:

  • Monitoring: Alert on "error rate > 5%"
  • Observability: Dig into logs and traces to find which users affected, which service caused it, what changed in recent deployments

Key Insight: You can monitor without observability (know something is wrong but not why). You need observability to debug complex systems.

Tools: Prometheus (monitoring) + Grafana + ELK + Jaeger (observability)

7. Explain the concept of "shifting left" in DevOps​

Answer: Shifting left means moving activities earlier in the development lifecycle to catch issues sooner.

Traditional (left to right): Dev → Test → Ops → Production

  • Problems discovered late are expensive to fix
  • Testing is separate from development

Shift-Left: Build quality in from the start

  • Testing: Developers write unit tests, run tests locally
  • Security: Security checks in CI, SAST scanning before code review
  • Code Quality: Linting, complexity checks during development
  • Infrastructure: Developers provision own test environments
  • Deployment: Deployment processes validated early

Benefits:

  • Bugs cost 10x less to fix in development vs. production
  • Developers get faster feedback
  • Reduces QA bottleneck
  • Fewer production incidents

Examples:

  • Pre-commit hooks running tests
  • Security scanning in CI/CD
  • IaC validated before apply
  • Automated code review bots

8. How would you implement disaster recovery for a cloud application?​

Answer: Comprehensive DR strategy with multiple components:

RPO & RTO:

  • Recovery Point Objective (RPO): How much data can we lose? (e.g., 1 hour)
  • Recovery Time Objective (RTO): How long to restore? (e.g., 4 hours)
  • These define your DR strategy and cost

Implementation:

  1. Multi-Region Replication

    • Database replication to secondary region
    • Automated snapshots stored in different region

  2. Infrastructure as Code

    • Entire infrastructure in code (Terraform)
    • Can redeploy in minutes to any region

  3. Data Backup

    • Daily automated snapshots
    • Point-in-time recovery capability
    • Test restores regularly (DR drills)

  4. DNS Failover

    • Route 53 health checks
    • Automatic failover to secondary region
    • Or manual failover with runbook

  5. Monitoring & Alerting

    • Health checks on primary region
    • Automated failover on detection

  6. Testing

    • Regular DR drills (at least quarterly)
    • Document runbook for manual recovery
    • Automate what you can

Architecture Example:

Primary Region (Active)
  ├── App Servers
  ├── Database (Master)
  └── Load Balancer (Primary DNS)

Secondary Region (Standby)
  ├── App Servers (stopped or minimal)
  ├── Database (Replica)
  └── Load Balancer (Backup DNS)

Replication: Database master → slave (continuous)
Failover: DNS switches to secondary on primary failure

9. What are SLOs, SLIs, and SLAs?​

Answer: Three related but distinct concepts:

SLI (Service Level Indicator):

  • Measurable metric of service behavior
  • Examples: 99.9% uptime, p99 latency < 200ms, error rate < 0.1%
  • What you actually measure

SLO (Service Level Objective):

  • Goal for SLI
  • What you commit to internally
  • Example: "SLI target 99.9% uptime"
  • Used for decision making

SLA (Service Level Agreement):

  • Contract with customers
  • Legal commitment with penalties if not met
  • Usually more lenient than SLO
  • Example: "99% uptime, $100 credit per hour below SLA"

Relationship:

SLA (99% uptime) ← SLO (99.9% uptime) ← SLI (99.95% actual uptime)
Contract         Internal Goal        Actual Metric

Error Budget:

  • If SLO is 99.9% uptime, you have 43.2 minutes downtime per month
  • Use this budget for changes, experiments, testing
  • Once budget exhausted, focus on stability

10. Describe your experience with container orchestration​

Answer: Share real experience, focusing on Kubernetes since it's industry standard:

What I've Done:

  • "I've deployed microservices to Kubernetes, managing pods, services, deployments"
  • "I've used Helm charts to package and version releases"
  • "I've configured networking with ingress controllers"
  • "I've set up persistent storage for stateful workloads"
  • "I've implemented auto-scaling based on CPU metrics"

Key Concepts to Understand:

  • Pods: Smallest deployable unit (usually one container)
  • Deployments: Manages replica sets and rolling updates
  • Services: Stable endpoint for accessing pods
  • Ingress: Manages external HTTP(S) access
  • ConfigMaps & Secrets: Configuration management
  • Volumes: Persistent data storage
  • Labels & Selectors: Organizing and selecting resources

Challenges I've Solved:

  • "Managed rolling updates with zero downtime"
  • "Configured health checks to prevent cascading failures"
  • "Optimized resource requests/limits for cost and stability"
  • "Set up log aggregation for cluster-wide visibility"

Tools Used:

  • kubectl for management
  • Helm for package management
  • ArgoCD for GitOps deployment
  • Prometheus for monitoring

Be Honest: If you haven't used Kubernetes extensively, say so but show you understand concepts from studying or small projects.

Tips for Success​

  • Focus on real-world experience and problem-solving
  • Be prepared to whiteboard architectures
  • Know your tools deeply — don't just name-drop
  • Understand trade-offs in every decision
  • Practice explaining complex topics simply

Additional Concepts​

What is DevOps? (Extended)​

DevOps is the combination of cultural philosophies, practices, and tools that increases an organization's ability to deliver applications and services at high velocity. It enables organizations to evolve and improve products faster than traditional software development and infrastructure management.

DevOps Process visualized as an infinite loop: Plan → Code → Build → Test → Release → Deploy → Operate → Monitor

DevOps and Cloud Computing​

Development and Operations are considered a single entity in DevOps practice. Agile development alongside Cloud Computing provides straight-up advantage in scaling practices and business adaptability. Cloud is the car; DevOps is its wheels.

Cloud Computing​

On-demand delivery of IT resources and applications via the internet with pay-as-you-go model.

Features:

  1. On-demand provisioning
  2. Scalability in minutes (scale out or scale in)

Cloud Models:

  • Public
  • Private
  • Hybrid
  • Community

LAMP Architecture​

LAMP stands for Linux, Apache, MySQL, and PHP. Together, they provide proven software for delivering high-performance web applications.

Top DevOps Tools​

  • Configuration Management & Deployment: Chef, Puppet, Ansible
  • Version Control: Git
  • Continuous Integration: Jenkins
  • Containerization: Docker
  • Continuous Monitoring: Nagios

Main Goal of DevOps​

Optimize the flow of value from idea to end-user. Make delivery effective and efficient. Focus on culture and cultural changes in the company.

Agile vs DevOps​

  • Agile — Increases efficiency of developers and development cycles
  • DevOps — Enables continuous integration and continuous delivery through operations team collaboration

Jenkins​

An open-source Java tool for automation and continuous integration. Features:

  • Create and test projects continuously
  • Integrate changes quickly
  • Large number of plugins for integration with other software
  • Handle entire development lifecycle: creation, testing, packaging, deployment, analysis

Ansible​

A RedHat product for service deployment. An open-source solution for:

  • Software provisioning
  • Application deployment
  • Configuration management

Offers numerous facilities and is designed for multi-tier deployment to handle different systems together.

Tomcat Server​

Used for web applications written in Java that don't require full Java EE specifications. Provides a reliable tool for developing Java EE applications. Includes Servlet and JSP containers.

Web Server​

Computers that deliver requested web pages. Every web server has an IP address and domain name.

Nginx​

Open-source software designed for maximum performance and stability. A dedicated web server solving efficiency issues and handling thousands of requests concurrently.

Features:

  1. Provides HTTP server capabilities
  2. Designed for stability and maximum performance
  3. Functions as proxy server for email (IMAP, POP3, SMTP)
  4. Uses event-driven, non-threaded architecture
  5. Provides scalability
  6. Reduces client wait time
  7. Upgrades possible without downtime

CI/CD and AWS​

CI/CD (Continuous Integration/Continuous Delivery or Continuous Deployment) combines processes that fill gaps between production and operational activities. AWS services automate creating, testing, and deploying applications. Progressive code changes are compiled, linked, and packaged into software deliverables.

Continuous Testing in DevOps​

Execution of automated tests every time code is merged. Enables engineers to get immediate feedback on recent code merges. Automation encouraged throughout development cycle.

Container Resource Monitoring Tools​

  1. Grafana
  2. Heapster

Advanced Topics for Deep Preparation​

DevOps Culture & Frameworks​

  • The Three Ways of DevOps: Flow, feedback, continuous learning
  • CALMS Framework: Culture, Automation, Lean, Measurement, Sharing
  • Team Topologies: Stream-aligned, platform, enabling teams
  • DORA Metrics: Deployment frequency, lead time, MTTR, change failure rate
  • Blameless Postmortems: Learning from failures without blame

→ Study: DevOps Fundamentals

CI/CD & Deployment​

  • Pipeline Design: Stages, parallelization, artifact management
  • Deployment Strategies: Blue-green, canary, rolling, feature flags
  • GitOps: Infrastructure and applications declared in Git
  • Release Management: Rollback strategies, deployment verification
  • Secrets Management: Vault, cloud provider secrets managers

→ Study: DevOps Practices

Observability at Scale​

  • Observability vs Monitoring: Three pillars (metrics, logs, traces)
  • Incident Response: Severity levels, escalation, on-call rotation
  • Chaos Engineering: Resilience testing, failure injection
  • Cost Optimization: FinOps, resource right-sizing
  • SLOs & Error Budgets: Setting reliability targets

→ Study: DevOps Practices

Tool Landscape & Selection​

  • Version Control: Git workflows, branching strategies
  • CI/CD Tools: Jenkins, GitHub Actions, GitLab CI, CircleCI
  • Infrastructure as Code: Terraform, Ansible, CloudFormation
  • Container Technology: Docker, Kubernetes, registries
  • Monitoring Platforms: Prometheus, Grafana, Datadog, Splunk
  • Tool Selection Framework: How to choose tools for your environment

→ Study: DevOps Tools Overview

Week 1-2: Foundations​

  • Read DevOps Fundamentals
  • Understand CALMS, Three Ways, DORA metrics
  • Study team topologies and organizational aspects

Week 3-4: Practices​

  • Deep dive DevOps Practices
  • Practice designing CI/CD pipelines
  • Understand deployment strategies in detail
  • Study incident management and observability

Week 5-6: Tools & Architecture​

Week 7-8: Mock Interviews & Practice​

  • Do system design exercises (design a deployment pipeline, monitoring stack, etc.)
  • Practice explaining concepts clearly
  • Record yourself answering questions
  • Get feedback from peers
  • Review for gaps in knowledge

Recommended Books & Resources​

Must-Read Books:

  • Accelerate by Nicole Forsgren, Jez Humble, Gene Kim — Research-backed DevOps metrics
  • The DevOps Handbook by Gene Kim, Jez Humble, John Willis, Patrick Debois — Practical implementations
  • The Phoenix Project by Gene Kim — Novel about DevOps transformation
  • Release It! by Michael Nygard — Production-ready systems design
  • Site Reliability Engineering by Betsy Beyer, Chris Jones, Jennifer Petoff, Niall Murphy — Google's SRE philosophy

Online Resources:

Interview Tips & Strategies​

Before the Interview​

  1. Research the Company

    • What tech stack do they use?
    • What size is their infrastructure?
    • Check their blog, tech talks, open source contributions

  2. Prepare Concrete Examples

    • Describe real projects you've worked on
    • Use the STAR method: Situation, Task, Action, Result
    • Focus on your contributions and learnings
    • Be ready to discuss failures and how you recovered

  3. Practice Technical Communication

    • Explain concepts clearly (imagine explaining to non-technical person)
    • Use diagrams and drawings
    • Don't use jargon without defining it
    • Ask clarifying questions

During the Interview​

  1. Listen Carefully

    • Understand what they're really asking
    • Ask clarifying questions if unclear
    • Take time to think before answering

  2. Structure Your Answers

    • Answer the question directly first
    • Provide context and trade-offs
    • Give concrete examples
    • Ask if they want more depth

  3. Demonstrate Problem-Solving

    • Walk through your thinking process
    • Discuss trade-offs and decisions
    • Show flexibility (multiple solutions, choose based on constraints)

  4. Ask Good Questions

    • About their tech stack and infrastructure
    • About DevOps maturity and challenges
    • About team structure and culture
    • About on-call practices and incident response

Common Mistakes to Avoid​

❌ Name-dropping tools without understanding them ❌ Claiming experience you don't have ❌ Not discussing trade-offs (no solution is perfect) ❌ Overcomplicating answers ❌ Forgetting about security and compliance ❌ Being defensive about different approaches ❌ Ignoring the human/culture side of DevOps

✅ Show depth in areas you know ✅ Be honest about learning areas ✅ Discuss trade-offs thoughtfully ✅ Keep explanations clear and concise ✅ Remember DevOps is about people and culture first ✅ Show curiosity and willingness to learn ✅ Ask intelligent questions about their challenges