Shipping a feature takes an afternoon. Operating it takes years. That asymmetry is the most under-taught part of full-stack development: the deploy button is the cheapest thing in this entire series, and everything around it — the pipeline that rehearses the deploy, the telemetry that watches it, the rollback that saves you from it — is where the actual engineering lives.
Four disciplines make up day-2 operations in 2026: where the code runs, how it gets there safely, how you see what it is doing, and how you undo it when reality disagrees with your tests.
Where to deploy in 2026
The platform question is workload-shaped, and the honest 2026 map has four territories:
- Vercel — the polished choice for Next.js: every PR gets a preview URL, Fluid Compute keeps serverless functions warm for 99%+ of requests, ~70 ms average TTFB across 100+ edge locations. The catches: the free Hobby plan is non-commercial only, Pro is $20/seat, and bandwidth overage ($40/100 GB) plus image optimization and function invocations are where volatile traffic turns into volatile bills.
- Netlify — the generalist: framework-agnostic, built-in forms/identity/split-testing that delete third-party services, and — the detail that decides it for freelancers and agencies — the free tier allows commercial use. Pro is $19/seat; overage is pricier at $55/100 GB.
- Cloudflare Pages/Workers — the economics play: 300+ PoPs, free unmetered bandwidth, Workers at ~1–3 ms cold starts. One published same-traffic comparison put a Cloudflare bill at $53 where Vercel’s was $1,900. The DX is less polished; at bandwidth-heavy scale, it is not close.
- Railway / a VPS / Docker — for what serverless cannot do: WebSocket hubs, 30-second webhook processors, background queues, persistent processes with a database next to them. Railway packages this well (Postgres and Redis as first-class citizens); a $5 VM does it for the price of a coffee.
The decision filter is one question: what shape is the workload? Static or content — anywhere, cheapest wins. Next.js application — Vercel unless bandwidth dominates, then Cloudflare. Persistent backend with state — Railway or a VM. And keep the escape hatch warm: build on Web Standards (Part 5) so the platform stays a line item, not a landlord.
CI/CD: the pipeline that earns trust
A pipeline is a rehearsal you run on every change, so production never sees a first performance. The 2026 minimum viable pipeline, in order:
- Install & build — reproducible install (lockfile, pinned package manager), then a full production build. If it does not build in CI, it was never going to build.
- Typecheck & lint —
tsc --noEmit(seconds on the 7.0 compiler from Part 2), lint, format check. This is the gate that catches what your laptop forgives. - Test — unit tests for logic, a handful of integration tests for the request paths that make money. Coverage worship is out; confidence per minute of CI time is in.
- Preview deploy — one URL per PR, reviewed by humans (and agents) before merge. This is the step that changed team culture everywhere it landed: “does it work?” becomes a link, not a meeting.
- Production deploy on merge — and database migrations ride the same pipeline, using the expand-contract phases and the unpooled connection string from Part 6. Never by hand, never “I’ll run it after.”
Deploys should be frequent and small. The bigger the diff, the longer the incident.
Observability: see it before your users do
Monitoring tells you p99 latency spiked. Observability tells you why — which user, which request, which span. In 2026 the substrate is settled: OpenTelemetry — vendor-neutral, CNCF-governed, supported by every serious backend. You instrument once with the OTel SDK, route signals through the OTel Collector (which also scrubs PII), and export to Grafana, Datadog, Honeycomb, or your own stack without changing application code.
The part that makes it work is not the three pillars — logs, metrics, traces — but their correlation: every structured log line (pino in Node, JSON always) and every outbound API call carries the active trace_id and span_id. The debugging loop this unlocks: alert fires on a metric → open the slow traces → drill into the exact log lines of the exact request → see that one database span that ate 180 ms. The browser is in the loop too: RUM captures Web Vitals (INP especially), Sentry source-maps your minified stack traces, and trace IDs propagate from the user’s click all the way to the database.
Instrument in this order, and stop when it answers your questions:
- Errors — uncaught exceptions, server and browser, with release tags.
- Latency — per route, with percentiles (averages lie).
- The golden path — the two or three traces that make money: signup, checkout, the core action.
- Alerting on SLOs, not vibes — an error budget that pages you when it burns, not a dashboard nobody opens.
The rollback discipline
The most underrated feature on any platform: the instant rollback. But the deeper discipline is separating deploy from release:
A deploy puts code in production — dark, behind a flag, serving nobody. A release exposes it to users — first to a 10% canary while you watch the error budget, then 50%, then everyone. When something burns, flag off is a config change measured in seconds; rolling back a deploy is a pipeline run measured in minutes. Put every risky change behind a flag; keep flags short-lived and delete them after the ramp, because a flag collection is a debt collection.
And practice the failure: roll back on purpose once in a while. A rollback path you have never used is a rollback path that does not work.
Cost awareness: where the bills hide
A five-minute audit that saves real money:
- Bandwidth overage — the #1 surprise: $40–55 per 100 GB past the plan. Heavy images and video multiply it; fix with AVIF,
content-visibility, and honest asset budgets (Part 2). - Function invocations & duration — chatty client code and long-running functions are metered directly.
- Per-user pricing — seats (Vercel/Netlify) and MAU (Clerk, from Part 5) scale with success. Know the number at 10x, not at 1x.
- Free-tier traps — “free” splits into commercial-allowed (Netlify, Cloudflare) and hobby-only (Vercel). Deploying a client project to the wrong one is a ToS violation, not a life hack.
Practice, then Part 8
- Wire one repo end to end: PR → CI gates → preview URL → merge → production. Then break a test on purpose and watch the pipeline refuse. That refusal is the product.
- Add OpenTelemetry to one service: auto-instrumentation, one structured log line with trace context, one Grafana or vendor dashboard showing a route’s p95. Follow one slow request from browser click to database span.
- Put the next change behind a feature flag and ramp it 10% → 100%. Roll it back once at 10%, calmly, because you can.
Part 8 is the long game: performance as a budget, security as a habit, dependency and documentation maintenance across years, and how to run all of it with AI agents doing more of the typing — without losing the plot yourself.