DevOps

AWS's managed pub/sub messaging — publish once, fan out to many subscribers (queues, functions, HTTP, email). The one-to-many complement to SQS's one-to-one queue.

AWS's fully-managed message queue — a simple, durable buffer that decouples services and absorbs load spikes. Serverless, cheap, and the default first reach for async work in AWS.

An agentless configuration-management and automation tool — pushes changes over SSH using simple YAML playbooks. Popular for its low barrier to entry and broad reach.

A distributed event-streaming platform — a durable, replayable log of events that many consumers read independently. The backbone of event-driven data pipelines, not a task queue.

A managed entry point that routes, secures, and monitors API traffic.

Evolving an API without breaking existing clients — the discipline that decides whether you can change your API or are held hostage by it.

A GitOps continuous-delivery tool for Kubernetes: your Git repo declares the desired cluster state, and ArgoCD makes reality match it.

A declarative deployment loop syncing Git repository states to Kubernetes clusters.

Atlassian's CI/CD built into Bitbucket — YAML pipelines next to your code, tightly integrated with Jira, priced by build minutes.

Running two identical production environments and flipping traffic from old to new all at once — instant cutover, instant rollback, double the infrastructure.

A deployment strategy utilizing two identical environments to eliminate release downtime.

A release strategy that rolls out updates to a small fraction of users to verify stability.

Rolling out a new version to a small slice of real users first, watching the metrics, then widening — the strategy built to limit the blast radius of a bad deploy.

A veteran configuration-management tool that treats servers as code — but from an era of long-lived servers now largely displaced by immutable infrastructure and containers.

Automating the path from code commit to production — continuous integration tests every change, continuous delivery ships it safely.

A managed CI/CD platform built around reusable config (orbs), first-class caching, and per-credit pricing — where pipeline speed is the product.

A resilience pattern that stops calling a failing service to let it recover — 'tripping' after repeated failures instead of pounding a dead dependency and cascading the outage.

AWS's native infrastructure-as-code service — declarative stacks with managed state and automatic rollback, at the cost of YAML verbosity and AWS lock-in.

The gradual divergence of a system's real state from its intended, defined state as manual changes accumulate — the silent cause of 'works here but not there' failures and failed deploys.

Splitting a system's write model from its read model so each is optimized independently — powerful for complex, high-scale domains, overkill for ordinary CRUD.

Deploying a feature to production but keeping it hidden — running its code silently to test performance and correctness with real traffic before anyone sees it.

A commercial, all-in-one observability SaaS covering metrics, traces, logs, and more in one integrated platform. Fast to adopt, famously easy to overspend on.

The tool that popularized containers — packaging an app with all its dependencies into a portable image that runs the same everywhere. The unit modern deployment is built on.

An approach to modeling complex software around the business domain and its real language — bounded contexts, ubiquitous language. Its value is in the hard domains.

Runtime switches that decouple deploying code from releasing it — enabling canary rollouts, instant kill switches, and A/B tests without redeploying.

A GitOps operator for Kubernetes — it runs inside the cluster and continuously reconciles it to match config declared in Git. Automation-first, a peer to Argo CD.

GitHub's built-in CI/CD — workflows in YAML in your repo, triggered by git events, with a huge marketplace of reusable actions. The default for anything already on GitHub.

GitLab's built-in CI/CD system — pipelines defined in a YAML file in your repo, tightly integrated with the whole GitLab platform. A single-vendor alternative to stitching tools together.

An operating model where Git is the single source of truth for infrastructure and deployments, and automation continuously makes the live system match what's in Git. Declarative, auditable, self-healing.

The default open-source dashboarding and visualization layer — it turns metrics, logs, and traces from many sources into graphs and alerts. It stores nothing itself.

A query language for APIs that lets the client ask for exactly the data it needs in one request — solving over- and under-fetching, at the cost of new complexity.

A high-performance RPC framework using HTTP/2 and Protocol Buffers — fast, strongly-typed service-to-service calls. Great between backends, awkward from browsers.

A unique client-supplied identifier that lets a server safely de-duplicate retried requests — so a payment or order sent twice (after a timeout) only happens once.

An approach where servers are never modified after deployment — to change anything you build a new image and replace them. Eliminates drift and 'works on my machine,' at the cost of a build pipeline.

A rendering strategy that serves pre-built static pages while regenerating them in the background — static-site speed with content that stays fresh.

The methodology managing and provisioning cloud networks and compute units using configuration files.

The veteran, plugin-heavy CI/CD automation server — enormously flexible and self-hosted, but showing its age against lighter, git-native tools like GitHub Actions and GitLab CI.

A popular open-source API gateway — the single entry point that sits in front of your services and handles auth, rate limiting, routing, and observability so each service doesn't have to.

An open-source platform for orchestrating containerized workloads at scale.

Netlify's serverless functions — backend code deployed alongside your frontend with no server management, wrapping AWS Lambda in a simpler developer experience for Jamstack apps.

A commercial all-in-one observability platform — metrics, traces, logs, and APM in one product. You pay to skip assembling the open-source stack yourself.

The vendor-neutral standard for traces, metrics, and logs — instrument once, send anywhere, and finally escape observability-vendor lock-in.

The de-facto open-source metrics system — pull-based scraping, a time-series database, and PromQL. It tells you your systems' vital signs; it is not for logs or traces.

The declarative configuration-management veteran: agents continuously converge servers toward a cataloged desired state — still ruling large regulated fleets.

A mature message broker for routing tasks and events between services — flexible routing and per-message reliability. A queue for work, not a log for streaming like Kafka.

Automatically re-attempting a failed operation to ride out transient errors — essential for resilient distributed systems, and dangerous without backoff, jitter, and idempotency.

Updating a service by replacing its instances a few at a time while the rest keep serving traffic — the default zero-downtime deployment, and Kubernetes's built-in strategy.

A dead-simple way to stream server-to-client updates over plain HTTP — one-directional, auto-reconnecting, and the natural fit for streaming LLM token output.

Generating a page's HTML on the server for each request rather than in the browser — better first-load performance and SEO, at the cost of server work. One point on a spectrum of rendering strategies.

Pre-rendering a whole site into static HTML at build time so it can be served as plain files from a CDN — the fastest, cheapest, most secure way to serve content that doesn't change per request.

The dominant infrastructure-as-code tool — declare cloud resources in config, and Terraform plans and applies the changes to reach that state. Cloud-agnostic, with state as its double-edged core.

A plugin translating declarative HCL resource configs into specific cloud API commands.

An early cloud CI pioneer that popularized YAML pipelines for open source — now a cautionary tale about platform decline and a security-incident case study.

Vercel's global edge platform — a CDN plus edge compute that serves and runs your app close to users worldwide. The deploy-target side of the modern frontend/Jamstack stack.

An HTTP callback that sends real-time event notifications from one system to another.

A reverse API: instead of you polling a service for changes, it calls your URL when something happens. Efficient and real-time — and a security surface you must lock down.