· via dev.to (home feed)
AWS Emulator reaches general availability for testing AWS calls without an account
AWS Emulator is now generally available, letting developers exercise CLI and SDK calls against a local, in-memory stand-in for AWS services without an account or a deployment.

What happened
AWS Emulator, a tool for exercising code that calls AWS services without deploying it first, reached general availability on November 11, 2026, according to a dev.to write-up. The emulator takes API calls made through the AWS CLI and language SDKs against a local HTTPS endpoint, either on a laptop or inside a continuous integration pipeline, and it runs without an AWS account.
How it works
Point a CLI or SDK at the emulator's local endpoint and calls accumulate state across a test: a bucket created early in a run is visible to the code that runs later. That state lives in memory and disappears when the process exits, so each run starts from a clean slate. AWS ships Linux packages plus a Docker setup for macOS and Windows, and Rust test suites can embed the emulator directly. In server mode it creates its own signing credentials and a local certificate, so it never needs credentials from a real account.
The dev.to author draws a distinction between configuring a service and using it. Creating an S3 bucket is a control-plane call; uploading and reading an object are data-plane calls. A successful create only proves the emulator recorded the configuration. The post cites a public CDK test in which the emulator dutifully created an ECS service record while no containers actually started.
Fidelity, not full coverage
Coverage varies by operation. AWS scores services on what it calls fidelity: the count of test cases whose results, including expected errors and resulting state, match real AWS. A service score is not the share of API operations implemented, and anything unsupported returns 501 Not Implemented. The practical advice from the article is to list the operations your code actually calls, check them against the fidelity test suite, and run your own workflow on a pinned release rather than trusting a coverage percentage.
What to test locally, and what not to
Good local candidates include S3 and DynamoDB behavior such as conditional writes, message handling across SQS, SNS and EventBridge (including deliberate redelivery), simple Lambda handler invocations, and small CloudFormation templates. Public examples cited in the post range from a notes app over S3 and DynamoDB with a GitHub Actions workflow to a serverless order demo covering payment retries and inventory rollback.
What belongs in real AWS: permissions, throttling and contention at production load, managed triggers, retry and redrive configuration, networking, and anything performance-related.
The post also carries a warning about request routing. In one reported JavaScript setup, CreateQueue went to the emulator while SendMessage followed the returned queue URL back to real AWS, and checking only the initial endpoint would have missed it. The recommendation is to run setup and tests in the same isolated process with real AWS credentials removed, and to verify where requests actually land before allowing writes.
The author demonstrates the payoff with a worker that reads from S3 and records metadata in DynamoDB. The first delivery's acknowledgement is suppressed; on the second delivery, which carries the same message ID but a new receipt handle, the worker finds the existing row and leaves exactly one unchanged record, thanks to a conditional write keyed on an application request ID.
Agents on both sides of the tool
AWS ships a coding-agent setup skill that can start the emulator, connect the CLI or SDK, and detect which operations a project uses. The article's guidance is to give an agent an assertable outcome rather than just a service to call: reproduce a failure, confirm precisely what state remains, and report what still requires real AWS.
More notably, according to the post, AWS says agents build and maintain the emulator itself, finding behavioral differences from real AWS, writing tests and fixes, and pushing changes through a release pipeline that reruns the fidelity suite. The transferable lesson the author draws is that an agent can propose code and even write the test, but the expected behavior has to come from a reference outside the agent's own implementation.
Why it matters
Local AWS testing has historically meant mocks that return whatever response you scripted, or slow and costly deployments to a live account. The emulator offers a middle path: real API semantics, real error responses and real state transitions, disposable by default. That is more convincing evidence than a mock for behaviors applications genuinely depend on, such as idempotent redelivery handling and conditional writes, and it slots naturally into pull-request checks and agent-driven development loops. The limits are equally clear: a green local run says nothing about permissions, account and region boundaries, managed service behavior, or performance, so a small real-AWS suite remains necessary. And the fact that AWS uses agents to maintain the emulator, with an independent fidelity suite as the referee, is an early template for how agent-written software might be verified at scale.
- #aws
- #cloud
- #testing
- #developer-tools
- #continuous-integration