DevOps interview rounds are not just about naming tools. Interviewers test how you think when a pipeline breaks, how you collaborate when Dev and Ops disagree, and whether you understand why a tool exists - not just what it does.
The demand for DevOps engineers in Nepal and globally is growing fast. Senior DevOps roles in Nepal now pay between NPR 1,50,000 and 2,50,000 per month, and companies are actively hiring at every level, from interns to cloud architects. But landing that role requires more than reading documentation.
Whether you are sitting for your first DevOps internship interview or targeting a senior cloud engineering position, this guide covers everything; concepts, tools, scenario questions, and preparation tips - broken down by experience level.
Not sure where DevOps fits in your career path yet? Start with our complete guide on how to get into DevOps before diving into interview prep. And when you are ready to build hands-on skills, our DevOps and Cloud diploma program gives you real pipelines, real tools, and real projects to talk about in interviews.
Memorizing definitions is not enough. Companies want engineers who can apply DevOps principles to real infrastructure problems. Here is what you need to do before you walk into the room.
Before anything else, you need to be solid on the fundamentals - not just able to define them, but able to explain them clearly without a script.
A clear understanding of what DevOps actually is and how it works gives you a foundation that connects every tool and practice you learn after it.
Interviewers at most Nepal-based IT companies and global remote roles expect you to speak confidently about the tools you have actually used - not just tools you have heard of. Structure your preparation by category:
For each tool, prepare one real example of how you used it - even in a home lab or training project. Saying "I set up a Jenkins pipeline that builds and tests a Node.js app on every Git push" is far stronger than "I know Jenkins."
Check out our breakdown of the most important DevOps tools and what each one does for a deeper look at how these fit together.
In Nepal's current IT hiring market, a working portfolio beats a certification every time. Interviewers want proof that you can do the work, not just that you passed a test.
What makes a strong DevOps portfolio:
Practical DevOps skills get you interviews. A portfolio gets you offers.
Before you walk in, know exactly what stack the company uses. Read the job posting carefully - every tool they mention is a potential interview question.
Map your preparation to their DevOps roadmap and their current stage - early-stage startup infrastructure looks very different from a mature enterprise pipeline.
These are the questions that come up across every level - fresher, mid-level, and senior. Understand the concepts well enough to explain them without reading from a script. Interviewers always follow up.
DevOps is a set of practices, cultural values, and tools that bring development and operations teams together to deliver software faster and more reliably. Before DevOps, developers wrote code and handed it to an operations team that deployed and maintained it separately. That wall between the two teams caused slow releases, finger-pointing when deployments broke, and long feedback loops.
DevOps removes that wall. Teams share ownership of the entire lifecycle - from writing code to keeping it running in production. The result is faster delivery, fewer failures, and quicker recovery when things do go wrong.
In traditional IT, development and operations work in silos. Developers write code in one team, operations deploy and maintain it in another. Releases happen quarterly or monthly, documentation is heavy, and communication between teams is mostly through tickets.
DevOps combines those responsibilities. Developers care about how their code runs in production. Operations engineers get involved earlier in the development cycle. Releases happen continuously, sometimes multiple times a day and feedback flows both ways in real time.
CALMS is the most widely accepted framework for describing what DevOps actually means in practice:
Three terms that sound similar but mean different things:
IaC is the practice of defining and managing infrastructure - servers, databases, networks, load balancers - using code instead of manual configuration.
Instead of logging into an AWS console and clicking through to create a server, you write a Terraform file that describes the infrastructure you want. Running that file creates it, every time, consistently.
IaC solves three problems: it makes infrastructure reproducible, it puts infrastructure changes under version control, and it eliminates the "snowflake server" problem where no one knows exactly how a production server was configured.
A container is a lightweight, isolated environment that packages an application and everything it needs to run - libraries, dependencies, runtime - into a single unit. It shares the host operating system's kernel, which makes it fast to start and cheap to run.
A virtual machine emulates an entire computer, running a full guest OS on top of the host OS through a hypervisor. VMs are heavier, slower to start, and use more resources - but they offer stronger isolation.
For most modern application deployment, containers are faster and more practical. VMs still make sense when you need full OS-level isolation or are running legacy software.
Docker is the most widely used containerization platform. It lets you package an application and all its dependencies into a container that runs identically on any machine - your laptop, a server, or a cloud platform.
It solves the "it works on my machine" problem. Before Docker, code that ran fine on a developer's laptop often broke on a server because of environment differences. Docker eliminates those differences entirely.
For a deeper look, our Docker for beginners guide covers containers, images, Dockerfile writing, and Docker Compose from scratch.
Kubernetes is a container orchestration platform. Docker runs containers. Kubernetes manages them at scale - scheduling containers across multiple servers, restarting failed ones automatically, scaling up when traffic increases, and rolling out updates without downtime.
You need Kubernetes when you are running many containers across multiple servers and need automated management. For a single container on one server, Docker alone is enough. For 50 services running across a production cluster, Kubernetes is what keeps everything stable and organized.
For a deeper look, our Kubernetes for beginners guide covers Pods, Deployments, Services, and scaling from scratch.
A CI/CD pipeline is an automated workflow that takes code from a developer's commit to a live deployment without manual steps.
A typical pipeline runs like this:
For a complete breakdown of how CI/CD works from code commit to live deployment, our CI/CD guide covers every stage in detail.
Configuration management is the practice of keeping servers and infrastructure in a known, consistent state. Instead of manually configuring each server, you define the desired state in code and let a tool enforce it.
Common tools:
Ansible is the most common starting point in Nepal's DevOps job market.
Both are infrastructure automation tools, but they solve different problems:
A common pattern: use Terraform to create the infrastructure, then Ansible to configure it.
A branching strategy defines how teams manage code changes in a shared repository. GitFlow is the most widely used:
GitFlow works well for teams with scheduled releases. Teams doing Continuous Deployment often use a simpler trunk-based development model instead.
Blue-green deployment is a release strategy that keeps two identical production environments running - blue (current live) and green (new version).
When you want to release a new version, you deploy it to the green environment, run tests, and then switch the traffic from blue to green. If something goes wrong, you switch traffic back to blue immediately. Zero downtime, instant rollback.
The downside is cost - you run two full environments at the same time.
A canary release gradually rolls out a new version to a small percentage of users first - say 5% - before releasing it to everyone.
If the 5% shows no errors or performance issues, you gradually increase the rollout to 25%, then 50%, then 100%. If something breaks, you roll back only the affected percentage. It reduces risk significantly compared to releasing to all users at once.
Observability is your ability to understand what is happening inside a system based on its outputs. The three pillars are:
Monitoring tells you when something is wrong. Observability helps you understand why.
DevSecOps integrates security into every stage of the DevOps pipeline instead of treating it as a final checkpoint before release.
In a DevSecOps workflow, security scans run automatically inside the CI/CD pipeline: static code analysis checks for vulnerabilities in the code, dependency scanning flags outdated or insecure libraries, and container scanning checks Docker images for known vulnerabilities before they deploy.
The goal is to find and fix security issues when they are cheapest to fix - during development, not after a breach.
GitOps is a way of managing infrastructure and deployments using Git as the single source of truth. Instead of running deployment commands manually or through a CI/CD pipeline that pushes changes, GitOps tools like ArgoCD or Flux pull the desired state from a Git repository and continuously reconcile it with what is actually running in the cluster.
If someone manually changes a Kubernetes resource directly, GitOps detects the drift and reverts it to match the repository. Infrastructure stays exactly as declared in Git.
The answer depends on the deployment strategy:
The most important thing is that rollback is practiced and automated before it is needed, not figured out during an incident.
The four DORA metrics are the industry standard for measuring DevOps performance:
Landing a DevOps internship in Nepal is competitive. Interviewers know you do not have years of production experience - but they do expect structured thinking, basic technical understanding, and evidence that you have actually tried things on your own.
Do not say "it sounds exciting" or "the salary is good." Give a real answer. Talk about the specific problem DevOps solves - the gap between how software gets built and how it gets delivered. Talk about what drew you to automation, infrastructure, or the engineering side of software delivery. Interviewers remember candidates who show genuine curiosity.
A DevOps engineer spends most of their time on three things: maintaining and improving CI/CD pipelines, managing infrastructure (often on cloud platforms like AWS), and fixing whatever breaks in the delivery process. They write automation scripts, review deployment processes, work with developers to debug pipeline failures, and set up monitoring so the team knows when something is wrong before users do.
A developer writes application code - features, logic, APIs, databases. A DevOps engineer builds and maintains the infrastructure that runs that code - pipelines, containers, servers, monitoring. In practice, the roles overlap. Good DevOps engineers write clean automation code. Good developers understand how their code will be deployed and operated.
If you have built one - even in a training project - walk through every step: what triggers the pipeline, what the stages are, what happens when a test fails, and where the final artifact ends up. Be specific. "I set up a GitHub Actions workflow that runs on every push to main, runs Jest tests, builds a Docker image, and pushes it to Docker Hub" is a strong answer.
Talk through writing a Dockerfile, choosing a base image, copying your app files, installing dependencies, exposing a port, and running the container. If you have used Docker Compose to run a multi-container app locally, mention that too. Our Docker for beginners guide covers this entire process with real examples.
Be honest. List what you have actually used, even if it is just Docker on your laptop or a free-tier AWS account. Interviewers respect honesty far more than a list of tools you have only read about.
At the entry level, interviewers expect you to handle real tasks - setting up pipelines, working with Linux, debugging containers. The questions get more specific and more practical.
Install Jenkins on a server, install the necessary plugins (Git, Pipeline, Docker), create a new Pipeline job, write a Jenkinsfile that defines your stages (checkout, build, test, deploy), and connect it to your Git repository. Jenkins then triggers the pipeline automatically on every push.
The pipeline stops at the failed stage and notifies the team - usually via Slack, email, or the CI tool's dashboard. The developer who triggered the build checks the logs, identifies the failure (a failing test, a compilation error, a dependency issue), fixes it, and pushes again. A good team treats a broken build as a top priority - it blocks everyone else from merging.
Configure a webhook in your Git repository (GitHub, GitLab) that sends an HTTP request to your CI server whenever code is pushed. Jenkins, GitLab CI, and GitHub Actions all support this natively. In GitHub Actions, you define the trigger in the workflow YAML: on: push or on: pull_request.
sudo lsof -i :8080
# or
sudo ss -tulpn | grep 8080A cron job is a scheduled task that runs automatically at a defined time or interval on a Linux server. You create one by editing the crontab:
crontab -eA cron expression like 0 2 * * * runs a task every day at 2:00 AM. The five fields are: minute, hour, day of month, month, day of week.
An image is a read-only blueprint - a snapshot of an application and all its dependencies. A container is a running instance of that image. One image can run many containers simultaneously. The image is the recipe; the container is the cooked dish.
Containers are stateless by default - data stored inside a container disappears when the container stops. You persist data using Docker volumes, which store data outside the container on the host machine:
docker run -v mydata:/app/data my-appFor our full guide on how CI/CD connects with Docker in a real workflow, the what is CI/CD blog covers the pipeline from code commit to deployment in detail.
At the intermediate level, interviewers expect you to go deeper - architecture decisions, troubleshooting under pressure, and tool-specific technical depth.
A Pod is the smallest deployable unit in Kubernetes. It wraps one or more containers that share the same network namespace and storage. In most cases, a Pod contains a single container. Kubernetes schedules and manages Pods across a cluster of nodes.
Kubernetes has three auto-scaling mechanisms:
Scenario: Your Kubernetes pod is in CrashLoopBackOff, what do you do?
CrashLoopBackOff means the container starts, crashes, and Kubernetes keeps restarting it. Step one is checking the logs:
kubectl logs <pod-name> --previous
kubectl describe pod <pod-name>Common causes: the application is failing on startup due to a missing environment variable, a bad config file, a failed database connection, or an out-of-memory error. Read the logs, find the root cause, fix the underlying issue, and redeploy.
The state file (terraform.tfstate) is Terraform's record of what infrastructure it has created. It maps your configuration to the real resources in the cloud. Without the state file, Terraform cannot know what already exists and would try to create everything from scratch on the next run - potentially creating duplicate resources or destroying existing ones.
In production, the state file lives in a remote backend (like AWS S3 with DynamoDB locking) so it is shared across the team and protected against corruption.
Infrastructure drift happens when someone manually changes a cloud resource outside of Terraform - through the AWS console, for example. Terraform detects drift when you run terraform plan, which shows a difference between the desired state in your config and the actual state of the resource. You fix drift by either updating your Terraform config to match the manual change, or running terraform apply to revert the resource back to the defined state.
Monitoring tells you when something is wrong. You set thresholds on known metrics, CPU over 90%, error rate over 5% - and get alerted when those thresholds are crossed.
Observability tells you why something is wrong. A system is observable when you can diagnose any failure, including failures you did not predict using metrics, logs, and traces that the system produces.
You can monitor a system without it being fully observable. But you cannot achieve true observability without good monitoring as a foundation.
Prometheus is a monitoring system that scrapes metrics from your applications and infrastructure at regular intervals and stores them in a time-series database. Your applications expose a /metrics endpoint; Prometheus polls that endpoint and stores the data.
Grafana connects to Prometheus as a data source and lets you build dashboards that visualize those metrics - request rates, error rates, latency percentiles, infrastructure utilization. Together, they are the most common open-source monitoring stack in DevOps.
Scenario: Your application response time just spiked, how do you investigate?
Start with your monitoring dashboard. Check whether the spike is in all endpoints or a specific one. Check whether it correlates with a deployment - if a release went out in the last 30 minutes, that is your first suspect. Check database query times, external API latency, and CPU/memory usage on the application servers. Pull the application logs for error messages or slow query warnings during the spike window. Narrow it down step by step: is it the application, the database, the network, or an external dependency?
Senior interviews shift from "do you know the tool" to "how do you think about the system." Expect architecture discussions, trade-off questions, and scenarios with no single right answer.
Start with the principles: each service should have its own pipeline, independent deployments, and no hard dependencies between pipeline runs. A typical setup:
Each service has its own repository (or a well-organized monorepo path). Every push triggers: linting, unit tests, Docker image build, container scan, push to registry. On merge to main: integration tests run, image deploys to staging, smoke tests run. On approval: image deploys to production via blue-green or canary strategy. Kubernetes handles the actual deployment; ArgoCD or Flux manages the GitOps sync.
Never hardcode secrets in code or Dockerfiles. Use a dedicated secrets manager:
Rotate secrets regularly, restrict access using IAM roles and least-privilege policies, and audit secret access logs.
Security cannot be a gate at the end of the pipeline - it needs to run at every stage:
First, stay calm. Check the pipeline logs immediately to identify the exact failure point - is it a test, a build step, or a deployment stage? If it is a flaky test that has failed before, assess whether you can skip it safely with justification and release. If it is a real failure, do not push through. Roll back the release plan, fix the root cause, and reschedule. A 10-minute delay is far better than a broken production deployment at peak traffic.
Immediate priority: restore service. Roll back to the previous version first, investigate second. Run the rollback command, confirm the service is back up, and post a status update to the team and any affected stakeholders.
Then investigate: pull deployment logs and application logs from the outage window, compare what changed between the working and broken versions, identify the root cause. Write a post-mortem - not to assign blame, but to document what happened, what the impact was, what fixed it, and what process changes will prevent it next time.
Bring both teams to the same data. Dev teams often push for speed; Ops teams push for stability. Neither is wrong - they are optimizing for different risks. The right answer comes from looking at the deployment frequency, error rate, and recovery time together and deciding on a strategy that serves both.
If the disagreement is about a specific release, run a smaller deployment, canary or staged rollout - that lets the Dev team ship while giving Ops team the ability to roll back quickly if metrics degrade.
Always prepare 3-4 questions to ask at the end. It shows that you think about the work seriously, not just about getting the job.
These questions also tell you a lot about whether the team operates at a level you want to be part of.

DevOps interviews reward people who understand why the tools exist, not just what they do. Every question in this guide - from the basics to the senior scenarios - comes back to that same idea: can you think clearly about software delivery problems and solve them with the right combination of culture, automation, and tooling?
Prepare with real projects. Practice talking through your work. And walk in knowing that the best answer is always an honest one backed by something you have actually built.
Want to build job-ready DevOps skills with real pipelines and hands-on cloud projects? Explore Skill Shikshya's DevOps and Cloud diploma program, built around what Nepal's IT industry is actually hiring for right now.
