AWS released its own local emulator yesterday. I’m in the middle of preparing a new release of cfnrain, the CloudFormation CLI I maintain, so I took it for a spin.
It’s already good enough for SDK and IaC wiring, with some real gaps that are understandable on day one.
I care because integration tests against AWS are expensive. cfnrain’s real-AWS suite needed a dedicated account, OIDC trust from GitHub, guardrail policies, and a whole process to protect it and myself.
It isn’t a free AWS. There’s no console, only an API endpoint, so you drive it through the CLI, an SDK or your IaC tool. The README is direct about the rest: “AWS Emulator is for building and testing. Don’t use it for production workloads or to test security.”
None of AWS’s isolation comes with it. According to the security page, function code you hand it “runs with your user’s permissions and can read and change your files,” other users on the same machine can reach its ports, and the ports it opens for resources “don’t check request signatures.”
The one to watch in CI: “If AWSENDPOINT_URL isn’t set, your code calls AWS with whatever credentials it finds.” My CI job unsets every inherited `AWS*variable and refuses to continue unlesssts get-caller-identityreturns the emulator's account,000000000000`.
AWS Emulator is generally available, free, and released under CC0. It’s one local binary generated from AWS’s 438 published API models, with an endpoint for each. How much of each service actually works varies widely, and anything unimplemented returns a 501. AWS says agents wrote all of it: “Our team hasn’t written or reviewed any of the code.”
CC0 is unusual for AWS, which normally uses Apache 2.0 or MIT-0. It isn’t a license in the usual sense but a public domain dedication: AWS waives its copyright, so you can copy, fork, embed or ship the code with no conditions and no attribution. The reason is the agents. The New Stack reports that AWS wasn’t sure it could copyright code no human wrote, and didn’t want to claim rights that might not exist. Two caveats: the vendor/ directory, the framework the agents build on, stays under Apache 2.0, and CC0 leaves patent and trademark rights untouched, so you don’t get the patent grant Apache 2.0 would give you.
Setup takes minutes. The Linux package is 163 MiB and runs without root. It’s ready in about 23 milliseconds and serves HTTPS on localhost with its own credentials and CA. cfnrain uses the AWS SDK for Go v2, which talked to it with no code change, only environment variables.
Everything lives in memory and is gone on restart, Regions and accounts aren’t kept apart so you run one emulator per Region, and telemetry is on by default. AWS publishes fidelity scores with every release. CloudFormation passes 795 of its 4,206 test units, and the docs say IaC support “varies by service.”
Three rounds: cfnrain’s own workflows, then a production-shaped VPC with Aurora and Fargate on top, then a minimal stack for each of 18 services, each one created, updated and deleted. Every resource was read back through its own service API. Exit codes and stack status were never taken as proof.
The CloudFormation core holds up. Create, update and delete, change sets previewed and then executed, a failing update that rolls back with the real reason in its events, termination protection, artifact uploads to S3. Express mode and Early Validation, the two CloudFormation features AWS shipped this year, behave the way they do in a real account.
The messaging core moves real data. A message sent to SQS comes back out, an SNS publish lands in a subscribed queue, EventBridge events reach their target, Lambda runs inline Python, Step Functions executions succeed and DynamoDB answers a GSI query. If your application is mostly queues, functions and tables, you can test a lot of it locally today.
A commenter on r/aws said “it’s not really clear where the edges are,” and after playing with it I agree: it’s not easy for a human to tell what is expected to work and what isn’t.
Success for things that don’t exist. CloudWatch alarms, ElastiCache, CloudFront, load balancers and ECS services all reported CREATE_COMPLETE, and their service APIs had nothing. CloudFront and the load balancers even hand back plausible DNS names. An Aurora cluster reported complete too, until its instance failed with “cluster not found.”
Create, but no update. API Gateway, ECR and WAFv2 stacks create fine and roll back on their first update with NotImplemented. So did every update I tried on a stack with an internet gateway attachment, which most VPCs have.
No permission checks. “The emulator never denies a request signed with its own key,” so permission bugs stay invisible. One commenter put it plainly: “Not realistically usable for IAM is a bummer.”
Lambda can’t reach most of AWS. The runtime builds SDK clients for only a handful of services. SNS, which my function needed, isn’t one of them, and neither is S3. The invoke still returns HTTP 200, with the error flagged “Unhandled.”
Real templates hit real bugs. A plain VPC template failed on !GetAtt of an Elastic IP, which resolved empty. An import inside an Fn::If branch that was switched off still got resolved. ACM DNS validation and StackSet instances aren’t implemented.
I filed seven issues upstream, each with a plain CloudFormation and AWS CLI reproduction. None has an AWS response yet. The published scores were a rough guide at best, and they didn’t predict my results well in either direction.
A commenter on r/aws named the use case: “much faster than deploying cloudformation to a personal testing account.”
cfnrain’s real-AWS suite runs off main: on every push, weekly, and on pull requests a maintainer labels. Those tests aren’t easily parallel-safe, and cleanup across concurrent runs would become its own problem. The emulator gives every pull request its own isolated, throwaway AWS instead.
Mark every integration test as emulator-safe or real-AWS only. RDS, ECS, IAM and anything that updates an API Gateway stay on real AWS.
Run the emulator-safe set on every pull request. Mine is 36 checks in under three minutes on a stock GitHub runner, with no AWS credentials and read-only repository permissions.
Keep the real-AWS suite on main as the referee. A test only counts as emulator-safe when it passes on both. When the two disagree, you have a bug report, which is where my seven issues came from.
Read back, don’t trust status. Every check asks the service API what exists.
Prove the tests can fail. I broke cfnrain on purpose in six places, and the emulator job caught every one.
Step 3 also answers the most upvoted comment in the thread, which balked at agents fixing code “without human review.” You don’t have to trust the emulator. Your real-AWS suite reviews it.
LocalStack has been the default since 2016, with CloudFormation since 2017. Its free community edition ended in March 2026: it now needs an account, the free tier is non-commercial only, and paid plans run $39 to $89 per license per month. Moto has mocked AWS inside Python tests since 2013 and CloudFormation since 2014, and it resets state between tests without a restart, which AWS Emulator can’t do. Floci, MIT-licensed and the one r/aws kept recommending, runs RDS, ElastiCache and MSK as real Docker containers, the very resources AWS Emulator fakes today. MiniStack, Fakecloud and LocalEmu are newer still.
AWS’s own earlier local tools covered one service each: DynamoDB Local, sam local, Step Functions Local. As far as I can find, AWS never shipped a local CloudFormation before this one. Its edge is that it comes from AWS, it’s scored in public against AWS behavior, and it covers every published API model.
If you test RDS or ElastiCache, Floci runs the real engines that AWS Emulator fakes today, and if you need fast per-test resets in Python, Moto.
The repository shows 12 releases in five days. I expect most of these gaps to close within weeks. Exciting times ahead.
What’s New: AWS Emulator now available — launch date 2026-11-11
AWS News Blog: Test your applications against AWS locally — GA, no service fee, AgentCore/CodePipeline pipeline
About Amazon: How autonomous AI agents built AWS Emulator — Goldberg: “written entirely by autonomous agents”, CC0 reasoning
All Things Distributed: Swami on the engineer’s job when agents write the code — “An engineer built the scaffolding”
The New Stack: AWS Emulator and AI agents — Callaway quotes, 438 API models, copyright angle
AWS Emulator user guide — install, limits
Fidelity page — scoring method
Security page — “never denies a request signed with its own key”; function code not isolated from your machine; real credentials leak if AWS_ENDPOINT_URL is unset
Telemetry page — on by default, includes which AI assistant drives it
aws/aws-emulator — source, no PRs accepted, issues/ directory
Release v1.0.322 — version tested, scores.json.gz
Evaluation suite — published “so that you can not trust us”
LocalStack: The road ahead — account required, free tier non-commercial from March 2026
DEV: How emulators might catch what you might miss — LocalStack CTO statement
LocalStack pricing — Hobby free non-commercial; Base $39, Ultimate $89 per license per month, billed yearly
localstack/localstack — community repo, archived
getmoto/moto — Python mock library, Apache-2.0, since 2013
floci-io/floci — MIT, Java, real Docker for RDS/ElastiCache/MSK; floci-ui web console
ministackorg/ministack — Python, MIT, 60+ services
faiscadev/fakecloud — Rust, AGPL-3.0, 107 services
localemu/localemu — LocalStack fork
HN: AWS emulator — maintenance, telemetry, state reset (jbmchuck)
AWS write-up: Lambda runtime has no SNS client — eight valid service names; permission test can’t tell denied from missing client
AWS write-up: Lambda runtime has no S3 client — nine valid names, adds sesv2
Step Functions Local: unsupported — “does not provide feature parity and is unsupported”
r/aws discussion — launch thread by an AWS employee; top comments: no human review (159), which services are implemented (95), oneplane on spec conformance (67), IAM (26), Floci (19)
cfnrain CI job, PR #317 — the emulator job

