On November 11, 2026, AWS released AWS Emulator: an official, free, public-domain emulator that lets you test applications against AWS APIs on your laptop or in CI, with no AWS account. I tried it on a small but complete application, first with the AWS CLI, then with Terraform.
This article starts with what it changes for engineering leadership, then goes into how it works, the numbers, and the limits, for those who will actually get their hands on it.
What it changes, beyond development teams
- Cheaper, faster tests. Part of your integration testing can run without a cloud environment to pay for or wait on. The emulator answers in milliseconds, on a laptop or in a pipeline.
- Fewer secrets in circulation. These tests no longer need real AWS credentials on developer machines or in CI. That is attack surface you get to remove.
- A sandbox for AI agents. Each instance has its own port, keys and state. A coding agent can create, break and retry without ever touching a real account.
- A signal about how software gets built. AWS says this product was written, and is maintained, entirely by AI agents. Trust does not rest on the author but on a public test suite and scores published with every release.
- A product that improves by the day. In five days, its measured fidelity went from 56.5% to 69.4%, and ElastiCache gained a Redis engine between my two test runs. What blocks you today may not block you next month.
- One limit to keep in mind. The emulator passes 69.4% of its own fidelity tests (56.5% at launch, five days earlier), and it does not evaluate IAM permissions the way AWS does. It complements a pre-production environment; it does not replace one.
My take in one sentence: adopt it now for everyday integration tests, not yet for replaying a full infrastructure.
Why this is a big deal
Testing AWS code without touching AWS is an old need: lower costs, faster pipelines, reproducible tests. For years, LocalStack was the reference. In March 2026, its free Community edition gave way to a single image that requires an account and an auth token, and several open-source alternatives (Floci, Kumo, fakecloud, LocalEmu and others) appeared in response.
An emulator published by AWS itself, in the public domain, reshuffles the deck: no more licensing question, and a vendor committed to tracking its own APIs.
What AWS Emulator is
It is a local program, written in Rust, that exposes an endpoint compatible with AWS APIs. You point the CLI or an SDK at it, without changing your code, and calls are served in milliseconds.
Services are not hand-coded one by one: they are generated from the API models AWS publishes. Any service that has a model is therefore covered at least on the surface, and new services or APIs show up automatically. Trade press reports more than 200 services. Real behavior is then filled in and verified progressively.
The code is released under CC0 (public domain) and there is no service fee: you only pay for AWS resources when you actually deploy to AWS. The emulator is most faithful on the control plane (create, describe, update, delete resources). It keeps state, so later calls see earlier changes, and it rejects invalid calls with the same errors as AWS when the operation is implemented.
Getting started in five minutes
The official guide is tested on Amazon Linux 2023, with an RPM package. A Debian package exists too: that is the one I used on Ubuntu, in WSL and in Docker. AWS does not publish a ready-made Docker image; a few Dockerfile lines around the package are enough.
Install and start, in a first terminal:
PKG=https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest # Debian, Ubuntu, WSL curl -fsSLo aws-emulator.deb $PKG/aws-emulator_amd64.deb sudo apt-get install -y ./aws-emulator.deb # Amazon Linux 2023 sudo dnf install -y $PKG/aws-emulator-x86_64.rpm aws-emulator The emulator listens over HTTPS on 127.0.0.1:9297 and generates its credentials, config and certificate in ~/.aws/emulator/9297/. In a second terminal, point the CLI at it:
export AWS_ENDPOINT_URL=https://127.0.0.1:9297 export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials export AWS_CONFIG_FILE=~/.aws/emulator/9297/config export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem export AWS_EC2_METADATA_DISABLED=true export AWS_DISABLE_HOST_PREFIX_INJECTION=true export AWS_REGION=us-east-1 export AWS_DEFAULT_REGION=us-east-1 unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE aws sts get-caller-identity aws s3 mb s3://local-getting-started There is a single account (000000000000) and access keys start with EMULATOR. They change on every start, and the emulator rejects any request signed with other keys. For Rust tests, an embedded mode creates one instance per test, each with its own state, so tests can run in parallel.
Measured fidelity
This is the real differentiator. Fidelity measures how closely the emulator answers like AWS. A fidelity test only passes if the HTTP status, the body, the exact error code and message, and the resources created all match what real AWS returns.
The tests are public in the aws-emulator-evaluation-suite repository, including those that still fail, and scores (k tests passed out of n) ship with every release. I recomputed the scores from the scores.json.gz file of two releases: 1.0.322 from November 11, 2026, launch day, and 1.0.471 from November 16. A test that touches several services counts for each of them:
| Scope | Score on Nov 11 | Score on Nov 16 | Tests passed on Nov 16 |
|---|---|---|---|
| All services | 56.5% | 69.4% | 30,237 of 43,548 |
| AWS KMS | 71% | 86% | 437 of 510 |
| Amazon SQS | 68% | 76% | 1,173 of 1,536 |
| Amazon S3 | 63% | 76% | 2,172 of 2,845 |
| AWS IAM | 58% | 72% | 895 of 1,238 |
| Amazon ECS | 48% | 63% | 608 of 965 |
| Elastic Load Balancing v2 | 47% | 63% | 456 of 724 |
| Amazon EC2 | 39% | 54% | 1,346 of 2,499 |
| AWS CloudFormation | 19% | 24% | 1,022 of 4,282 |
Thirteen points gained in five days: the product moves fast, and every figure quoted here will age just as fast. A test only passes if the whole sequence of calls matches AWS; taken individually, 81% of calls pass. Create operations are therefore much better covered than full scenarios. One more note from the documentation: a score can go down when new tests are added, even while the emulator improves. To check whether your own project is covered, AWS provides a skill for coding agents and the list of operations in manifest.jsonl.
Built by AI agents
AWS says the emulator was entirely written and is maintained by autonomous agents, with no code written or reviewed by its engineers. Three roles share the work: detection agents compare responses with real AWS and with the Smithy models, then open an issue for each gap; fix agents write the test, implement the behavior and review the change; a security agent reviews every change adversarially. Each release goes through a CodePipeline pipeline that replays the fidelity tests.
The GitHub repository exposes every issue opened by the agents, sorted into resolved and unresolved. That is an interesting case in itself: quality does not rest on trusting the author, but on a public, measurable test suite.
Limits to know
An emulator is still a testing tool. The documentation is clear on several points:
- IAM: IAM policies and resource-based policies are not evaluated the way AWS evaluates them. A call denied in production can succeed locally.
- Single account and Region: an instance behaves like one account and one Region, with no cross-account or cross-Region behavior.
- Unimplemented operations: they return an HTTP 501 (Not Implemented) error.
- In-memory state: it is lost when the emulator stops.
- Variable fidelity: the data plane, CloudFormation and CDK depend on the service; check the scores.
- Security: by default, the emulator only listens locally and refuses requests not signed with its keys. It sends anonymous usage and error data, which you can turn off, and you should keep real AWS credentials out of the test environment.
Practical conclusion: it replaces neither a real pre-production environment nor IAM policy testing.
My test in detail
AWS Emulator is good news for teams doing integration testing: free, no account, with a vendor that publishes its own gaps. But with an overall score of 69.4%, you have to check service by service what you can rely on, rather than treat it as a complete local AWS.
The test: a fictional application, "Carnet" (French for notebook), with a React front end, a Python back end and Cognito authentication. The back end reads its notes from RDS PostgreSQL, caches the list in ElastiCache, exports to S3, publishes to SQS and logs to CloudWatch Logs. A shell script creates the whole infrastructure with the AWS CLI, plays a scenario and classifies each step: passed, failed, or not implemented (501).
The code is on GitHub if you want to run it yourself: PatriceT/aws-emulator-carnet-demo. It is a snapshot of these tests, not a maintained project.
Result on November 16, 2026, on version 1.0.471, on Windows 11 with WSL 2 and Docker: out of 72 checks, 66 passed, 6 failed, and no 501 errors. The whole demo starts with docker compose up --build, and the full user journey works: sign in, create a note, read it back from the cache.
I had run the same test three days earlier, on version 1.0.341, and three things changed in between. ElastiCache now exposes a local port that speaks the Redis protocol, where there was nothing behind it before. A public ALB is now rejected if the VPC has no internet gateway, exactly as on AWS: my script was wrong and used to pass by mistake. And the overall fidelity score gained thirteen points. A test written against this emulator therefore needs to be replayed regularly.
The Carnet app after sign-in, on November 16 with version 1.0.471: the note is in the database, the list is read back from the cache, and all seven building blocks respond. The cache now goes through the emulated ElastiCache; three days earlier, it needed a local Redis.
Excerpt from the script output (labels translated from French):
OK Cognito Sign-in (InitiateAuth) OK Cognito Wrong password rejected OK Cognito Public keys (JWKS) OK RDS (SQL) INSERT ... RETURNING OK RDS (SQL) Transaction and ROLLBACK FAIL RDS (SQL) now() function FAIL RDS (SQL) Auto-incrementing serial column FAIL RDS (SQL) Identity column FAIL RDS (SQL) gen_random_uuid() OK RDS (SQL) jsonb type .. ElastiCache Endpoint reachable: YES OK ElastiCache (Redis) SET with expiry OK ElastiCache (Redis) GET FAIL ElastiCache (Redis) HSET (hash) FAIL ElastiCache (Redis) LPUSH (list) One trap to know about: the emulator moves some states forward on its own, like AWS does. My first runs gave different results from one run to the next, depending on machine speed. Measured on version 1.0.341: an SES identity is only verified half a second after it is created, and a send attempted before that is rejected with "Email address is not verified"; an ACM certificate goes from PENDING_VALIDATION to FAILED after about 3 seconds; an ALB target goes from initial to unhealthy in the same time. The script now waits for the stable state before checking, and every run since, on two machines, gives the same result.
| Building block | What works | What diverges |
|---|---|---|
| Cognito | Pool, client, user, sign-in, wrong password rejected, RS256 tokens verifiable through JWKS | The token issuer is the emulator's address |
| RDS PostgreSQL | Instance created, local port speaking the PostgreSQL protocol, common SQL, transactions, jsonb | Not a real PostgreSQL: now(), serial, identity and gen_random_uuid() fail |
| ElastiCache | Created through the API, local port speaking the Redis protocol: PING, SET, GET, INCR | Partial Redis: HSET and LPUSH are unknown, and only the older RESP2 protocol is accepted |
| S3, SQS, Secrets Manager, CloudWatch Logs | The whole scenario, including the S3 presigned URL and the SQS dead-letter queue | Nothing in this scope |
| VPC, security groups, ACM, ALB | All creations; duplicate rule and public ALB without an internet gateway rejected as on AWS | No traffic flows through the emulated ALB |
| SES v2 | Identity created, send accepted once the identity is verified | No email delivered; send rejected during the first half second |
Two lessons for a development team. The control plane is solid on these common services, and the application runs end to end with unchanged boto3 code. However, the emulated engines are partial: RDS's PostgreSQL does not know now() or serial, and ElastiCache's Redis does not know lists or hashes. Carnet's back end therefore sticks to portable SQL and a key-value cache, and I had to force the redis-py client to RESP2 for it to connect. A more demanding application will keep real containers alongside. Another trap I ran into: AWS CLI v1 ignores AWS_ENDPOINT_URL for RDS in us-east-1 and sends the call to real AWS; use CLI v2 or the --endpoint-url option.
And with Terraform?
I described the same infrastructure in Terraform (31 resources) and ran apply, a control plan and destroy against emulator 1.0.471, with Terraform 1.17.2. It is rougher than with the CLI. The three blockers I hit are instructive, and none of them moved between November 13 and 16:
| Blocker | What happens | Workaround |
|---|---|---|
| AWS provider 6.x and S3 | Creating a bucket hangs: the provider reads tags through the S3 Control API, whose requests do not reach the emulator (a limit documented by AWS) | Stay on provider 5.x (tested with 5.100.0) |
| Security groups | Terraform revokes the default egress rule at creation; the emulator answers that it does not exist, even though it lists it | None found: the 3 groups and their 3 rules are not created |
| RDS without a version | Without engine_version, creation is rejected ("Cannot find version for postgres") | Set engine_version |
Once you work around these, the rest behaves well: 25 of 31 resources created (S3, SQS, Secrets Manager, Cognito, VPC, ACM, ALB, RDS, ElastiCache, SES, CloudWatch), an empty control plan, so no drift on re-read, and a complete destroy. All in about 4 minutes, including 1 min 20 s waiting on RDS and 1 min on the ALB. My initial fear, that unfaithful reads would make the plan unstable, did not materialize in this scope.
Conclusion: for infrastructure as code, the emulator is usable service by service, not yet for replaying a full stack as is. A module that creates security groups, which means almost all of them, does not pass today.
Should you adopt it?
| Use | Verdict | Why |
|---|---|---|
| Application integration tests (S3, SQS, Secrets Manager, Cognito, logs) | Yes, right now | The whole scenario passes, with unchanged application code |
| Applications that depend on a database or a cache | Yes, with a container alongside | RDS's PostgreSQL and ElastiCache's Redis are partial |
| Sandbox for coding agents and CI | Yes | Isolated instances, no real credentials |
| Full infrastructure as code with Terraform | Not yet | Security groups fail, the recent provider hangs on S3 |
| Security and IAM permission tests | No | Policies are not evaluated the way AWS evaluates them |
| Validation before going to production | No | Partial fidelity, no real traffic |
The product moves fast, with several releases a day: these verdicts hold for version 1.0.471 of November 16, 2026, and deserve to be rechecked in a few weeks.
Sources
- AWS – AWS Emulator now available (What's New, French page)
- AWS News Blog – Test your applications against AWS locally with AWS Emulator
- Documentation – Fidelity in AWS Emulator
- Documentation – What is AWS Emulator?
- Documentation – Pointing your AWS SDK at AWS Emulator
- GitHub – the test code for this article
- GitHub – aws/aws-emulator
- GitHub – AWS Emulator releases, each with its scores.json.gz
- Help Net Security – AWS Emulator, built by autonomous AI agents
- InfoQ – LocalStack
- LocalStack – The Road Ahead


