Table of Contents

Click Here to Return To the Software Development Career Playbook

Every senior software developer who deploys to production needs to understand DevOps and platform engineering concepts. You do not need to be the person building the CI/CD pipeline or managing Kubernetes clusters, but you need to understand how your code gets from a commit on your laptop to a running service in production — and what can go wrong at each step. A senior developer who cannot debug a failing deployment pipeline is blocked by infrastructure every time something goes wrong.

What DevOps Actually Means

DevOps is a culture and practice that breaks down the wall between software development and IT operations. Rather than developers throwing code over a wall to operations teams who then deploy it, DevOps means developers own their code all the way through production.

In practice this means:

  • Developers write and own CI/CD pipelines for their services.
  • Developers are on-call for the services they build (you build it, you run it).
  • Infrastructure is defined as code alongside application code, not managed manually.
  • Feedback loops between production behavior and development decisions are short.

CI/CD Pipelines

A CI/CD pipeline automates the path from code commit to production deployment.

Continuous Integration (CI) runs automatically on every pull request:

  • Code checkout and dependency installation
  • Static analysis and linting
  • Unit and integration tests
  • Build artifact creation

Continuous Deployment (CD) automates delivery to environments:

  • Deploy to staging on merge to main
  • Run smoke tests and integration tests against staging
  • Deploy to production (automated or with manual gate)
  • Post-deployment health check and rollback trigger
CI/CD ToolNotes
GitHub ActionsNative to GitHub; YAML-based; easiest to adopt for GitHub users
GitLab CIBuilt into GitLab; powerful; good for self-hosted scenarios
JenkinsMature and highly extensible; complex to maintain
CircleCIManaged platform; good parallelization
BuildkiteHybrid: managed orchestration + self-hosted agents

Containers and Kubernetes

Docker packages applications and their dependencies into portable, reproducible containers. Every production application should run in a container for consistency between development, staging, and production.

Kubernetes (K8s) orchestrates containers at scale: scheduling, scaling, load balancing, health checking, and rolling deployments. As a developer you need to understand:

  • Writing a basic Deployment, Service, and Ingress manifest.
  • How pod resource requests and limits work.
  • How to read pod logs and describe events for debugging.
  • How rolling deployments and rollbacks work.
  • How ConfigMaps and Secrets manage configuration.

You do not need to manage the Kubernetes control plane. Your platform team does that. You need to write correct manifests and debug deployment failures.

Infrastructure as Code (IaC)

Infrastructure as Code means defining cloud infrastructure (servers, databases, networks, IAM policies) in version-controlled code rather than clicking through consoles.

Terraform is the most widely used IaC tool. It uses a declarative language (HCL) to describe desired infrastructure state and plans and applies changes idempotently.

Key Terraform concepts:

  • Providers: plugins that connect Terraform to cloud APIs (AWS, Azure, GCP).
  • Resources: individual infrastructure objects (EC2 instance, S3 bucket, RDS database).
  • State: Terraform tracks what it has deployed in a state file, stored remotely (S3, Terraform Cloud).
  • Modules: reusable infrastructure components.
  • Plan and apply: terraform plan shows what will change; terraform apply executes the changes.

As a developer, you will write Terraform for your service’s infrastructure: the database, queue, S3 bucket, IAM roles, and environment-specific configuration your application needs.

Observability

Observability is the ability to understand what your system is doing at any moment, based on the outputs it produces. The three pillars:

PillarWhat It ProvidesTools
MetricsQuantitative measurements over time (request rate, latency, error rate, CPU)Prometheus, CloudWatch, Datadog
LogsTextual records of events from each serviceElasticsearch/Kibana, Datadog, CloudWatch Logs, Loki
TracesThe path of a request across multiple servicesJaeger, Zipkin, Datadog APM, AWS X-Ray

Every production service needs three baseline metrics from day one:

  1. Request rate: how many requests is the service handling per second?
  2. Error rate: what percentage of requests are failing? Alert if above 1%.
  3. Latency: what is the p50, p95, and p99 response time? Alert on p99 degradation.

This is the RED method (Rate, Errors, Duration). Complementary is the USE method for infrastructure resources (Utilization, Saturation, Errors).

The Platform Engineer Role

A platform engineer builds and maintains the internal platforms that other developers use to ship software: CI/CD systems, container orchestration, secrets management, observability tooling, deployment frameworks, and developer portals.

Platform engineering treats internal teams as customers. The platform team’s job is to make building and operating software faster and safer for all engineering teams.

This is one of the highest-demand and highest-compensated specializations in software engineering. See Software Development Specializations for more.

Next Steps