Originally published on LinkedIn.

Most small teams I talk to think zero-downtime deploys need Kubernetes. They don't. For a lot of products, Docker containers on AWS ECS behind a load balancer, plus a disciplined pipeline, gets you there with far less to operate.

I spent about 15 years building large systems, including fraud-decisioning platforms where a bad deploy was not an option, and I've been hands-on with AWS since 2014. Here is the setup I keep coming back to, and the reasons behind each piece.

The goal: users never notice a release

Zero-downtime is simple to state. While a new version goes live, every request still gets a correct answer. No maintenance page, no dropped sessions, no "try again in five minutes."

Three things make that possible: something that only sends traffic to healthy copies of your app, a way to start the new version next to the old one, and a fast, boring way back if the new version is wrong.

Piece 1: The same Docker image, everywhere

Build one image per commit and promote that exact image from test to production. Don't rebuild for each environment. If the image that passed your tests is not the image that runs in production, your tests didn't test production.

Configuration that differs between environments comes in from outside (environment variables or a secrets store), never baked into the image.

Piece 2: Health checks that mean something

ECS and the load balancer decide which containers get traffic based on health checks. A check that only returns "200 OK" because the web server is up is close to useless. The app can be up and still unable to reach its database.

A good health endpoint answers one question honestly: can this copy serve a real request right now? Keep it fast, check the dependencies that matter, and don't let it do expensive work. If the new version can't pass it, it never receives traffic, and that is exactly what you want.

Piece 3: Rolling deploys with a safety margin

ECS rolling updates start new tasks before stopping old ones. The two settings that matter are how many tasks must stay healthy during the deploy and how many extra tasks you allow on top. Set them so you never drop below the capacity you need, even for a minute.

Then give new tasks time to warm up before the load balancer judges them, and let old tasks finish the requests they're already handling before they stop (connection draining). Skipping those two details is the most common reason "rolling" deploys still drop requests.

Piece 4: Database changes that work with both versions

During a rolling deploy, old and new code run at the same time against the same database. So every schema change has to work with both. Add a column first, deploy code that uses it, and only remove old columns in a later release. It feels slower. It is much faster than a midnight rollback that can't undo a dropped column.

Piece 5: Rollback is a button, not a project

Because every release is just an image tag, rolling back means pointing the service at the previous tag. ECS's deployment circuit breaker can do this automatically when new tasks keep failing their health checks. Practise it before you need it. A rollback path you have never used is a hope, not a plan.

Piece 6: The pipeline decides what ships

I've built this with Jenkins and with GitHub Actions; the tool matters less than the rule. Build, test, scan, deploy to a test environment, check it, then promote. Nobody deploys from a laptop. The same rule runs my own product today: FinMoment, an AI bookkeeping pipeline on Next.js, Supabase and Vercel, ships only when the CI and deploy gates pass, even though a team of Claude Code agents operates it.

Piece 7: Watch the release, not just the server

After a deploy, look at error rates and latency, not only CPU. I've used Splunk, Kibana and New Relic for this; what matters is having a dashboard or alert that tells you within minutes whether the new version is worse than the old one.

When you do need more

This setup won't fit every case. If you run dozens of services with complex scheduling needs, a bigger platform may earn its keep. But many teams adopt that complexity long before they need it, and then spend their time operating the platform instead of the product.

That's the kind of work I do: AWS and platform architecture, CI/CD pipelines with real gates, and AI automation for finance and document workflows, including Claude agents with human approval gates. If you want a second pair of eyes on your deploy setup, or want to see how I run FinMoment, I'm happy to walk you through it on a call.

You can find me on Upwork: https://www.upwork.com/freelancers/~0146d40003db2cffd3