DevOps & Cloud Engineering (AWS)

Operate and troubleshoot Linux servers confidently, the baseline skill every DevOps and cloud interview screens for first.

• Linux filesystem hierarchy and file permissions (chmod, chown, umask)
• Process management (ps, top, htop, kill, nice, systemd services)
• Package management with apt/yum/dnf and building from source
• User, group, and sudo privilege administration
• Disk, volume, and filesystem management (fdisk, lvm, mount, df/du)
• Bash scripting fundamentals: variables, loops, conditionals, functions
• Text processing with grep, sed, awk, and regular expressions
• Job scheduling with cron and systemd timers
• Log inspection and rotation (journalctl, logrotate, /var/log)
• SSH key management, remote access, and hardening (sshd_config)
• Networking basics on Linux (ip, netstat/ss, curl, dig)
• Writing idempotent shell scripts for automation tasks
• Environment variables, PATH management, and shell profiles
• Basic performance troubleshooting (load average, memory, iostat)

Build a working mental model of how requests travel across networks, so cloud and container networking clicks instead of confuses.

• OSI and TCP/IP model layers with real packet examples
• IP addressing, subnetting, and CIDR notation
• TCP vs UDP: handshakes, ports, and connection states
• DNS resolution flow: resolvers, records (A/CNAME/MX), and propagation
• HTTP/HTTPS request lifecycle and status codes
• TLS/SSL handshake basics and certificate chains
• Load balancing concepts: L4 vs L7, health checks, sticky sessions
• Firewalls, security groups, and network ACLs
• VPNs, NAT, and proxy servers (forward vs reverse)
• Reading and troubleshooting with ping, traceroute, curl, dig, netstat
• VPC design basics: public/private subnets, route tables, gateways
• CDN fundamentals and edge caching
• Common network troubleshooting scenarios in production incidents

Write practical Python scripts that automate infrastructure tasks and interact with cloud APIs, a core skill DevOps interviewers probe.

• Python fundamentals refresher: data types, control flow, functions
• Working with files, JSON, and YAML for config-driven scripts
• Virtual environments and dependency management (venv, pip, requirements.txt)
• Writing and consuming REST APIs with the requests library
• AWS automation with boto3: EC2, S3, IAM scripting
• Error handling, logging, and retries in automation scripts
• Argument parsing for reusable CLI tools (argparse, click)
• Automating server health checks and log parsing scripts
• Writing unit tests for automation code (pytest basics)
• Working with environment variables and secrets in scripts securely
• Scheduling and orchestrating Python jobs (cron, simple task runners)
• Parsing and transforming CSV/JSON data for reporting pipelines
• Building a small automation project: cloud resource inventory script
• Code style, linting, and packaging basics for shared team scripts

Master Git workflows used by real engineering teams, so collaboration and code history never become an interview blind spot.

• Git fundamentals: init, clone, add, commit, status, log
• Branching strategies: feature branches, Gitflow, trunk-based development
• Merging vs rebasing and resolving merge conflicts
• Remote workflows: push, pull, fetch, and tracking branches
• Pull request workflows and effective code review practices
• Tagging, releases, and semantic versioning
• Undoing changes: reset, revert, checkout, and reflog
• Git hooks for automation (pre-commit, pre-push)
• Managing large repos: .gitignore, submodules, and monorepos
• Collaborative workflows on GitHub: forks, issues, and reviews
• Protecting branches and enforcing CI checks before merge
• Git internals: commits, trees, blobs, and how history is stored
• Troubleshooting common Git problems in team settings

Get hands-on with the AWS services that power most real-world cloud infrastructure, directly aligned with industry deployment patterns.

• IAM: users, groups, roles, and least-privilege policies
• EC2: instance types, AMIs, key pairs, and auto scaling groups
• VPC design: subnets, route tables, internet/NAT gateways, security groups
• S3: buckets, storage classes, versioning, and lifecycle policies
• Elastic Load Balancing (ALB/NLB) and target groups
• RDS: managed relational databases, backups, and read replicas
• Route 53 for DNS management and routing policies
• CloudWatch for metrics, logs, alarms, and dashboards
• Lambda and serverless basics for automation triggers
• CloudFormation fundamentals for declarative provisioning
• AWS CLI configuration, profiles, and scripting common tasks
• Cost visibility and tagging strategy for cloud resources
• AWS Well-Architected Framework pillars overview
• Common AWS Solutions Architect Associate exam-style scenarios

Package and ship applications reliably with Docker, the container skill every modern deployment pipeline depends on.

• Container fundamentals: images, layers, and namespaces/cgroups
• Writing efficient Dockerfiles and multi-stage builds
• Docker CLI essentials: build, run, exec, logs, ps
• Managing images and containers with Docker Hub and private registries
• Docker networking modes (bridge, host, none) and custom networks
• Persisting data with volumes and bind mounts
• Docker Compose for multi-container local environments
• Image optimization: reducing size, layer caching, .dockerignore
• Container security basics: non-root users, image scanning (Trivy)
• Pushing images to Amazon ECR and integrating with CI
• Resource limits and health checks for containers
• Debugging container startup failures and log inspection
• Introduction to container orchestration concepts (why Kubernetes)

Deploy, scale, and operate containerized applications on Kubernetes, the orchestration standard expected in senior DevOps roles.

• Kubernetes architecture: control plane, kubelet, kube-proxy, etcd
• Core objects: Pods, ReplicaSets, Deployments, and Services
• kubectl essentials for managing and debugging workloads
• ConfigMaps and Secrets for application configuration
• Networking model: ClusterIP, NodePort, LoadBalancer, and Ingress
• Persistent storage: PersistentVolumes and PersistentVolumeClaims
• StatefulSets, DaemonSets, Jobs, and CronJobs use cases
• Namespaces, resource requests/limits, and quotas
• Rolling updates, rollbacks, and deployment strategies
• Helm charts for packaging and templating applications
• Horizontal Pod Autoscaling and cluster autoscaling basics
• Managed Kubernetes on AWS with EKS
• RBAC and security basics for cluster access control
• Troubleshooting common pod failures (CrashLoopBackOff, pending pods)

Automate build, test, and deployment workflows end to end, turning manual releases into repeatable, reliable pipelines.

• CI/CD concepts: continuous integration, delivery, and deployment differences
• Designing a pipeline: build, test, package, deploy stages
• Jenkins fundamentals: jobs, pipelines-as-code (Jenkinsfile), agents
• GitHub Actions: workflows, jobs, runners, and reusable actions
• Automated testing integration in pipelines (unit, integration)
• Artifact management and versioning across pipeline stages
• Building and pushing Docker images within CI pipelines
• Deployment strategies: blue-green, canary, and rolling deployments
• Secrets management in CI/CD (encrypted secrets, vault integration)
• Pipeline triggers: webhooks, scheduled builds, and branch policies
• Notifications and pipeline observability (build status, alerts)
• Deploying to AWS/Kubernetes from a CI/CD pipeline
• Common pipeline failure debugging and rollback strategies

Provision and manage cloud infrastructure through code, eliminating manual clicks and making environments reproducible and auditable.

• IaC principles: declarative vs imperative provisioning
• Terraform basics: providers, resources, variables, and outputs
• Terraform state management and remote backends (S3 + DynamoDB locking)
• Modules for reusable, composable infrastructure code
• Terraform plan/apply workflow and change management
• Provisioning AWS resources with Terraform (VPC, EC2, S3, RDS)
• Ansible fundamentals: inventories, playbooks, and modules
• Configuration management vs provisioning: when to use each tool
• Ansible roles for reusable configuration across environments
• Idempotency and drift detection in infrastructure code
• Integrating Terraform/Ansible into CI/CD pipelines
• Managing multiple environments (dev/stage/prod) with workspaces
• Version-controlling infrastructure code and peer review practices
• Security best practices for IaC (secrets, least-privilege roles)

Instrument systems for observability and lock them down against real threats, the skills that keep production stable and audit-ready.

• Observability fundamentals: metrics, logs, and traces
• Prometheus architecture: exporters, scraping, and PromQL basics
• Building dashboards and alerts in Grafana
• Setting up Alertmanager for on-call notification routing
• AWS CloudWatch metrics, alarms, and log insights queries
• Application and infrastructure health checks and SLOs/SLIs
• Container and Kubernetes monitoring (node exporter, kube-state-metrics)
• Security fundamentals: shared responsibility model on AWS
• IAM security best practices and least-privilege auditing
• Secrets management (AWS Secrets Manager, HashiCorp Vault basics)
• Container image scanning and vulnerability management (Trivy)
• Network security: security groups, NACLs, and WAF basics
• Incident response basics: detection, triage, and postmortems
• Compliance and logging for audit trails (CloudTrail, GuardDuty overview)