DevOps Upskilling for Job Switch

Write a defensive Bash script with strict error handling, validation, and cleanup.

Use text-processing tools to extract structured evidence from production logs.

Write a Python program that parses logs and summarizes operational failures.

Call a paginated REST API from Python with authentication, timeouts, and retries.

Implement exponential backoff without retrying non-transient failures.

Write unit tests for an infrastructure automation function.

Review an operations script for reliability, security, and idempotency defects.

Trace traffic through an AWS VPC using routes, security groups, network ACLs, and gateways.

Select an AWS load balancer based on protocol, routing, scaling, and availability requirements.

Evaluate an IAM request using identity policies, resource policies, permission boundaries, and SCPs.

Diagnose failed access to a private AWS workload from observed network evidence.

Choose an AWS compute service for a workload based on operational trade-offs.

Design a Multi-AZ application pattern that removes identified single points of failure.

Select an AWS storage service based on consistency, durability, latency, and access-pattern requirements.

Estimate the principal reliability and cost trade-offs in an AWS scaling design.

Predict Terraform resource changes from configuration, state, and provider behavior.

Design a remote-state layout that limits access and failure blast radius.

Refactor Terraform configuration into a reusable module without changing managed resources.

Use lifecycle controls without masking unsafe infrastructure changes.

Import an existing AWS resource into Terraform without unintended replacement.

Detect and reconcile infrastructure drift through a controlled workflow.

Design a team workflow for reviewing, locking, and applying Terraform changes.

Test Terraform code with formatting, validation, policy, and behavioral checks.

Explain how Linux namespaces and cgroups enforce container isolation and resource limits.

Set Kubernetes resource requests and limits from observed workload behavior.

Select liveness, readiness, and startup probes for a given failure model.

Configure graceful pod startup and termination for disruption-safe deployments.

Choose a Kubernetes rollout strategy based on risk and rollback requirements.

Control pod placement using affinities, taints, tolerations, and topology constraints.

Configure horizontal pod autoscaling from suitable workload signals.

Package a configurable Kubernetes application as a maintainable Helm chart.

Trace service traffic through Kubernetes DNS, Services, endpoints, and kube-proxy behavior.

Diagnose ingress and TLS routing failures from Kubernetes and controller evidence.

Enforce namespace traffic boundaries with Kubernetes NetworkPolicies.

Design least-privilege Kubernetes RBAC for an application and its operators.

Apply pod security controls to block a specified container escape path.

Diagnose Pending, CrashLoopBackOff, and ImagePullBackOff pods systematically.

Diagnose node pressure and eviction behavior from cluster evidence.

Plan a Kubernetes cluster upgrade with compatibility checks and rollback safeguards.

Design a CI/CD pipeline with fast feedback, promotion controls, and clear failure ownership.

Create an immutable artifact versioning strategy that supports audit and rollback.

Place unit, integration, security, and deployment tests at appropriate pipeline stages.

Replace long-lived cloud credentials in CI/CD with short-lived federated identity.

Choose between rolling, blue-green, and canary delivery for a specified risk profile.

Define an automated rollback decision using health and business signals.

Explain how a GitOps reconciliation loop detects and corrects configuration drift.

Use DORA metrics to identify a delivery bottleneck without incentivizing harmful behavior.

Define a measurable service-level indicator from a user-visible reliability expectation.

Set an SLO and error-budget measurement window for a given service.

Write PromQL queries for rate, ratio, latency percentile, and saturation analysis.

Design structured application logs that support correlation without exposing secrets.

Trace a request across service boundaries using distributed tracing context.

Build a dashboard that distinguishes symptoms from likely causes.

Create a multi-window burn-rate alert for an SLO.

Control telemetry cost through sampling, retention, and cardinality decisions.

Translate an error-budget state into a defensible release policy.

Forecast service capacity from demand, utilization, and growth evidence.

Perform a failure-mode analysis for a distributed service dependency.

Choose timeout, retry, circuit-breaker, and load-shedding settings for a failure scenario.

Assign incident roles and communication channels for a major production event.

Write an executable runbook for a recurring operational failure.

Write a blameless post-incident review with testable corrective actions.

Derive a disaster-recovery design from explicit RTO and RPO requirements.

Construct a threat model for an AWS-hosted Kubernetes workload.

Design a secrets workflow that supports encryption, access control, and rotation.

Prioritize container vulnerabilities using exploitability and runtime context.

Generate and use an SBOM to investigate exposure to a vulnerable dependency.

Verify a container artifact's provenance and signature before deployment.

Detect suspicious AWS activity using audit and threat-detection evidence.

Express a deployment guardrail as policy as code.

Identify platform capabilities from recurring developer friction and operational risk.

Define a paved-road service template with safe defaults and escape hatches.

Design a self-service interface that hides complexity without blocking advanced users.

Define tenancy boundaries for teams sharing a Kubernetes platform.

Specify a platform API contract with ownership, lifecycle, and support expectations.

Select platform metrics that measure developer outcomes rather than tool adoption.

Evaluate build-versus-buy trade-offs for a platform capability.

Translate a target DevOps, SRE, or platform job description into an evidence-based gap matrix.

Design an AWS and Kubernetes reference system with explicit availability and security requirements.

Create an architecture diagram that communicates traffic, trust, and failure boundaries.

Structure an infrastructure repository so reviewers can navigate Terraform, Kubernetes, and delivery code.

Create an operational-readiness checklist covering deployment, observability, security, and recovery.

Present a five-minute technical walkthrough that explains key design trade-offs.

Convert a real production incident into a concise STAR interview narrative.

Solve a timed end-to-end troubleshooting case while communicating evidence, hypotheses, and decisions.