Developer working on a MacBook Pro at a desk, running code locally on the laptop

AWS Emulator: Where a Free Local AWS Fits in Your Test Strategy

On November 11, AWS shipped something QA engineers have wanted for years: an official local copy of its APIs. AWS Emulator runs on a laptop, a dev server or a CI runner, needs no AWS account and has no service fee. Point your SDK at it and your integration tests stop touching the cloud. That’s useful. It also comes with a list of things a green run cannot prove, and that list matters more than the launch headline. Here is how I would fit the AWS Emulator into a team’s test plan, and where I would keep real AWS in the loop.

What AWS Emulator actually gives a test team

The emulator is a Rust program that serves an AWS API endpoint on your machine. You set environment variables so the AWS CLI or an SDK talks to it, and your code runs unchanged. AWS says it covers more than 400 API models across more than 200 services. Some coverage, including InfoWorld’s, cites 426 services; I would go with AWS’s own count.

Per the GitHub README, it installs from RPM or Debian packages on Linux and runs in Docker on macOS and Windows. Rust projects get an embedded mode with one isolated emulator per test. The code is released under CC0, and telemetry is on by default, so switch it off in CI if your policies require that.

One detail I like as a tester: InfoWorld reports that operations the emulator doesn’t support yet return HTTP 503 instead of a fake success. A loud failure beats a silent pass.

What a green run in the emulator cannot prove

AWS is unusually direct about this. Its security guidance says passing tests in the emulator “don’t show that your permissions are correct or safe.” The emulator never denies a request signed with its own key, and it ignores KMS key policies and S3 bucket policies. A request AWS would deny can succeed locally, and the reverse can happen too.

The limitations page adds more gaps to plan around:

  • One Region and one account per emulator. Testing multi-Region behavior means one emulator per Region, each on its own port.
  • Behavior is checked against AWS only in us-west-2 (us-east-1 for global services), so Regional differences in features don’t show up.
  • Everything lives in memory and disappears when the emulator stops.
  • AWS hasn’t tested it for long-running use or load testing.
  • Function code you hand it is not isolated from your machine and runs with your user’s permissions.

InfoWorld quotes IDC’s Devin Pratt noting there’s no simulation of throttling or outages at launch, and Broadcom’s Advait Patel warning that missing failure modes create “false confidence.” Retries, backoff and timeouts are exactly the code paths that break in production, so they need another home in your plan.

A tiered test plan with AWS Emulator in it

The emulator fits best as a new middle layer: faster and cheaper than a cloud sandbox, more realistic than hand-written mocks. A split I’d start with:

  1. Unit tests stay as they are, with no AWS calls at all.
  2. Integration tests on the emulator run on every commit, locally and in CI. This is where you check multi-service flows, request shapes and validation errors. AWS’s docs show it returning the same DynamoDB validation error as the real service for a too-short table name.
  3. A real AWS sandbox stage before release covers what the emulator can’t: IAM and resource policies, cross-account and cross-Region access, throttling and failure behavior.
  4. Load and soak tests stay on real infrastructure.

Watch one trap in the CI scripts. AWS warns that if AWS_ENDPOINT_URL isn’t set, your code calls real AWS with whatever credentials it finds. Set the variables in the same script that runs the tests, and unset real credentials first. A misconfigured runner shouldn’t be able to write to a production bucket.

Check fidelity before you trust it

Fidelity varies by service, and AWS publishes fidelity scores with every release. Its project check guide describes a manual process worth putting in your test plan:

  • List the AWS operations your workflow calls.
  • Find their fidelity tests in manifest.jsonl in the evaluation suite repository.
  • Check the score for each service in the release you pinned.
  • For anything uncovered, run your own test against both the emulator and AWS and compare.

The repo also tracks known gaps in issues/things-that-do-not-work/. Read it before you migrate a suite, not after a flaky week. Security fixes ship only in the latest release, so plan for regular upgrades instead of pinning one version forever.

One more piece of context: AWS says autonomous agents wrote the emulator’s code, behind a merge gate that runs build, review, security and fidelity-regression checks, and that its team hasn’t written or reviewed any of it. That is AWS’s own account. For a test team, it’s one more reason to lean on the published fidelity tests rather than on assumptions.

What this changes for teams paying for local AWS tooling

Many teams have run LocalStack for this job. Since March 23, 2026, LocalStack ships as a single image that needs an account-bound auth token, CI included. SiliconANGLE quotes Constellation Research’s Holger Mueller describing AWS’s move as a “digital twin” of its public cloud. A free first-party option is worth a pilot, but treat it like any new dependency: run both tools on the same suite for a sprint and compare the failures each one catches.

Conclusion

A local AWS makes integration tests cheap enough to run on every commit. The risk is cultural: a team that sees green locally and stops testing permissions and failure modes on real AWS. Write down what the emulator can’t prove and give each item a stage that can. If your team needs QA and cloud engineers to set up that kind of pipeline, talk to Luby.