Why We Built JaisCloud — A Free, Single-Binary AWS Emulator in Go

If you've ever tried to test AWS-dependent code locally, you've probably reached for LocalStack. It works but it comes with baggage like Python runtime, Docker dependency, and the features most teams actually need locked behind a Pro subscription.

JaisCloud is our answer to that problem.

What is JaisCloud?

JaisCloud is a free, open-source local AWS cloud emulator written entirely in Go. It implements the exact AWS wire protocols — Query/XML, JSON/Target, REST — so your existing SDK code points at JaisCloud and works unmodified. No shims, no proxy rewrites, no SDK patches.

# Start it
jaiscloud-aws start

# Point your SDK at it
export AWS_ENDPOINT_URL=http://localhost:4566
export AWS_ACCESS_KEY_ID=test
export AWS_SECRET_ACCESS_KEY=test
export AWS_REGION=us-east-1

# Your existing code works — no changes needed
aws s3 mb s3://my-bucket
aws sqs create-queue --queue-name my-queue

Key Features

Single Static Binary

JaisCloud ships as a single Go binary per cloud. No Python, no Docker, no Node. Just download and run. Works on laptop, CI runner, or Kubernetes pod.

# Download and run — that is it
./jaiscloud-aws start

# Or with Docker
docker run --rm -p 4566:4566 rjaisval/jaiscloud-aws:latest

Portable State Snapshots

Export the complete emulator state — every resource, every account, every region to a single gzip tarball and restore it anywhere in milliseconds.

# Capture a baseline
jaiscloud-aws export -o baseline.tar.gz

# Restore on a teammate's machine or CI runner
jaiscloud-aws import -i baseline.tar.gz

# Named snapshots for test isolation
jaiscloud-aws snapshot create --name before-migration
# ... run tests ...
jaiscloud-aws snapshot revert before-migration

This changes how teams share environments. Instead of per-developer setup scripts that take minutes, share a tarball that restores in under a second.

Deterministic Time Control

This is the feature that has no equivalent in any other AWS emulator.

JaisCloud lets you freeze the clock at any instant and advance it on demand. Testing a 5-minute SQS delay queue? No need to wait 5 minutes.

# Freeze the clock
curl -X POST http://localhost:4566/_jaiscloud/clock \
  -d '{"mode":"fixed","time":"2024-06-01T09:00:00Z"}'

# Advance to trigger time-based behaviour
curl -X POST http://localhost:4566/_jaiscloud/clock \
  -d '{"mode":"fixed","time":"2024-06-01T09:06:00Z"}'

# Reset to wall time
curl -X POST http://localhost:4566/_jaiscloud/clock \
  -d '{"mode":"real"}'

This unlocks deterministic testing for:

• SQS delay queues — advance clock instead of waiting
• DynamoDB TTL expiry — trigger expiry on demand
• EventBridge cron rules — replay the exact scheduled moment repeatedly
• STS/SecretsManager token expiry — test expiry without waiting
• CloudWatch alarm windows — advance into the evaluation window instantly

Real Spark / EMR Execution

Most emulators fake compute — they accept the API call and immediately return COMPLETED. JaisCloud actually runs the Spark job, in Docker or on Kubernetes.

# Docker executor — runs real Spark jobs in containers
JAISCLOUD_EXECUTOR_MODE=docker ./jaiscloud-aws start

# Kubernetes executor — runs jobs as real K8s batch jobs
JAISCLOUD_EXECUTOR_MODE=k8s ./jaiscloud-aws start

Kubernetes-Native

JaisCloud runs natively as a Kubernetes pod. Lambda functions execute as real K8s pods. EMR steps run as batch/v1 Jobs. No special configuration needed, it uses the in-cluster service account.

JaisCloud in AI-Driven SDLC

AI coding agents — Claude, Copilot, Cursor, and others — are now writing, reviewing, and deploying cloud-dependent code, but giving them a safe, fast, and realistic cloud environment to develop and test against without touching real AWS has been an unsolved problem. JaisCloud is the answer.

AI Agents Need a Local Cloud

When an AI agent writes a Lambda function, creates an SQS queue, or sets up a DynamoDB table, it needs somewhere to run and verify that code immediately.

Real AWS introduces:

• Latency — round trips to AWS slow the agent's iteration loop
• Cost — every test run consumes real AWS resources
• Risk — a misconfigured IAM policy or an accidental S3 bucket deletion has real consequences
• State pollution — test resources left behind in shared AWS accounts

JaisCloud gives AI agents a fully isolated, local AWS environment that starts in milliseconds, costs nothing, and can be wiped and reset between runs.

Snapshot-Based Agent Context

One of the most powerful patterns for AI-driven development is using JaisCloud snapshots as agent context. Before handing a task to an AI agent:

# Create a snapshot of the exact environment state the agent should work against
jaiscloud-aws snapshot create --name agent-task-baseline

# Agent runs, creates resources, tests code
# ...

# If the agent's changes are wrong, revert and retry
jaiscloud-aws snapshot revert agent-task-baseline

The agent gets a deterministic, reproducible environment every time.
No shared state, no cross-contamination between agent runs.

Deterministic Testing for AI-Generated Code

AI-generated code often involves time-dependent logic — TTL expiry, scheduled jobs, token rotation, delay queues. JaisCloud's time-freeze feature lets agents test this logic without wall-clock delays:

# Agent generates code that processes expired DynamoDB records
# Freeze clock, create records, advance past TTL, verify behaviour
curl -X POST http://localhost:4566/_jaiscloud/clock \
  -d '{"mode":"fixed","time":"2024-01-01T00:00:00Z"}'

# Create records with TTL
# ...

# Advance past TTL — no waiting
curl -X POST http://localhost:4566/_jaiscloud/clock \
  -d '{"mode":"fixed","time":"2024-01-02T00:00:00Z"}'

# Trigger TTL sweep and verify

An AI agent can iterate through dozens of time-dependent test scenarios in seconds that would otherwise take hours of wall-clock time.

CI Pipeline for AI-Generated Pull Requests

When AI agents submit pull requests, your CI pipeline needs to validate cloud-dependent code quickly and cheaply. JaisCloud fits naturally into this loop:

# .github/workflows/ai-pr-validation.yml
- name: Start JaisCloud
  run: |
    docker run -d -p 4566:4566 rjaisval/jaiscloud-aws:latest

- name: Import baseline state
  run: jaiscloud-aws import -i ci-baseline.tar.gz

- name: Run tests against JaisCloud
  run: go test ./...
  env:
    AWS_ENDPOINT_URL: http://localhost:4566

No real AWS credentials needed in CI. No cost per PR. No shared state between parallel runs. Every agent-generated PR gets a clean, identical cloud environment to validate against.

The Full AI SDLC Loop

AI Agent writes code
      |
      v
JaisCloud provides local AWS environment
      |
      v
Agent tests and iterates against JaisCloud
      |
      v
Snapshot captures validated state
      |
      v
CI imports snapshot, runs full test suite
      |
      v
PR merged — real AWS only touched in production

JaisCloud makes the entire inner loop from AI code generation to PR validation — fast, free, and safe. Real AWS stays out of the picture until code is production-ready.

Supported AWS Services

SQS, SNS, DynamoDB (+ Streams), S3, Lambda, EMR on EC2, EMR on EKS,
Glue (Data Catalog + Apache Iceberg), EventBridge, CloudWatch (metrics + alarms + logs), KMS, SecretsManager, SSM, IAM, STS, CloudFormation, API Gateway, EC2, ECS, EKS, RDS, ElastiCache, Route53, Kinesis, Cognito, ACM, SES, Firehose, Redshift

Getting Started

Docker (quickest):

docker run --rm -p 4566:4566 rjaisval/jaiscloud-aws:latest

Binary:

# macOS
brew tap jaisrajms/homebrew-tap
brew install --cask jaiscloud-aws

# Linux
curl -sSL https://github.com/jaisrajms/jaiscloud/releases/latest/download/jaiscloud-aws_linux_amd64.tar.gz | tar xz
./jaiscloud-aws start

Default storage — state saved to ~/.jaiscloud/ and survives restarts.

Ephemeral mode (clean slate, ideal for CI):

jaiscloud-aws start --ephemeral

Postgres backend (durable, for teams):

jaiscloud-aws start --dsn "postgres://user:pass@localhost:5432/jaiscloud"

What is Next

JaisCloud is in early alpha (v0.1.0-alpha.1). Core AWS services are working and tested. On the roadmap:

• GCP emulator (jaiscloud-gcp)
• Azure emulator (jaiscloud-azure)
• Step Functions improvements
• Web UI for resource inspection
• More CloudFormation intrinsic functions

Try It

GitHub: https://github.com/jaisrajms/jaiscloud
Website: https://jaiscloud.com
Docker: docker pull rjaisval/jaiscloud-aws:latest

JaisCloud is Apache-2.0 licensed — free forever, no Pro tier, no usage limits.

If you have hit walls with LocalStack Community or just want a Go-native cloud emulator that runs anywhere as a single binary, give JaisCloud a try.

Feedback and contributions are very welcome.

Star the repo if JaisCloud looks useful — it helps others find it.