Forem: Parag Agrawal

AWS App Runner Is Dead — Here's What You Should Use Instead (2026)

Parag Agrawal — Mon, 13 Apr 2026 12:24:24 +0000

If you're running apps on AWS App Runner — or were thinking about using it — you need to read this.

AWS has announced that App Runner will no longer accept new customers starting April 30, 2026.

This isn't speculation. It's in the official AWS documentation. Existing customers can still use the service and create new resources, but AWS has confirmed they won't be introducing new features. The service is entering maintenance mode — which, in AWS language, is one step before eventual deprecation.

If you're currently on App Runner, you need a migration plan. If you were evaluating it for a new project, you need a new direction.

This post covers everything: what happened, why AWS made this call, and exactly what you should use instead — with specific migration steps.

What Was AWS App Runner?

For those unfamiliar, App Runner was AWS's answer to Heroku/Render/Railway. Launched in 2021, it was designed to be the simplest way to deploy containerized web applications on AWS.

The pitch was compelling:

✅ Point to a container image or source code repository
✅ App Runner handles build, deploy, HTTPS, scaling, and load balancing
✅ No need to configure VPCs, ECS clusters, task definitions, or ALBs
✅ Runs on Fargate under the hood
✅ Auto-scales to zero (you only pay when your app gets traffic)

It was genuinely good for simple use cases. If you wanted to deploy a single API or web app without learning ECS, App Runner got you there in under 5 minutes.

So why is AWS killing it?

Why AWS Is Sunsetting App Runner

AWS hasn't published an official "here's why" blog post, but the reasoning becomes clear when you look at the timeline:

The Real Reason: ECS Express Mode

In late 2025 / early 2026, AWS launched ECS Express Mode — a new feature within Amazon ECS that provides almost everything App Runner offered, but within the ECS ecosystem.

ECS Express Mode automates:

Cluster creation on Fargate
Application Load Balancer provisioning
HTTPS/TLS configuration
Security groups and networking
Auto-scaling policies
CloudWatch monitoring and logging

In other words, ECS Express Mode makes ECS nearly as simple as App Runner — but with full access to the ECS feature set. It's App Runner's simplicity, with ECS's power.

Having two services that do essentially the same thing creates confusion and maintenance overhead for AWS. App Runner was always a thin wrapper around ECS Fargate anyway. Rather than maintaining two products, AWS chose to consolidate into one — and ECS Express Mode is the survivor.

What This Means for the Broader Market

This is actually a positive signal for the industry. It means:

AWS is investing heavily in making ECS simpler — which validates the core thesis that container deployment needs to be easier
The "App Runner" approach of simplicity-first is the right direction — AWS just decided to build it into ECS rather than maintain a separate service
ECS Fargate is the long-term bet — if you're building on ECS Fargate today, you're on the right side of AWS's strategy

This is also exactly the thesis behind TurboDeploy. More on that later.

The Timeline: What's Happening When

Here's what you need to know:

Date	What Happens
Now (April 2026)	App Runner is fully functional for existing customers
April 30, 2026	App Runner stops accepting new customers. If you haven't created an App Runner service before this date, you won't be able to.
Post April 30	Existing customers can continue using App Runner, create new services, and manage workloads. AWS will maintain security and availability.
Future (date TBD)	No new features will be added. Eventually, AWS will likely announce a full sunset date.

The writing is on the wall. Even if you're an existing customer, starting a migration now — while there's no time pressure — is the smart move.

What Should You Use Instead?

You have three main options, depending on your needs. Let's break down each one.

Option 1: Amazon ECS Express Mode (AWS's Official Recommendation)

This is the most direct replacement. AWS explicitly recommends ECS Express Mode for App Runner users.

What you get:

Nearly identical simplicity to App Runner
Provide a container image → get a running service with ALB, HTTPS, auto-scaling
Full access to underlying ECS resources (you can customize later)
No additional cost beyond standard Fargate + ALB pricing
Shares ALBs across up to 25 services to reduce costs

How to get started with ECS Express Mode:

Go to the Amazon ECS console
In the left nav, select Express mode
Click Create
Enter your container image URI (from ECR or any public registry)
(Optional) Configure CPU, memory, environment variables
Click Create — done

That's it. ECS Express Mode provisions the cluster, service, ALB, security groups, auto-scaling, and CloudWatch monitoring automatically.

Key difference from App Runner: Express Mode requires a pre-built container image. App Runner could build from source code. So you'll need a CI/CD step (like GitHub Actions) to build and push your Docker image to ECR before Express Mode can deploy it.

→ We'll cover this end-to-end in our upcoming post: How to Set Up a CI/CD Pipeline with GitHub Actions and AWS ECS

Who this is best for: Developers who are comfortable with Docker and want to stay 100% within the AWS ecosystem with minimal setup.

Option 2: Amazon ECS Fargate (Standard Mode)

If you need more control than Express Mode provides — or you want to understand what's happening under the hood — standard ECS Fargate gives you full power.

What you get:

Complete control over networking, IAM roles, task definitions, and deployment strategies
Blue-green and rolling deployments
Custom health check configurations
Integration with any CI/CD system
Multi-container task definitions (sidecars, logging agents, etc.)

The trade-off: You're back to configuring VPCs, ALBs, target groups, security groups, and IAM roles manually. This is significantly more complex than Express Mode.

→ We'll publish a full step-by-step guide: How to Deploy a Docker Container on AWS ECS Fargate

Who this is best for: Teams with DevOps experience who need fine-grained control over their infrastructure.

Option 3: A Deployment Platform That Handles the Complexity for You

Both ECS Express Mode and standard Fargate still require you to:

Build and push Docker images yourself (or set up CI/CD)
Manage your own ECR repositories
Configure environment variables through AWS interfaces
Deal with AWS IAM role setup
Monitor deployments through the AWS console

If you want the App Runner experience — "point to my code and deploy" — but don't want to lose the benefits of running in your own AWS account, this is where tools like TurboDeploy come in.

TurboDeploy sits in the gap between "PaaS simplicity" and "AWS control":

You connect your AWS account via a secure IAM role
You point to your GitHub repo
TurboDeploy handles the Docker build, ECR push, ECS service creation, ALB setup, and monitoring
Everything runs in your AWS account — you're not moving to someone else's cloud

This is essentially what App Runner was supposed to be, but with the added benefit that TurboDeploy doesn't need to be an AWS service to keep working. If TurboDeploy disappears tomorrow, your ECS services keep running in your account, unchanged.

Who this is best for: Developers and startup founders who want the App Runner "just deploy it" experience without vendor dependency.

→ Learn more: Why We're Building TurboDeploy — The Problem with Cloud Deployment in 2026

Comparison Table: Your Migration Options at a Glance

Feature	App Runner (dying)	ECS Express Mode	ECS Fargate (Standard)	TurboDeploy
Setup complexity	Very Low	Low	High	Very Low
Build from source code	✅ Yes	❌ Need CI/CD	❌ Need CI/CD	✅ Yes
HTTPS/TLS	✅ Automatic	✅ Automatic	⚙️ Manual (ACM + ALB)	✅ Automatic
Auto-scaling	✅ Built-in	✅ Built-in	⚙️ Manual config	✅ Built-in
Custom domains	✅	✅ (via Route53)	⚙️ Manual	🔜 Roadmap
Full AWS resource access	❌ Limited	✅ Full	✅ Full	✅ Full
Scale-to-zero	✅	❌	❌	❌
Long-term viability	❌ Sunsetting	✅ AWS investment	✅ Stable	✅ Active development
Runs in your account	✅	✅	✅	✅
Additional cost	App Runner pricing	Fargate + ALB only	Fargate + ALB only	Fargate + ALB + TurboDeploy

Step-by-Step: Migrating from App Runner to ECS Express Mode

If you have an existing App Runner service and want to migrate to ECS Express Mode, here's the recommended approach:

Step 1: Inventory Your App Runner Services

List all your App Runner services and document:

Container image source (ECR or source code)
Environment variables
CPU and memory configuration
Custom domain mappings
Auto-scaling configuration

aws apprunner list-services --region us-east-1

Step 2: Ensure Your Container Image is in ECR

If your App Runner service builds from source code, you'll need to set up a container build pipeline first. The simplest approach:

Add a Dockerfile to your repository (if you don't have one)
Create an ECR repository in your AWS account
Set up GitHub Actions to build and push on every commit

# Create an ECR repository
aws ecr create-repository --repository-name my-app --region us-east-1

→ Don't have a Dockerfile? Check out: How to Write a Production-Ready Dockerfile

Step 3: Create an ECS Express Mode Service

Open the ECS Console → Express mode → Create
Enter your ECR image URI
Configure CPU, memory, and environment variables to match your App Runner settings
Click Create

Your new service will be live in minutes with an AWS-managed URL.

Step 4: Set Up DNS Migration (Blue-Green)

AWS recommends a blue-green approach for zero-downtime migration:

Create a Route 53 weighted routing record set
Point 10% of traffic to the new ECS Express service
Monitor for errors, latency, and functionality
Gradually increase to 25% → 50% → 100%
Decommission the App Runner service once all traffic is migrated

# Example Route 53 weighted record
my-app.example.com → App Runner URL (weight: 90)
my-app.example.com → ECS ALB URL    (weight: 10)

Step 5: Tear Down App Runner

Once all traffic is on ECS and you're confident everything works:

aws apprunner delete-service --service-arn arn:aws:apprunner:us-east-1:123456789:service/my-app/xxx

What About Non-AWS Alternatives?

If the App Runner sunset makes you question your AWS commitment entirely, here are your options outside the AWS ecosystem:

Platform	Best For	Trade-off
Railway	Quick deployments, modern DX	Usage-based pricing, you don't own infra
Render	Predictable pricing, easy setup	Less flexibility than AWS
Fly.io	Global edge deployment	More complex networking model
Coolify (self-hosted)	Full control on your own VPS	You manage the PaaS layer + the server

These are all solid options, but they come with the platform tax trade-off: you're paying for convenience with someone else's infrastructure.

The Bigger Picture: What This Tells Us About Cloud Computing in 2026

The App Runner sunset isn't just a product lifecycle event. It's a signal about where cloud deployment is heading:

1. Simplicity is becoming a feature of existing services, not separate products

Instead of creating new "simple" services, cloud providers are making their core services simpler. ECS Express Mode is ECS-made-easy, not a separate product. Expect the same pattern from other AWS services.

2. Containers on Fargate is the "default" deployment model

AWS is clearly betting on ECS Fargate as the standard way to deploy containerized applications. Not Lambda (too limited for many workloads), not EKS (too complex for most teams), but ECS on Fargate.

→ We explore this further in: ECS vs EKS vs Lambda — How to Choose the Right AWS Compute Service

3. The developer experience gap is still the real problem

Even with ECS Express Mode, deploying to AWS is still harder than Vercel or Railway. The gap is smaller than it was in 2021, but it's still there. And that gap is exactly the space where tools like TurboDeploy add value.

TL;DR — What To Do Right Now

If you're currently on App Runner:

✅ Don't panic — your services keep running
✅ Start planning migration to ECS Express Mode
✅ Set up a Docker build pipeline if you don't have one
✅ Test ECS Express Mode with a non-critical service first
✅ Migrate production services using blue-green (Route 53 weighted routing)

If you were considering App Runner for a new project:

✅ Use ECS Express Mode for the closest experience
✅ Or try TurboDeploy for an even simpler experience that deploys to your AWS account
❌ Don't start with App Runner — the service is entering end-of-life

If you're unsure which option is right:

Read our decision guide → How to Choose Between a PaaS and AWS for Your Startup

👉 Join the TurboDeploy waitlist → — Deploy to AWS without the AWS headache.

Why We're Building TurboDeploy - The Problem with Cloud Deployment in 2026

Parag Agrawal — Thu, 09 Apr 2026 15:42:02 +0000

Every developer has been there.

You've built something — an app, a side project, maybe the MVP of your startup. It works on your machine. It runs beautifully in development. And now you need to put it on the internet.

That's when the fun stops.

If you go with AWS, you're suddenly drowning in a sea of IAM roles, VPCs, security groups, task definitions, load balancers, target groups and CloudFormation templates. You didn't sign up for a PhD in infrastructure, but here you are, three hours in, Googling "what is an ECS cluster" at 2 AM.

If you go with a managed platform like Vercel, Railway or Render, the experience is beautiful. Connect your repo, click deploy and you're live. But this simplicity has a price. Literally.

A few months later, your startup starts growing. And that $0/month hobby plan quietly becomes a $200/month, then a $500/month, then a "wait, why is my cloud bill higher than my rent?" situation.

We've lived through both of these nightmares. And that's exactly why we're building TurboDeploy.

The Two Extremes of Cloud Deployment

In 2026, deploying a web application still forces you into one of two painful choices:

Option A: The AWS Way (Powerful but painful)

AWS is the gold standard of cloud infrastructure. It's what Netflix, Airbnb and thousands of serious companies run on. It gives you:

Full control over every aspect of your infrastructure
Transparent, pay-for-what-you-use pricing
No vendor lock-in (it's your account, your resources)
Enterprise-grade security, compliance, and scalability

But the learning curve is brutal.

Just to deploy a simple Node.js app, you need to:

Create a VPC with subnets
Set up security groups
Create an ECR repository
Build and push a Docker image
Write an ECS task definition
Create an ECS service
Configure an Application Load Balancer
Set up target groups and listeners
Configure IAM roles and policies
Set up CloudWatch logging

That's 10 steps before your "Hello World" is live. And if you get one IAM permission wrong, you get a cryptic error message that sends you down a 45-minute Stack Overflow rabbit hole.

Most developers give up somewhere around step 4.

Option B: The PaaS Way (Easy but expensive)

Platforms like Vercel, Railway, Render, Heroku, and Fly.io exist because Option A is so painful. And they're genuinely excellent products. The developer experience is world-class.

But here's what they don't tell you upfront:

They host your application on their infrastructure.

This means:

You're paying a "platform tax": They buy AWS/GCP resources at bulk prices, mark them up 2–5x and resell them to you as "simplified deployment."
Your costs scale with their pricing, not AWS pricing: When your app grows, you don't benefit from AWS's economies of scale — you benefit from their price tiers.
You're locked in: Your infrastructure definitions, environment configurations and deployment pipelines are all proprietary. Moving to AWS later means starting from scratch.
You don't own your infrastructure: Your containers run on their accounts. Your logs are in their dashboard. Your data flows through their network.

Let me put real numbers on this. Here's what a simple web app (2 vCPU, 4 GB RAM, running 24/7) costs per month:

Platform	Monthly Cost (approx.)	What You Get
Vercel (Pro)	$20/seat + usage	Great for frontend, but serverless function costs and bandwidth add up fast
Railway	$50–150+	Usage-based, but grows linearly with traffic
Render	$20–85 per service	Predictable, but no flexibility in underlying infra
AWS ECS Fargate (direct)	$30–50	Same compute, full control, your account

At small scale, the difference is $20–50/month. Not a big deal.

At growth scale (let's say 5 services, production + staging environments, a database and a background worker), the difference becomes $500–1500/month vs. $150–300/month on AWS direct.

That's $3,600–$14,400/year in "platform tax." For an early-stage startup watching every dollar, that's the difference between hiring a part-time contractor and not.

There Should Be a Third Option

We kept asking ourselves the same question:

What if you could have the simplicity of Vercel — but everything runs in your own AWS account?

No markup. No lock-in. No "we host your app on our cloud and charge you 3x."

Just connect your AWS account, point to your repo, click deploy — and everything gets provisioned in your cloud, with your billing, under your control.

That's TurboDeploy.

What TurboDeploy Actually Does

TurboDeploy is a deployment platform for AWS. But unlike traditional PaaS platforms, we never become your hosting provider. AWS is your hosting provider. We're just the orchestration layer that removes the pain.

Here's how it works:

You connect your AWS account — using a secure, read-scoped IAM role (via AWS AssumeRole). No long-term access keys, ever. We create a narrowly scoped role that can only do what's needed for deployment.
You point to your GitHub repo — or upload your project. Tell us the build command, start command, and port.
You click deploy — and everything happens automatically:
- We pull your code
- Build a Docker image
- Push it to Amazon ECR in your account
- Create an ECS task definition
- Provision an ECS Fargate service behind an Application Load Balancer
- Configure logging via CloudWatch
- Return a public URL
You see everything in your dashboard — deployment status, logs, errors, and your live URL.

The key difference: After deployment, if you go to your AWS console, you'll see the ECS service, the load balancer, the CloudWatch logs — all in your account. If you ever stop using TurboDeploy, your app keeps running. Nothing changes. Because it was never on our infrastructure to begin with.

The Architecture (Simplified)

For the technical readers, here's what's happening under the hood:

┌─────────────┐     ┌──────────────────┐     ┌─────────────────────────────────┐
│  Your Code  │────▶│   TurboDeploy    │────▶│    YOUR AWS Account             │
│  (GitHub)   │     │  (Orchestration)  │     │                                 │
└─────────────┘     └──────────────────┘     │  ┌─────┐  ┌──────┐  ┌──────┐  │
                           │                  │  │ ECR │─▶│ ECS  │─▶│ ALB  │──│──▶ Users
                     AssumeRole               │  └─────┘  │Fargate│  └──────┘  │
                    (temp creds)              │           └──────┘             │
                                              │  ┌──────────────┐             │
                                              │  │  CloudWatch   │             │
                                              │  │  (Logs)       │             │
                                              │  └──────────────┘             │
                                              └─────────────────────────────────┘

Security model: TurboDeploy uses AWS AssumeRole to get temporary, scoped credentials. We never store permanent AWS access keys. The IAM role we create has the minimum permissions needed — it can push images, manage ECS services, and configure load balancers. It can't access your S3 buckets, databases, or anything else.

We also never see or touch your application data. We only orchestrate infrastructure creation. Your code runs entirely in your account.

Why We're Building This Now

Three things converged in 2026 that make this the right moment:

1. AWS just made ECS dramatically simpler

AWS launched ECS Express Mode — a streamlined way to deploy containers on Fargate with automated ALB, auto-scaling, and security group provisioning. This is a signal that even AWS recognizes the deployment experience needs to be simpler. TurboDeploy builds on top of this foundation to make it even easier.

→ Read our deep dive: AWS ECS Express Mode: The Complete Getting Started Guide

2. The "platform tax" backlash is real

Developers are increasingly vocal about PaaS pricing. Reddit threads in r/devops and r/webdev are full of developers sharing "bill shock" stories — especially from Vercel. The shift back to owning infrastructure is happening, but the tooling gap makes it hard for most teams to make the switch.

→ We break down the numbers: The Hidden Costs of Vercel, Railway, and Render — A Real-World Pricing Breakdown

3. "Bring your own cloud" is becoming a real pattern

We're not the only ones who see this trend. But most tools in this space are either too complex (Terraform, Pulumi — great but require IaC expertise) or too opinionated (Coolify, Dokploy — deploy to VPS, not to your cloud account). TurboDeploy sits in the sweet spot: opinionated enough to be simple, flexible enough to use real AWS infrastructure.

What TurboDeploy Is NOT

Let's be honest about our scope. This matters more than marketing promises:

❌ Not a full AWS management console — We do one thing: deploy containerized web apps to ECS Fargate.
❌ Not a database provisioning tool — (Yet. It's on the roadmap, but not in v1.)
❌ Not for multi-service microservice architectures — (Also roadmap. v1 is single-container apps.)
❌ Not Kubernetes — We deliberately chose ECS Fargate over EKS because most startups don't need Kubernetes.
❌ Not a hosting provider — We never host your app. Period.

We're intentionally narrow. We'd rather do one thing perfectly than ten things poorly.

Who Is This For?

TurboDeploy is for:

Solo developers who want AWS-grade infrastructure without the AWS learning curve
Early-stage startup founders who want to own their infrastructure from day one without hiring a DevOps engineer
Small teams who are currently on Vercel/Railway/Render and starting to feel the cost pressure
Indie hackers who want cloud costs measured in dollars, not hundreds of dollars

Even if you're a 200-person engineering org with a dedicated platform team, then also we can probably help you.

Where We Are Today

We're being transparent about this: TurboDeploy is in active development.

Our MVP can deploy a single containerized app (Node.js, Python, etc.) to AWS ECS Fargate in your account, with a load balancer and a public URL. It works. We've tested it.

But we're not pretending it's production-ready for everyone. Features like custom domains, auto-rollback, preview environments, and multi-region support are on the roadmap, not in the product today.

We've launched a waitlist at turbodeploy.dev and we're looking for early adopters who want to try it, break it and help us figure out what to build next.

If this sounds like you, sign up. We'll personally onboard you.

What's Coming Next

Over the next few weeks, we'll be publishing deep dives on the topics that matter to developers building on AWS:

Follow along. We're building in public, and we're not pretending we have all the answers.

The Bottom Line

Cloud deployment in 2026 is stuck between two bad options:

AWS gives you power but drowns you in complexity.
PaaS gives you simplicity but charges you a premium for it.

TurboDeploy is the third option: the simplicity of a PaaS, running entirely in your own AWS account.

Your code. Your AWS. No lock-in.

👉 Join the waitlist at turbodeploy.dev →

Unlocking the Potential: Exploring the Future of Web Development with React

Parag Agrawal — Tue, 30 May 2023 14:41:01 +0000

Introduction

Web development has come a long way, and the future looks incredibly promising. One technology that has gained significant popularity and transformed the web development landscape is React. In this article, we will delve into the potential that React brings to the table, unlocking new possibilities and empowering developers to create exceptional web experiences. Whether you're a seasoned developer or just starting out, understanding the power of React is crucial to stay ahead in the ever-evolving world of web development.

What is React?

At its core, React is a JavaScript library for building user interfaces. Developed by Facebook, React provides a declarative and component-based approach, making it easier to build complex UIs by breaking them down into reusable components. With its virtual DOM and efficient rendering techniques, React has gained popularity for its ability to create highly interactive and performant applications.

Unlocking the Potential: Exploring the Key Features of React

React is packed with powerful features that enhance the development process and enable developers to create dynamic web applications. Let's take a closer look at some of these features:

1. Component-Based Architecture

One of the fundamental concepts of React is its component-based architecture. By breaking down the user interface into reusable components, developers can build complex applications more efficiently. Components are self-contained and can be composed together, offering a modular and scalable approach to web development.

2. Virtual DOM

React utilizes a virtual DOM, which is a lightweight representation of the actual DOM. This allows React to efficiently update and render only the necessary components when changes occur, minimizing the impact on performance. The virtual DOM acts as a middle layer between the actual DOM and the application's state, enabling faster rendering and improved user experience.

3. JSX: The Power of JavaScript and HTML Fusion

React introduces JSX, a syntax extension that combines JavaScript and HTML. This powerful fusion allows developers to write HTML-like code within JavaScript, making it easier to create dynamic and interactive user interfaces. JSX enhances code readability and simplifies the process of building complex UI structures.

4. Unidirectional Data Flow

React follows a unidirectional data flow, which means data flows in a single direction within the application. This clear data flow pattern makes it easier to track and manage data changes, resulting in more predictable and maintainable code. Unidirectional data flow enhances code stability and makes debugging and testing more efficient.

5. React Native: Cross-Platform Development

React extends its potential beyond the web with React Native, a framework that enables developers to build native mobile applications using React. By leveraging React's component-based approach, developers can create mobile apps that are indistinguishable from those built using native languages like Java or Swift. React Native allows for code reusability, reducing development time and effort across multiple platforms.

6. Performance Optimization

React's virtual DOM and efficient diffing algorithm contribute to superior performance. By minimizing unnecessary updates to the actual DOM, React ensures optimal rendering speed. Additionally, React's ability to handle large datasets and its support for server-side rendering (SSR) enhance the overall performance of web applications.

Conclusion

React has undoubtedly unlocked a world of possibilities in web development. Its component-based architecture, virtual DOM, JSX syntax, and other powerful features empower developers to create dynamic, performant, and scalable applications. Whether you're building a simple website, a complex web application, or even a mobile app using React Native, you can harness the potential of React to deliver exceptional user experiences.

As the web continues to evolve, React remains at the forefront of web development technologies, constantly evolving and improving. By investing time in learning React and keeping up with its advancements, developers can stay ahead of the curve and unlock the full potential of web development.

In conclusion, Unlocking the Potential: Exploring the Future of Web Development with React is not just a catchy title; it represents the exciting journey that developers can embark upon with React. So, dive in, explore the vast ecosystem of React, and embrace the future of web development.