Guides › Cloud Computing & DevOps
DevOps Interview Questions and Answers: Complete Guide
Prepare for DevOps interviews with detailed questions and answers covering Linux, networking, Git, CI/CD, Jenkins, Docker, Kubernetes, cloud computing, Terraform, Ansible, monitoring, logging, security, deployment strategies, troubleshooting scenarios, practical commands, and real-world interview pr
DevOps Interview Questions and Answers: Complete Guide
1. What Is DevOps?
DevOps is a set of practices, cultural principles, and tools that help development and operations teams collaborate to deliver software reliably and frequently.
DevOps emphasizes automation, continuous feedback, shared responsibility, monitoring, and continuous improvement.
Benefits of DevOps
- Faster and more consistent software delivery.
- Earlier detection of defects.
- Repeatable deployments.
- Better collaboration between teams.
- Improved visibility through monitoring.
- Faster recovery from failures.
- More consistent infrastructure configuration.
DevOps is not simply a collection of tools. Installing Jenkins, Docker, or Kubernetes does not create an effective DevOps process unless teams also improve testing, delivery, security, operations, and feedback.
2. What Is the DevOps Lifecycle?
A common lifecycle contains these stages:
- Plan: Define requirements and work items.
- Code: Develop and review application changes.
- Build: Compile or package the application.
- Test: Run automated tests and quality checks.
- Release: Prepare a version for deployment.
- Deploy: Deliver the version to an environment.
- Operate: Keep the service running and manage changes.
- Monitor: Collect signals and detect problems.
- Feedback: Use operational and user feedback to improve the next iteration.
The process is continuous rather than a strict one-way sequence.
3. What Is the Difference Between Agile and DevOps?
Agile focuses on iterative software development, customer feedback, and adapting to changing requirements.
DevOps extends collaboration across development, deployment, and operations. It emphasizes delivery automation, operational reliability, observability, and shared ownership.
They complement each other but are not interchangeable.
4. What Is CI/CD?
Continuous Integration (CI) means frequently integrating code changes into a shared repository and validating them through automated checks.
Continuous Delivery keeps validated changes ready for release, with production release often requiring approval.
Continuous Deployment automatically releases qualifying changes to production after the required checks pass.
Example CI/CD Pipeline
- Developer pushes a Git commit.
- CI system checks out the code.
- Dependencies are installed.
- Unit tests and static analysis run.
- An artifact or container image is built.
- Security and quality checks run.
- The artifact is stored in a registry.
- The application is deployed to a test environment.
- Integration and smoke tests run.
- A controlled production release occurs.
- Monitoring verifies application health.
- Failed releases trigger rollback or remediation procedures.
5. What Is a CI/CD Pipeline?
A CI/CD pipeline is an automated sequence of jobs that builds, tests, validates, packages, and delivers software.
A good pipeline should be:
- Repeatable.
- Version controlled.
- Secure.
- Observable.
- Fast enough to provide useful feedback.
- Able to stop on failed required checks.
- Designed for controlled releases and recovery.
Pipeline design depends on application architecture, risk, and delivery requirements.
6. What Is Jenkins?
Jenkins is an automation server commonly used to build CI/CD pipelines through plugins, pipeline definitions, and integrations.
Important concepts include:
- Controller and agent architecture.
- Jobs and pipelines.
- Jenkinsfile.
- Plugins and credentials.
- Build parameters.
- Artifacts.
- Build logs.
- Pipeline triggers.
- Access control.
What Is a Jenkinsfile?
A Jenkinsfile defines a pipeline as code and is usually stored in the application's source repository.
Example declarative pipeline:
pipeline {
agent any
stages {
stage('Checkout') {
steps {
checkout scm
}
}
stage('Test') {
steps {
echo 'Run automated tests here'
}
}
stage('Package') {
steps {
echo 'Build the application artifact here'
}
}
}
}
This is a minimal illustration, not a complete production pipeline. Replace the placeholder steps with real build, test, scanning, artifact publishing, and deployment commands.
Jenkins Best Practices
- Store pipeline definitions in version control.
- Restrict access to Jenkins administrators and agents.
- Use the credentials store instead of hardcoded secrets.
- Keep Jenkins and plugins updated.
- Separate trusted and untrusted workloads.
- Use ephemeral or isolated agents where appropriate.
- Archive useful logs and artifacts.
- Avoid giving build agents unnecessary production privileges.
7. What Is Git?
Git is a distributed version control system that records source-code changes and supports collaboration.
Important concepts include:
- Repository.
- Commit.
- Branch.
- Merge.
- Rebase.
- Remote.
- Pull request.
- Tag.
- Conflict resolution.
.gitignore.
Common Git Commands
git init
git status
git add .
git commit -m "Add initial application"
git branch
git switch -c feature/login
git log --oneline
git diff
git fetch
git pull
git push
The exact workflow for pushing depends on whether a remote and upstream branch have been configured.
What Is a Merge Conflict?
A merge conflict occurs when Git cannot automatically reconcile overlapping changes. The developer must review the affected files, decide the intended result, remove conflict markers, test the changes, and complete the merge or rebase.
Never resolve a conflict by blindly accepting one side without understanding what the code does.
What Is the Difference Between Merge and Rebase?
- Merge combines histories and normally creates a merge commit when needed.
- Rebase reapplies commits onto a different base, producing a rewritten commit history.
Avoid rewriting shared public history unless the team has an agreed workflow.
8. What Is Linux and Why Is It Important in DevOps?
Linux is widely used for servers, cloud instances, containers, and infrastructure tooling.
A DevOps engineer should understand:
- Files and directories.
- Users and groups.
- Permissions.
- Processes and services.
- Package management.
- Logs.
- Networking.
- Disk and memory usage.
- Shell scripting.
- SSH access.
Essential Linux Commands
pwd
ls -lah
cd /var/log
cat file.txt
less application.log
grep "ERROR" application.log
tail -f application.log
find /var/log -name "*.log"
ps aux
top
free -h
df -h
du -sh /var/log
These commands help inspect the filesystem, search logs, and diagnose resource usage.
How Do You Check a Running Service?
On a system using systemd:
systemctl status nginx
systemctl restart nginx
journalctl -u nginx --since "30 minutes ago"
Service names and permissions vary. Review the status and logs before restarting a critical production service.
How Do You Check Disk Space?
df -h
du -sh /path/to/directory
df reports filesystem usage, while du estimates space used by files and directories. A deleted file may continue occupying disk space if a running process still has it open.
9. What Is SSH?
SSH is a protocol for securely accessing remote systems and executing commands.
Common tasks include:
- Using key-based authentication.
- Managing authorized keys.
- Verifying host identity.
- Restricting account permissions.
- Troubleshooting connectivity.
Example:
ssh -i ~/.ssh/lab_key USERNAME@SERVER_ADDRESS
Replace the placeholders with the correct user, key, and host. Protect private keys and verify host fingerprints; do not disable host-key verification merely to suppress warnings.
10. What Is Networking in DevOps?
Networking enables applications and infrastructure components to communicate.
Important concepts:
- IP addresses and subnets.
- DNS.
- TCP and UDP.
- Ports.
- HTTP and HTTPS.
- Routing.
- Firewalls.
- NAT.
- Load balancers.
- TLS certificates.
- Proxies.
Useful Diagnostic Commands
ping example.com
curl -I https://example.com
nslookup example.com
dig example.com
ss -lnt
Some commands may not be installed by default, and ICMP requests can be blocked even when a service is working.
How Would You Troubleshoot a Website That Is Not Accessible?
- Confirm the URL and DNS resolution.
- Check whether the server or hosting platform is healthy.
- Verify the application process and listening port.
- Check firewalls and network routes.
- Inspect the load balancer and health checks.
- Test TLS certificates and HTTPS configuration.
- Review application and proxy logs.
- Compare the failure with recent deployments or configuration changes.
Use a systematic approach rather than restarting every component immediately.
11. What Is Docker?
Docker is used to build, distribute, and run containerized applications.
Core concepts:
- Images.
- Containers.
- Dockerfiles.
- Registries.
- Volumes.
- Networks.
- Compose.
Image vs Container
An image is a packaged template. A container is a runtime instance created from that image.
Useful Docker Commands
docker build -t myapp:1.0 .
docker images
docker run -d --name myapp -p 8080:80 myapp:1.0
docker ps
docker logs myapp
docker inspect myapp
docker stats
docker stop myapp
The port mapping assumes the application listens on port 80 inside the container. Adjust it for your application.
How Do You Reduce Docker Image Size?
- Choose an appropriate small base image.
- Use
.dockerignore. - Remove unnecessary build dependencies from the runtime image.
- Use multi-stage builds.
- Avoid copying caches and development files.
- Use reproducible dependency installation.
- Inspect image layers to identify unnecessary content.
Do not choose a base image solely because it is small; consider maintenance, compatibility, and security.
12. What Is Kubernetes?
Kubernetes orchestrates containerized workloads and manages their scheduling, scaling, networking, and lifecycle.
Important concepts:
- Cluster.
- Control plane.
- Node.
- Pod.
- Deployment.
- ReplicaSet.
- Service.
- Namespace.
- ConfigMap.
- Secret.
- PersistentVolumeClaim.
- Ingress or Gateway.
What Is a Pod?
A Pod is the smallest deployable unit in Kubernetes and can contain one or more related containers that share selected resources.
What Is a Deployment?
A Deployment manages replicated Pods and supports declarative updates and rollbacks.
What Is a Service?
A Service offers a stable network endpoint for a changing set of Pods.
Useful Kubernetes Commands
kubectl get nodes
kubectl get pods -A
kubectl get deployments
kubectl describe pod POD_NAME
kubectl logs POD_NAME
kubectl get services
kubectl get events
kubectl rollout status deployment/DEPLOYMENT_NAME
kubectl rollout undo deployment/DEPLOYMENT_NAME
Replace placeholders with actual resource names and check the current Kubernetes context before running commands.
13. What Is Infrastructure as Code (IaC)?
Infrastructure as Code defines infrastructure through files that can be version controlled, reviewed, tested, and applied repeatedly.
Benefits:
- Repeatability.
- Reviewable changes.
- Reduced manual configuration.
- Easier environment recreation.
- Better documentation.
- Drift detection.
Popular tools include Terraform, OpenTofu, CloudFormation, and Bicep.
What Is Terraform?
Terraform is an infrastructure-as-code tool that uses configuration files to describe resources and their relationships.
Common commands:
terraform init
terraform fmt -check
terraform validate
terraform plan
terraform apply
Inspect the plan before applying changes. State files can contain sensitive information and must be protected.
What Is Terraform State?
State records the relationship between Terraform configuration and managed resources. It helps Terraform determine what changes are needed.
Use an appropriate state backend, access controls, and locking support where available. Do not publish state files or casually edit them manually.
What Is Configuration Drift?
Configuration drift occurs when actual infrastructure differs from its intended or recorded configuration, for example after manual console changes.
Detect drift through planned comparisons, policy checks, and regular reviews. Correct drift carefully because the intended configuration may not reflect every emergency change made in production.
14. What Is Ansible?
Ansible automates configuration management and operational tasks. It commonly connects to remote systems over SSH for Linux targets and can manage many other systems through supported connection methods.
Important concepts:
- Inventory.
- Playbooks.
- Tasks.
- Modules.
- Variables.
- Templates.
- Roles.
- Handlers.
- Idempotency.
What Is Idempotency?
An operation is idempotent when repeating it produces the same intended final state rather than repeatedly introducing additional changes.
Idempotency is valuable in automation because a playbook may run multiple times.
Example playbook:
---
- name: Configure web server
hosts: web
become: true
tasks:
- name: Install Nginx
ansible.builtin.package:
name: nginx
state: present
- name: Ensure Nginx is running
ansible.builtin.service:
name: nginx
state: started
enabled: true
The inventory group web must exist and contain suitable target systems. Package and service behavior depends on the target operating system.
15. What Is Monitoring and Observability?
Monitoring tracks system health using metrics, alerts, dashboards, and logs.
Observability uses telemetry to help explain why a system behaves in a particular way. It commonly combines:
- Metrics: Numeric measurements over time.
- Logs: Records of events.
- Traces: End-to-end request journeys across services.
Popular tools include Prometheus, Grafana, OpenTelemetry-based systems, and cloud-native monitoring platforms.
What Should You Monitor?
- Availability and error rates.
- Response latency.
- Request throughput.
- CPU, memory, and disk usage.
- Database health and connection saturation.
- Queue depth.
- Deployment failures.
- Certificate expiration.
- Backup and recovery status.
Alert on meaningful symptoms and actionable conditions. Excessive alerts can create noise and hide genuine incidents.
16. What Is Logging?
Logging records application and infrastructure events for debugging, auditing, and operational analysis.
Best practices:
- Prefer structured logs where practical.
- Include timestamps and useful correlation identifiers.
- Use appropriate log levels.
- Centralize logs when necessary.
- Set retention policies.
- Restrict access to sensitive logs.
- Avoid recording passwords, tokens, or unnecessary personal information.
A useful incident investigation correlates application logs with deployment events, infrastructure metrics, and traces.
17. What Is a Load Balancer?
A load balancer distributes incoming requests among available targets according to configured rules and health checks.
Benefits can include:
- Better distribution of traffic.
- Improved availability.
- Easier horizontal scaling.
- TLS termination where supported.
- Health-based routing.
A load balancer alone does not guarantee high availability. Its configuration, backend health, dependencies, and deployment design also matter.
18. What Is Blue-Green Deployment?
Blue-green deployment maintains two production-like environments:
- Blue: the current version.
- Green: the candidate version.
The new version is tested in the inactive environment, and traffic is switched when the release is ready.
Advantages:
- Fast traffic switching.
- Clear separation of versions.
- Potentially straightforward application rollback.
Challenges:
- Additional infrastructure cost.
- Database compatibility.
- Session and data migration concerns.
- Ensuring the inactive environment is truly ready.
A traffic switch does not automatically reverse data changes made by the new application.
19. What Is Canary Deployment?
A canary deployment releases a new version to a small subset of traffic or users first.
The team monitors error rates, latency, business metrics, and other health indicators before gradually expanding the rollout.
If the new version performs poorly, traffic can be shifted back, subject to the release architecture.
Canary deployment reduces exposure but requires reliable monitoring and a clear rollback policy.
20. What Is Rolling Deployment?
A rolling deployment gradually replaces old application instances with new ones.
Important considerations:
- Readiness and health checks.
- Minimum healthy capacity.
- Backward compatibility.
- Connection draining.
- Database migrations.
- Rollback procedures.
A rolling update can reduce downtime, but it does not guarantee zero downtime. Application and infrastructure behavior determine the outcome.
21. What Is GitOps?
GitOps uses version-controlled declarations as the primary source of truth for intended infrastructure or application state. Automated controllers reconcile the running environment toward that state.
Benefits:
- Auditable changes.
- Reviewable configuration.
- Repeatable deployment.
- Clear change history.
- Drift detection and reconciliation.
GitOps does not mean every secret should be committed to Git. Use appropriate secret-management mechanisms and protect repository access.
22. What Is Site Reliability Engineering (SRE)?
SRE applies software engineering methods to operations and reliability.
Important concepts:
- SLI: A measured indicator of service behavior.
- SLO: A target for an SLI over a defined period.
- SLA: An agreement that may define service commitments and consequences.
- Error budget: The acceptable unreliability implied by an SLO.
- Toil: Repetitive operational work that can often be reduced through automation.
Example: An SLI might measure the percentage of successful requests within a defined latency threshold. An SLO sets the target and measurement window.
The specific target should reflect user expectations and business requirements.
23. What Is Incident Management?
Incident management is the process of detecting, responding to, resolving, and learning from service disruptions.
A typical workflow:
- Detect the incident.
- Assess severity and user impact.
- Assign an incident lead and relevant responders.
- Mitigate immediate harm.
- Communicate status to stakeholders.
- Restore service.
- Validate recovery.
- Document the timeline.
- Conduct a blameless review.
- Track corrective actions.
The first goal is to reduce impact and restore service safely. Root-cause analysis and long-term fixes follow, often in parallel when staffing allows.
24. What Is Shift-Left Security?
Shift-left security means introducing security checks earlier in the software development lifecycle.
Examples include:
- Code analysis.
- Dependency vulnerability scanning.
- Secret detection.
- Container image scanning.
- Infrastructure policy checks.
- Threat modeling.
- Automated tests for access control.
Security must continue after deployment through patching, monitoring, incident response, and access reviews.
25. What Is DevSecOps?
DevSecOps integrates security into development, delivery, and operations rather than treating it as a final approval step.
Practices include:
- Secure coding.
- Dependency management.
- Identity and access control.
- Secrets management.
- Automated security testing.
- Infrastructure policy validation.
- Runtime monitoring.
- Vulnerability remediation.
Automated checks should have clear severity policies and a documented process for handling exceptions.
26. How Do You Manage Secrets in CI/CD?
- Use the CI platform's supported secret store or a managed secret manager.
- Give each job only the credentials it needs.
- Use short-lived credentials where supported.
- Mask secrets in logs where possible.
- Avoid printing environment variables.
- Rotate exposed credentials immediately.
- Restrict who can modify privileged pipelines.
- Separate development, staging, and production permissions.
Masking is not a guarantee against every form of leakage. Avoid placing secrets in command arguments, build artifacts, images, or generated reports.
27. What Is a Health Check?
A health check determines whether an application or infrastructure component is functioning sufficiently for a particular purpose.
Common forms:
- Liveness: Is the process still functioning?
- Readiness: Should this instance receive traffic?
- Startup: Has the application completed startup?
- Synthetic check: Can a monitored external user journey succeed?
A health endpoint should avoid exposing internal secrets or sensitive infrastructure details.
28. Scenario-Based Interview Questions
Scenario 1: A Deployment Succeeds but the Website Returns Errors. What Do You Do?
- Confirm the scope and severity of the problem.
- Check error rates and recent release history.
- Inspect application, proxy, and platform logs.
- Verify configuration, environment variables, and secrets.
- Check dependency connectivity and database health.
- Compare the current release with the last known-good version.
- Roll back or mitigate if the risk justifies it.
- Confirm recovery through monitoring and user-facing tests.
- Record the cause and preventive actions.
Scenario 2: A Server Is Running Out of Disk Space.
- Check filesystem capacity with
df -h. - Identify large directories with
du. - Inspect application logs, caches, temporary files, and container storage.
- Check whether deleted files are still held open by processes.
- Expand storage or clean up only after confirming what is safe to remove.
- Add alerts and a long-term retention or capacity plan.
Do not delete database files or unknown system files to free space quickly.
Scenario 3: A Kubernetes Pod Is in CrashLoopBackOff.
- Run
kubectl describe pod POD_NAME. - Inspect
kubectl logs POD_NAME. - If the container restarted, inspect its previous logs.
- Check command arguments and environment configuration.
- Review permissions, dependencies, probes, and resource limits.
- Correct the cause and monitor the rollout.
Scenario 4: An Application Works Locally but Fails in Production.
Possible causes include:
- Environment differences.
- Missing dependencies.
- Incorrect configuration.
- Different permissions.
- Network restrictions.
- DNS or TLS errors.
- Database schema differences.
- Architecture mismatch.
- Missing secrets.
- Resource constraints.
Compare environments systematically and reproduce the failure in a controlled test environment.
Scenario 5: A CI/CD Pipeline Is Very Slow.
- Identify which stage consumes the most time.
- Parallelize independent tests where safe.
- Cache dependencies appropriately.
- Avoid rebuilding unchanged components unnecessarily.
- Use efficient build agents.
- Remove redundant steps.
- Track duration and failure rates over time.
Caching must not make builds non-reproducible or allow stale dependencies to bypass required checks.
Scenario 6: Cloud Costs Increase Suddenly.
- Inspect billing and usage reports.
- Identify the affected service, region, and resource tags.
- Check recent deployments and traffic changes.
- Look for oversized or abandoned resources.
- Investigate data transfer, logs, and storage growth.
- Stop or resize resources only after assessing production impact.
- Add budgets, alerts, and ownership metadata.
Scenario 7: A Secret Is Accidentally Committed to Git.
- Revoke or rotate the secret immediately.
- Investigate access logs and potential misuse.
- Remove the secret from active configuration.
- Clean repository history if required by policy, while recognizing that copies may remain.
- Notify the appropriate security team.
- Add secret scanning and safer credential handling.
- Review related credentials and permissions.
Deleting the file in a later commit does not invalidate an exposed credential.
29. Common DevOps Commands Reference
Git
git status
git log --oneline
git diff
git switch -c feature-name
git fetch
git pull
git push
Linux
ps aux
top
free -h
df -h
du -sh /path
tail -f application.log
Docker
docker ps
docker images
docker logs CONTAINER_NAME
docker inspect CONTAINER_NAME
docker stats
Kubernetes
kubectl get pods -A
kubectl get deployments
kubectl describe pod POD_NAME
kubectl logs POD_NAME
kubectl get events
Terraform
terraform init
terraform fmt -check
terraform validate
terraform plan
terraform apply
Networking
curl -I https://example.com
dig example.com
ss -lnt
Commands and flags can vary by tool version and operating system. Review output before performing destructive or production-changing operations.
30. DevOps Portfolio Projects
Project 1: Automated CI Pipeline
Build a small application pipeline that checks out source code, runs tests, performs static analysis, and publishes a versioned artifact.
Project 2: Containerized Application
Create a Dockerfile for an application, add health checks, configure persistent storage if required, and document image versioning and cleanup.
Project 3: CI/CD Deployment
Automate deployment to a test environment. Add an approval or controlled release step, smoke tests, and a rollback plan.
Project 4: Infrastructure as Code
Provision a small test environment with Terraform or an equivalent tool. Use variables, outputs, version control, reviewed plans, and secure state storage.
Project 5: Monitoring Dashboard
Collect application metrics, display request rate and latency, configure useful alerts, and demonstrate how an incident would be investigated.
Project 6: Kubernetes Deployment
Deploy a containerized application using a Deployment and Service. Add probes, resource requests, configuration, and a documented update and rollback process.
Project 7: Backup and Recovery
Back up sample data, perform a restoration in a test environment, measure recovery time, and document the limitations.
For each project, include:
- Problem statement.
- Architecture diagram.
- Tools and versions.
- Setup instructions.
- Test results.
- Security considerations.
- Troubleshooting notes.
- Cleanup instructions.
- Lessons learned.
31. DevOps Interview Preparation Plan
| Week | Focus |
|---|---|
| 1 | Linux commands, processes, permissions, and shell basics |
| 2 | Networking, DNS, HTTP, TLS, and troubleshooting |
| 3 | Git workflows, branching, and conflicts |
| 4 | CI/CD concepts and Jenkins pipelines |
| 5 | Docker, images, volumes, and Compose |
| 6 | Kubernetes objects and troubleshooting |
| 7 | Cloud fundamentals, IAM, and networking |
| 8 | Terraform, Ansible, and infrastructure automation |
| 9 | Monitoring, logs, alerts, and SRE concepts |
| 10 | DevSecOps and secrets management |
| 11 | Scenario-based questions and mock interviews |
| 12 | Build, document, and present a portfolio project |
Practice explaining not just what a tool does, but why it is appropriate, what alternatives exist, what can fail, and how you would recover.
32. Questions You Should Be Able to Answer
- What is DevOps, and what problems does it solve?
- What is the difference between CI, continuous delivery, and continuous deployment?
- How do Git merge and rebase differ?
- How do you troubleshoot a Linux server with high CPU usage?
- How are Docker images different from containers?
- How do you persist container data?
- What are Pods, Deployments, and Services?
- What causes a Pod to enter CrashLoopBackOff?
- What is Infrastructure as Code?
- How do you protect Terraform state?
- How do Ansible playbooks help automate configuration?
- What is the difference between metrics, logs, and traces?
- How do blue-green, canary, and rolling deployments differ?
- How do you protect CI/CD secrets?
- What are SLI, SLO, SLA, and error budgets?
- How do you investigate a failed deployment?
- How do you plan backup restoration and disaster recovery?
- How do you reduce cloud costs without harming reliability?
Conclusion
Strong DevOps engineers combine automation, software delivery, systems knowledge, cloud infrastructure, security, and operational judgment. Build practical projects, learn to troubleshoot systematically, and be prepared to explain trade-offs instead of memorizing definitions alone.
More guides
- How to Use Codify: A 7-Day Start Plan — New here? Pick a roadmap, make a study plan, start the DSA sheet, revise with notes, practise for placements and test yourself — one step a day, then a daily routine.
- Infosys Preparation Guide: Online Test, Pseudocode and Interview — Roles (SE, DSE, SP), what each section of the Infosys online test checks, how to crack pseudocode and reasoning, a 4-week plan and the interview.
- Wipro Elite NLTH Preparation: Aptitude, Essay and Coding — The Wipro fresher test round by round — quant, logical and verbal, the written essay, two coding problems — plus a 3-week plan and interview tips.
- Accenture Preparation Guide: Cognitive, Technical, Coding and Communication — Every Accenture round explained — cognitive, MS Office/networking/cloud technical MCQs, pseudocode, coding and the spoken-English test — with a 4-week plan.