AWS Just Shipped a Free Local Copy of Its Own Cloud — Here's What the AWS Emulator Actually Changes for Developers

AWS Emulator, generally available November 11, 2026, runs real AWS APIs on your own machine at no extra cost — no AWS account needed. I dug into how it works, what it gets right, and where it still falls short.

AWS Just Shipped a Free Local Copy of Its Own Cloud — Here's What the AWS Emulator Actually Changes for Developers
AWS Just Shipped a Free Local Copy of Its Own Cloud — Here's What the AWS Emulator Actually Changes for Developers — Technical Architecture & Overview

Table of Contents

Introduction


I have lost count of how many times I have wanted a simple thing: a way to test my code against AWS without actually touching AWS. Not a mock I wrote myself, and not a stub that returns whatever I told it to return. I wanted a real AWS-shaped answer — the same request format, response shape, and error when I get something wrong — just running on my own machine, for free, with no account and no bill at the end of the month.

On November 11, 2026, AWS shipped exactly that. The announcement on the AWS News Blog was called "Test your applications against AWS locally with AWS Emulator", and the product is now generally available: the AWS Emulator, AWS's official, free local emulator of AWS APIs. I went through what AWS has said about it and what its limits are — because the limits matter just as much as the launch.

What the AWS Emulator Actually Is


The simplest way I can describe it is this: the AWS Emulator is a local program you run on your machine, serving AWS APIs over a local HTTPS endpoint at 127.0.0.1:9297. Your application code stays unchanged. The AWS CLI, the SDKs, and coding agents like Kiro and Claude Code talk to it with the same APIs as real AWS — you point your tools at the local endpoint via environment variables instead of at AWS itself.

That last point is the one I keep coming back to. I am not being asked to rewrite my code for a test harness, or to learn a second API that sort of resembles AWS. The interface stays the same and only the destination changes.

You do not need an AWS account, and there is no additional service fee. You pay only for AWS resources when you deploy on real AWS. That matters for a beginner who has hesitated to experiment over fear of an unexpected charge, and for teams: a new developer can poke at AWS-shaped APIs on day one without anyone provisioning an account first. It is written in Rust, and AWS describes it as light on CPU and memory.

Built From the Same Models as the SDKs


Here is the part that made me take this seriously. The emulator is built from more than 400 AWS API models covering more than 200 AWS services — the same models the SDKs use, so requests and error responses have the same shape as AWS. There are 160 service crates in the Rust workspace behind it.

Why does that matter? Because most of the bugs I have chased in cloud code were in the error path: a missing parameter, a wrong type, or an error message my code did not recognise. If a local emulator returns a roughly-right success response but a completely different error, my tests pass locally and fail in production — worse than having no local test at all, because it gives me false confidence.

Building from the same API models is AWS's answer to that problem. It does not guarantee that every behaviour matches real AWS, but it does mean the shape of the conversation is the same. The source is on GitHub, in the aws/aws-emulator repository, under a CC0 public-domain dedication, with the vendor directory under Apache-2.0. The repository was created on September 11, 2026, picked up around 3,000 GitHub stars within about 12 hours of the announcement, and reached version 1.0.322 at launch on November 11.

It Was Built by AI Agents


All of its code was written and tested by AI agents, according to AWS. Hundreds of agents, organised in three teams, working on Bedrock AgentCore Runtime Instances, CodePipeline, and CodeCommit. Simon Willison noted 29,684 commits in three weeks.

My take — and I mark this clearly as my opinion, not a fact from AWS — is that this launch is two announcements in one: the emulator itself, and a proof point that AWS used its own agent platform to build a large, real piece of infrastructure software at a speed that would be hard for a human team to match, and then shipped it. I will not pretend that commit count alone proves quality — a lot of commits can mean careful changes, or a lot of churn. For my own work, the practical takeaway is simpler: I care less about who — or what — wrote the code than about whether it behaves correctly. That is why fidelity matters more to me than the headline.

Getting Started


Installation depends on your machine. On Linux, you install an RPM or Debian package, which adds aws-emulator to /usr/bin. On macOS and Windows, you run it in Docker — you build the image from the Dockerfile in the docs, because no ready-made image has been published. You can also build it from source, and there is an embedded mode for the AWS SDK for Rust.

My take: the Linux path sounds smoothest right now; on macOS and Windows, building a Docker image from a Dockerfile is an extra step, and I would rather AWS had published a ready-made image on day one.

On startup, the emulator generates its own credentials, config file, and certificate into ~/.aws/emulator/9297/. It uses a fake account, 000000000000, and access keys that start with EMULATOR. I like this design: I am not pasting real credentials into a local test setup, and a test run cannot accidentally point at a real account because I left an old key lying around.

Why "Official" Changes the Conversation


No honest article about this launch can skip LocalStack: the long-time incumbent community emulator, written in Python, created in October 2016, with around 65,119 GitHub stars. A lot of developers have leaned on it for exactly the problem the AWS Emulator now addresses.

So what changes when the emulator comes from AWS itself? My take is that the biggest change is not a feature list. It is accountability. When a community emulator gets an API shape slightly wrong, that is an understandable gap. When AWS's own emulator gets it wrong, that is AWS disagreeing with itself — and AWS has the API models and the incentive to close that gap.

The fidelity test suite is public, in the aws-emulator-evaluation-suite repository, including tests that do not pass yet, and per-service fidelity scores are published per release. There is also a public gap ledger under issues/things-that-do-not-work/ — 6,545 tracked files at one count — with entries moving to things-that-now-work/ when fixed. A public list of what does not work yet is more useful to me than a marketing page claiming everything works. LocalStack is not disappearing tomorrow — it has ten years of community use behind it — but teams now have a real choice, depending on which services they use and how much fidelity they need.

The Limits: What It Does Not Do


This is the section I most want you to read carefully, because the limits decide whether this tool helps you or misleads you.

First, and most important: the emulator does not evaluate IAM policies or resource-based policies the way AWS does. A request AWS would deny can succeed locally. AWS says do not use it to test security. If your test passes locally, that tells you your code's logic is probably fine — nothing about whether your IAM setup would allow that call in production. My rule of thumb: the emulator tests my application; real AWS tests my access control.

Second, unimplemented operations return HTTP 501 (Not Implemented). That is honest behaviour — better than a fake success — but check the gap ledger and fidelity scores before you assume your code is wrong when you hit one. Third, it is a single account, a single Region, which does not match a multi-account or multi-Region architecture. Fourth, it is not for production workloads or load tests.

Finally, telemetry: the emulator reports usage telemetry to AWS unless you turn it off. AWS says the records are minimized, never include request or response contents, code, credentials, or personal data, and are not shared with third parties. My take: I am glad the opt-out exists — but check the setting before your first run if your workplace has strict rules about what leaves your machine. None of these limits make it a bad tool. They make it a specific tool, and the mistake would be treating it as a small copy of AWS.

How I Would Actually Use It


Here is my take — practical advice, not a set of facts from AWS. I would use it for the fast, repetitive loop: write a feature, run it locally against the emulator, fix the request shape, fix the error handling, run it again. No waiting for a deployment, and no bill for a loop I ran fifty times while debugging.

I would use it for onboarding: a new developer can run the stack locally on day one without anyone provisioning cloud access first. I would also use it for automated tests that need AWS-shaped responses — especially the error cases, where a failure that looks like a real AWS failure makes the test far more valuable.

I would not use it for security testing, load testing, or multi-account behaviour — anything where the difference between the emulator and real AWS is the whole point of the test. For those, I still need real AWS, in a safe account.

Conclusion


The AWS Emulator is not a copy of AWS, and it does not pretend to be one. It is a free, official, local program that serves AWS APIs from your own machine, built from the same API models as the SDKs, with no account and no additional fee, and a public record of what it does and does not do yet.

That combination — official, free, local, and honest about its gaps — is why I think this launch matters. For years, local AWS development meant writing your own mocks or relying on a community emulator. Now there is an official option, and the gap between local and real is public and shrinking in the open. My advice: try it for the job it is good at — tightening your development loop, testing error handling, and letting people learn without touching a real account. Respect the limits, especially around IAM and security.

FAQ

What is the AWS Emulator?


AWS's official, free local emulator of AWS APIs, generally available November 11, 2026. It runs on your machine and serves AWS APIs over a local HTTPS endpoint at 127.0.0.1:9297, so the AWS CLI, SDKs, and coding agents can talk to it with the same APIs as real AWS.

Do I need an AWS account to use the AWS Emulator?


No. No AWS account is needed, and there is no additional service fee. You pay only for AWS resources when you deploy on real AWS.

How is the AWS Emulator different from LocalStack?


LocalStack is the long-time community emulator, written in Python, created in October 2016, with around 65,119 GitHub stars. The AWS Emulator is the first official emulator from AWS itself, built from more than 400 AWS API models covering more than 200 AWS services — the same models the SDKs use.

Can I use the AWS Emulator to test IAM permissions and security?


No. The emulator does not evaluate IAM policies or resource-based policies the way AWS does, so a request AWS would deny can succeed locally. AWS says do not use it to test security.

What happens when the AWS Emulator does not support an operation?


Unimplemented operations return HTTP 501 (Not Implemented). The project publishes per-service fidelity scores per release and keeps a public gap ledger, so you can check what works before you rely on it.

Looking for more WordPress & Elementor tutorials?

Explore our complete directory of 53+ web performance, theme development, and Elementor architecture guides.

View Topic Sitemap XML Feed