Developer Tools10 min read

Which AWS tests can you move from the cloud to your laptop?

AWS Emulator runs supported cloud API calls locally. A DynamoDB write-and-read test shows where it can shorten feedback and why the real AWS account still matters.

K
Ken Jo

Suppose a code change looks trivial. An app should write an order to DynamoDB and read back the same order. You can check the arguments to a mocked client in seconds, or you can deploy to a development account and watch the full flow. There is a useful test between those two choices, and AWS now supplies the endpoint for it.

On November 11, 2026, Amazon Web Services made AWS Emulator generally available. The open-source tool lets the AWS CLI and SDKs send supported service requests to an emulator on your machine. AWS charges no additional service fee for the emulator. Its behavior varies by API, and AWS still advises running security checks and the whole application against real AWS before production. AWS launch announcement

The DynamoDB example makes the division clear. Check that your application writes and reads the right data on each change. Spend a smaller cloud test budget checking whether the deployed role, resources, and service behavior agree with your assumptions. Keep both checks in the release process.

An integration test can start with one record

Start with a concrete business assertion. An order with ID order-123 enters the test app with status pending. The app writes it through its DynamoDB client. A fresh read through the app's repository returns that same ID and status. This test catches mistakes such as writing to one table and reading from another, serializing the attribute under the wrong name, or assuming a different key shape. A mock can help reproduce those mistakes when explicitly configured, but you have to anticipate them.

AWS's release post demonstrates a similar sequence. It creates a table with a string partition key, inserts a test item, and reads it back. The post shows the CLI version and an in-process Rust SDK example. Using the normal client keeps this example close to the integration code you already run. An assertion on the returned value matters more than an assertion that the SDK method was called. AWS launch examples

A DynamoDB integration test sends a write and read through the SDK to a local endpoint

The local loop exercises the same client path for a write and a read. Original illustration by Telli.sh.

On Linux, AWS provides native RPM and Debian packages. For Windows and macOS, the official instructions describe building and running a Docker image. The standalone emulator starts an HTTPS endpoint on 127.0.0.1:9297 by default and writes a local configuration, certificate and separate credentials. The health check and caller identity help you verify that the test shell is talking to the emulator before you create resources. AWS documents an embedded mode for its Rust SDK as another way to run a scoped test instance inside the process. AWS Emulator user guide

Keep the client setup in the test configuration. A test shell should contain the emulator's endpoint, certificate settings and credentials, with real AWS credentials kept out of that shell. Keep the same application code in the real deployment. That makes the boundary reviewable. If the emulator is unavailable, the local job should fail with an explicit connection or configuration error. A test that silently reaches a different environment can invalidate its result and surprise whoever is responsible for the account.

AWS says requests, responses and data stored by the emulator stay on the local machine. The standalone emulator separately sends anonymous usage and error data by default. That telemetry can be disabled in the emulator settings. AWS launch documentation

Use each test where it can prove something

There are three useful layers. The first is a unit test for behavior you own, such as rejecting an order whose fields are incomplete before calling a service. A second layer exercises client configuration, encoding and the supported service operation together. A third checks the deployed resources, roles and service behavior in an actual AWS environment. You can move work between these layers after you see what each failure looks like.

LayerExample assertionEvidence it gives you
Unit testAn empty order ID is rejected before the client runsThe app enforces its own rule
Local emulatorA valid order can be written and read through the SDKThis client and these supported operations work with the emulator
AWS integrationThe deployment role can update its permitted table and is denied on the prohibited resourceThe real configuration enforces the access boundary

Start with one successful local case and add the failure your team cares about. If a duplicate request must leave the stored order unchanged, you might add a second call and check that the business result is correct. If the failure depends on conditional writes or transactions, confirm that the specific operations behave as your test assumes. The useful question is whether the emulator exercises the same operation and semantics your product needs. Checking an item exists tells you little about a race you never simulated.

A queue-driven example makes that distinction visible. A worker reads a job, writes a result, and acknowledges the job. You can construct a local test for the worker's ordering if the required operations are supported. Force the result write to fail, then see whether your app keeps the job available for retry according to the contract you designed. Use a cloud environment for service-managed event delivery, deployed role permissions and the timing that matters under load. Treat the local test as evidence about the path it actually exercised.

A service name tells you less than the operation list

AWS publishes fidelity results by service as a count of tests passing out of the total. Its launch post illustrates the format with 40 of 50. That example describes how to read the score. A team still needs to look at the evaluation cases for the calls it relies on. A score can fall after a release adds harder tests, even as support for existing features improves. AWS says an unimplemented operation responds with HTTP 501 in the emulator. AWS evaluation suite

A team with three DynamoDB calls should make a short list of those operations and the details that matter. The list could contain a write, a strongly consistent read, and a conditional update that prevents one user action from overwriting another. Record whether each behavior is covered by an upstream evaluation, a team test, a cloud check, or a combination. Check your required operations again when you update the emulator. That turns fidelity into a versioned dependency decision.

A test plan sends supported request behavior to the emulator and deployed permissions to a real AWS environment

The two environments answer different questions about the same application. Original illustration by Telli.sh.

When a test returns HTTP 501, identify the operation before changing application behavior. Moving that case into the cloud test job preserves the requirement. If the API is available but a local response differs from AWS, isolate the smallest input that reproduces the mismatch with synthetic data and file it upstream if helpful. A mismatch can also reveal an assumption in your client code. Keep the failing behavior visible until you know which side owns it.

The launch announcement says the project uses AI agents to compare emulator behavior with real service responses and published API models, with changes reviewed and checked by a release pipeline. That process is part of how AWS maintains the project. It gives teams public evaluations to inspect. It does not give your app a passing result for an operation that has yet to be tested. AWS launch and development process

Keep permissions and deployment in a real account

The local tool uses request signing and emulator-specific credentials, but those checks serve a different purpose from a full AWS policy evaluation. AWS says the emulator does not evaluate IAM and resource-based policies the way AWS does. It also models a single account and has no cross-account or cross-Region behavior at launch. A successful response from the emulator provides evidence for a functional test. A cloud test with a deployed identity provides evidence for a permission decision. AWS launch limits

Take the order example one step further. The production worker should only update a specific table. In the development AWS account, invoke it with the role it actually uses and verify the operation on the allowed table. Check the same operation with a controlled resource that the role must be denied from writing to. The negative case matters because a test that checks only allowed writes can pass when the role is overbroad. Keep test resources synthetic and clean them up according to your team's existing environment policy.

In another example, an app reads files uploaded to a storage bucket in a separate account. The deployment can depend on the app role, the bucket policy and the resource relationship. Run a narrow cloud check for that relationship on the relevant account and region setup. Use the emulator for input validation, object naming or the steps that depend on supported calls within one local instance. This arrangement keeps developers moving and tests the contract that will govern the real connection.

Put the fast tests on the branch and measure the whole loop

An emulator can shorten a feedback loop, but your result depends on which job currently takes the time. A three-minute deploy to test one API change presents a different opportunity from a long test suite that already runs in a cheap shared environment. Measure setup, execution and teardown on your current path. Then try the same representative change with a local integration job, and record which cloud cases you still run and when.

Use the wall-clock time from the start of the change to the first actionable result. A faster test job can still slow the workflow if developers spend ten minutes diagnosing missing certificates or shared-state failures. Pin the emulator release in the CI job, isolate test data and wait for readiness before running the suite. Keep startup and assertion failures distinct in the logs. AWS describes isolated embedded instances for Rust tests. For teams using a standalone service, separate workers or uniquely named resources can keep tests from seeing another worker's data.

  1. Choose a reproducible test that calls one AWS service and writes synthetic data.
  2. Pin the emulator version and start a disposable instance or isolated local environment.
  3. Set test-only credentials and endpoint configuration. Check identity and readiness before writing.
  4. Run your expected behavior and one negative case. Save the inputs and observations for the assertions that failed.
  5. Keep a real AWS smoke test for deployed integration and IAM policy checks. Record why that test belongs there.

A coding agent can help iterate on the application within this loop. Give it the test endpoint and a small assertion instead of broadly provisioning cloud resources for a quick experiment. Require a failing test for the defect and a passing test after the repair. Use the same human review of test coverage and permissions you would use for any other change. The agent's ability to run the test quickly is useful because it can bring back a more specific result.

Track actual cloud resource use if cost is part of the business case. AWS charges no separate emulator service fee, and local CI still uses computing resources. Deployed AWS checks can still incur charges for the resources they use. The meaningful comparison is what the team spends to maintain reliable coverage over a release cycle. A local job that catches contract errors early, paired with a lean cloud gate, can reduce repeat deployments without weakening the release check.

The best split makes a failure easier to act on

If the local order fails to round-trip, the developer can start with the request and the app's repository code. If the cloud permission test fails, the owner can start with deployment configuration and policy. That is the value of giving the test loop two endpoints. Faster feedback earns its place when it also points to the right next change.

Sources


To keep integration decisions and test notes together in a searchable record, create a Telli.sh account.


← Back to Blog