--- title: Two Free LocalStack Alternatives in 2026: MiniStack vs floci description: LocalStack paid tiers pushed free emulators forward. July 2026: MiniStack (~60+ services, real Postgres/Redis) vs floci (ms startup). Pick by CI speed vs DB fidelity. url: https://www.joinhorizon.co/blog/ministack-free-localstack-alternative-aws-emulator/ datePublished: 2026-04-10T00:00:00.000Z dateModified: 2026-10-28T00:00:00.000Z author: manojkumar-varatharajan category: DevOps & CI/CD tags: localstack, ministack, floci, aws-emulator, developer-tools, local-development, devops --- # Two Free LocalStack Alternatives in 2026: MiniStack vs floci > LocalStack paid tiers pushed free emulators forward. July 2026: MiniStack (~60+ services, real Postgres/Redis) vs floci (ms startup). Pick by CI speed vs DB fidelity. When LocalStack moved more core services behind paid tiers, teams that relied on free local S3/SQS/Lambda/RDS mocks had to pay, mock thinner, or switch. As of **July 2026**, two MIT-licensed contenders still matter: **MiniStack** (real DB/containers, broader surface, **60+** services advertised, actively releasing) and **floci** (Go binary, ms startup, tiny RAM for CI). **First-party benchmark (project-advertised, re-verify):** MiniStack ~**2s** start / ~**30MB** idle vs floci ~**24ms** / ~**13 MiB**. Pick by whether your suite needs real Postgres isolation or fast spin-up at density. **Reproduce this:** [Emulator choice matrix](https://www.joinhorizon.co/examples/architecture-blog-2026/ministack-local-aws/emulator-choice-matrix.md) · [ministack.org](https://ministack.org/) / GitHub `ministackorg/ministack` (pin image digests in CI). ## What is MiniStack? MiniStack is a free, MIT-licensed AWS emulator on port **4566**. It needs no account, API key, or telemetry. Install it with Docker or pip, then point the AWS CLI/SDKs at `http://localhost:4566`. **Key facts:** - **Language:** Python 3.12+ - **Install:** Docker, PyPI, or docker-compose - **License:** MIT (completely free, no commercial restrictions) - **Launch date:** April 2026 - **Community:** Actively maintained; re-check GitHub stars/releases before standardizing - **Services:** 60+ AWS services advertised (mid-2026) across compute, storage, databases, messaging, security. Verify the release you pin The project exists because LocalStack's free tier no longer exists. Nahuel Nucera and Johannes Grumböck built MiniStack as a direct answer to that gap. ## Real infrastructure instead of mocks ![Architecture diagram of an SDK calling MiniStack locally, which runs a real database](../../assets/images/blog/ministack-free-localstack-alternative-aws-emulator-local.webp) _Figure: MiniStack in the article. The SDK changes only the endpoint. Postgres and Redis run as real containers, not stubs. The sample bucket name and test keys are not shown. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/ministack-free-localstack-alternative-aws-emulator/local.drawio)._ Most AWS emulators mock the services. MiniStack spins up real containers. When you request RDS in MiniStack, it does not pretend to be a PostgreSQL database. It launches a real PostgreSQL container and runs your SQL against it. Same for Redis (ElastiCache), Docker (ECS), and SQL queries (Athena via DuckDB). Because of this, your local tests are more faithful to production. Compare this to traditional mocks: - Mocks catch schema errors and API signature mistakes but miss database-specific behavior, transaction edge cases, and performance surprises. - Real infrastructure forces you to confront the same constraints your production code faces: connection pooling, query planning, concurrency limits. For teams with database-heavy applications, this reduces the cases where tests pass locally but fail in production. ## AWS services MiniStack supports | Category | Services | | ------------------ | -------------------------------------------------- | | **Storage** | S3, EBS, EFS, S3 Object Lock | | **Compute** | Lambda, EC2, ECS, EMR | | **Databases** | RDS (PostgreSQL/MySQL), DynamoDB, DynamoDB Streams | | **Caching** | ElastiCache (Redis) | | **Messaging** | SQS (FIFO + DLQ), SNS, Kinesis, EventBridge | | **Workflows** | Step Functions (full ASL interpreter) | | **APIs** | API Gateway v1/v2, AppSync | | **Analytics** | Athena (DuckDB-backed), Glue, Firehose | | **Security** | IAM, KMS, ACM, WAF v2, Secrets Manager, STS | | **Networking** | Route53, CloudFront, ALB/ELBv2 | | **Identity** | Cognito | | **Infrastructure** | CloudFormation, CloudWatch Logs/Metrics, SSM | | **Email** | SES, SESv2 | For Lambda, MiniStack maintains warm worker pools for Python and Node.js, and uses Docker Runtime Interface (RIE) emulation for Go and Rust binaries. Your Lambda tests execute real code, not stubs. ## Quick Start **Installation:** three options. ```bash # Via pip pip install ministack && ministack # Via Docker docker run -p 4566:4566 ministackorg/ministack # pin a version/digest in CI — tags move; confirm on ministack.org / GitHub # Via docker-compose git clone https://github.com/Nahuel990/ministack.git cd ministack docker compose up -d ``` **Verify:** Check the health endpoint. ```bash curl http://localhost:4566/_ministack/health ``` **Use:** Point your AWS SDK to the local endpoint. Example with AWS CLI: ```bash aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket aws --endpoint-url=http://localhost:4566 s3 ls ``` With Terraform: ```hcl provider "aws" { region = "us-east-1" access_key = "test" secret_key = "test" endpoints { s3 = "http://localhost:4566" rds = "http://localhost:4566" } } ``` With Python boto3: ```python import boto3 s3 = boto3.client( 's3', endpoint_url='http://localhost:4566', aws_access_key_id='test', aws_secret_access_key='test', ) s3.create_bucket(Bucket='my-bucket') ``` The endpoint swap is the only required change. All existing code paths work unchanged. ## Performance comparison How both free alternatives compare with LocalStack and each other: | Metric | LocalStack Free | LocalStack Pro | MiniStack | floci | | ------------------------------------ | ---------------------- | -------------- | -------------- | ------------------ | | **Price** | Now paid | $35+/month | Free forever | Free forever | | **License** | BSL | Proprietary | MIT | MIT | | **Startup time** | 15–30s | 15–30s | ~2s | **~24ms** | | **Memory (idle)** | ~500MB | ~500MB | ~30MB | **~13 MiB** | | **Image size** | ~1GB | ~1GB | ~250MB | **~90MB** | | **Auth required** | Yes (since March 2026) | Yes | No | No | | **RDS/ElastiCache/ECS** | Paid only | Included | Included, free | Included, free | | **EC2, EMR, EBS, EFS** | Paid only | Included | Included, free | Included, free | | **Core services** (S3, Lambda, etc.) | Paid | Included | Included | Included | | **Test coverage** | — | — | 900+ tests | **1,850+ tests** | | **Runtime** | Python/JVM | Python/JVM | Python | Go (native binary) | Both free alternatives boot faster, use less RAM, and include paid-only services at zero cost. floci's 24ms startup and 13 MiB footprint suit parallel CI; MiniStack's 2-second boot and real Postgres/Redis containers suit database-heavy test suites. Both are actively maintained and have large test suites. ## Use cases **Local development loops.** Developers run MiniStack once (`docker run`) and test S3 uploads, Lambda invocations, and DynamoDB queries without touching AWS, with no cloud costs. **CI/CD integration.** MiniStack's 2-second startup suits test pipelines. Spin up before tests, reset state, tear down after. With `POST /_ministack/reset`, you can nuke all state between test runs without restarting the container. **Terraform and CDK testing.** Write infrastructure as code, validate it locally against MiniStack before applying to staging or prod. Works with all major IaC frameworks (Terraform, AWS CDK, Pulumi, CloudFormation). **Integration testing with real databases.** Because MiniStack runs actual Postgres and Redis, you can test connection pooling, transaction isolation, and caching behavior that mocks would hide. **Multi-tenant isolation testing.** MiniStack's IAM support allows you to test cross-account access patterns locally. Create separate Access Key IDs to simulate tenant isolation. ## Limitations **Scope.** With 38 services, MiniStack covers the "80% of use cases". But if your code relies on niche services (e.g., AWS Timestream, AWS IoT Core, AWS Glue Catalog subtleties), you may hit unimplemented features. **Small team.** MiniStack is maintained by two developers, and the maintenance burden grows as AWS adds services and changes APIs. GitHub issue #221 flags "CODE FREEZE DUE MIGRATION," which suggests the team is mid-architecture refactor. Monitor the project's activity rate. **Early stage.** With 900+ tests and solid core coverage, MiniStack is stable for local dev and CI, but it has not reached the maturity of LocalStack Pro's multi-year refinement. Edge cases and lesser-used service parameters may differ from real AWS behavior. **No paid support tier.** If something breaks, you rely on community issues and the maintainers' goodwill. For mission-critical CI, LocalStack Pro's commercial support may be worth the cost. ## Should you switch? **Yes, if you:** - Are frustrated by LocalStack's paywall and need RDS, ElastiCache, or ECS locally - Want faster test cycles (2-second startup vs. 30 seconds saves time in CI) - Are testing database-heavy applications and want real Postgres/MySQL, not mocks - Have simple, common AWS service use cases (S3, Lambda, DynamoDB, SQS, etc.) - Are using Terraform, CDK, or Pulumi and need a free validation environment **No, if you:** - Are already paying for LocalStack Pro and have a stable CI pipeline (switching has opportunity cost) - Rely heavily on AWS service features that MiniStack does not yet implement - Need commercial support contracts for your local AWS emulation (niche, but important for some organizations) - Are testing very new or niche AWS services that MiniStack has not added yet For most teams, the free tier plus real infrastructure makes MiniStack worth trying. If it covers your services, you get the performance and cost gains. --- ## The other contender: floci MiniStack is not alone. **floci** emerged from the same frustration: LocalStack's March 2026 community edition sunset forced developers to choose between paying or finding an alternative. But floci took a different engineering path. Where MiniStack opts for real infrastructure containers (Postgres, Redis) with ~2-second startup, floci separates stateless services into lightweight in-process handlers and reserves real containers for database/cache services. The result is **24-millisecond startup, 13 MiB RAM at idle, and 1,850+ automated compatibility tests** across Java, Python, Node.js, Go, Rust, AWS CLI, Terraform, OpenTofu, and AWS CDK. If raw speed and small footprint are your priority, floci is worth exploring. ## What is floci? floci is a free, MIT-licensed AWS emulator written in Go. It runs on port 4566 (same as LocalStack) and requires no account, API key, or telemetry. **Key facts:** - **Language:** Go (native binary) - **Install:** Docker Compose (`docker compose up`) or Docker image - **License:** MIT (completely free, no commercial restrictions) - **Launch:** March 2026 (same window as LocalStack's community edition sunset) - **Community:** 3,100+ GitHub stars, actively maintained - **Tests:** 1,850+ automated compatibility tests across 6 SDK languages and 3 IaC tools - **Maturity:** Early-stage; the test matrix is large ## Architecture: stateless in-process, stateful real containers ![Architecture diagram of floci serving stateless APIs in process and starting a container for a database](../../assets/images/blog/ministack-free-localstack-alternative-aws-emulator-floci.webp) _Figure: floci in the article. SQS, S3, and IAM stay in the process. Lambda, RDS, and ECS start a container when a test asks for them. The sample port is not shown. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/ministack-free-localstack-alternative-aws-emulator/floci.drawio)._ floci's speed comes from splitting services by state: **In-process stateless services** (SSM, SQS, SNS, IAM, STS, KMS, Secrets Manager, SES, Cognito, Kinesis, OpenSearch, EventBridge, Step Functions, CloudFormation, ACM, API Gateway v1/v2, AppConfig, CloudWatch Logs/Metrics) run as lightweight handlers inside the floci binary. No Docker overhead. **In-process stateful services** (S3 with versioning and Object Lock, DynamoDB with streams and transactions) use in-memory or persistent state, with no Docker startup cost. **Real container services** (Lambda, ElastiCache (Redis/Valkey with IAM auth), RDS (PostgreSQL/MySQL), ECS, and EC2 with VPCs) spin up actual Docker containers when needed, with the same fidelity as MiniStack, but only when you request them. That split explains the 24ms startup: the port opens and requests route immediately, and stateful services boot on demand. Compare this to MiniStack, which always spins up Postgres and Redis containers (hence ~2 seconds), or LocalStack, which runs a full JVM and legacy Python codebase (15 to 30 seconds). ## Quick Start ```yaml services: floci: image: hectorvent/floci:latest ports: - '4566:4566' ``` Save this as `docker-compose.yml`, then: ```bash docker compose up ``` Point your AWS SDK to `http://localhost:4566` with dummy credentials (no real AWS account needed): ```bash aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket ``` With Terraform: ```hcl provider "aws" { region = "us-east-1" access_key = "test" secret_key = "test" endpoints { s3 = "http://localhost:4566" rds = "http://localhost:4566" dynamodb = "http://localhost:4566" } } ``` With Python: ```python import boto3 s3 = boto3.client( 's3', endpoint_url='http://localhost:4566', aws_access_key_id='test', aws_secret_access_key='test', ) s3.create_bucket(Bucket='my-bucket') ``` The endpoint swap is the only required change. ## Storage and state management floci supports multiple storage modes (memory, persistent, hybrid, and WAL), configurable per service via `FLOCI_*` environment variables. This helps if you need state to persist across container restarts (e.g., DynamoDB data surviving a redeploy during test runs). Example with persistent S3: ```yaml services: floci: image: hectorvent/floci:latest ports: - '4566:4566' environment: FLOCI_S3_STORAGE: persistent FLOCI_DYNAMODB_STORAGE: memory ``` ## MiniStack vs floci: which one fits Both are free, MIT-licensed, and work with all major AWS SDKs and IaC tools. The decision comes down to your priorities. **Choose floci if you:** - **Need the fastest startup.** 24ms vs. 2 seconds matters in highly parallel CI pipelines (e.g., running 100 test containers concurrently). - **Are in a resource-constrained environment.** 13 MiB idle RAM vs. 30 MB matters for ephemeral test containers or local development on laptops with limited memory. - **Want a broader compatibility test matrix.** floci has 1,850+ automated tests across Java, Node.js, Python, Go, Rust, AWS CLI, Terraform, OpenTofu, and AWS CDK. MiniStack has 900+ tests; floci's matrix covers more SDK variants. - **Need S3 Object Lock with COMPLIANCE and GOVERNANCE modes.** floci ships with full Object Lock support; MiniStack has it, but it's worth verifying for your use case. - **Are using Go, Rust, or polyglot teams.** floci's native binary suggests good Go/Rust support. **Choose MiniStack if you:** - **Want the widest service breadth.** Service counts move quickly. MiniStack advertises 60+ mid-2026; verify AppSync/Athena/Glue coverage for your pin. - **Prefer pip install over Docker Compose.** `pip install ministack && ministack` is faster to trial than Docker setup if you're already in a Python environment. - **Are already running Python tooling.** If your test infrastructure is Python-centric, MiniStack's closer integration may reduce friction. - **Want real Postgres/MySQL/Redis always available without on-demand startup.** MiniStack's "always-on" containers simplify testing of connection pooling and persistence behavior. When in doubt, try floci first. Its 24ms startup and 13 MiB footprint mean there is almost no cost to spin it up locally and see if it covers your service requirements. If it doesn't, try MiniStack. ## Summary of the trade-offs LocalStack's move to paid tiers left a gap, and two projects have filled it. **MiniStack** and **floci** take different engineering approaches: - **MiniStack:** Real infrastructure everywhere. Postgres, Redis, and Docker containers boot with every launch. Startup is slower (~2s) and memory higher, but fidelity to production is higher. - **floci:** Stateless services in-process, stateful containers on demand. Startup is ~24ms, the footprint is tiny, and it ships as a native binary with 1,850+ compatibility tests. With two free, MIT-licensed alternatives, you now have a real trade-off to make: startup speed or breadth of services, database-heavy code or lightweight CI. Both projects have large test suites and active maintenance. Re-check GitHub before you standardize org-wide. **Our recommendation:** - **For CI/CD pipelines:** Start with **floci**. Its 24ms startup suits parallel test runs, and it has 1,850+ compatibility tests. - **For local development with database-heavy code:** Use **MiniStack**. The always-on Postgres and Redis containers mean you're testing real transaction isolation, connection pooling, and concurrency behavior from day one. - **If you hit a wall with either:** Try the other. The setup cost is low (30 minutes max). ## What this post doesn't cover LocalStack Pro feature parity matrices and every floci release cadence. Re-check GitHub before standardizing org-wide CI. ## What to do Monday morning 1. List which AWS APIs your integration tests actually call. 2. Trial floci for CI speed; MiniStack if you need real Postgres/Redis/ECS. 3. Pin an image digest; never float `:latest` in prod pipelines. 4. Walk the [emulator matrix](https://www.joinhorizon.co/examples/architecture-blog-2026/ministack-local-aws/emulator-choice-matrix.md). 5. Keep a thin suite against real AWS for IAM/auth edge cases emulators miss. 6. [Contact](https://www.joinhorizon.co/contact-us/) if you need a CI/emulator standard for a multi-team platform. ## FAQ ### Is MiniStack completely free? Yes. MiniStack is MIT-licensed with no paid tiers, no API keys, and no telemetry. ### Does MiniStack support RDS and ElastiCache? Yes. MiniStack spins up real PostgreSQL, MySQL, and Redis containers for RDS and ElastiCache, unlike LocalStack Free which moved these services to its paid tier. ### How does MiniStack compare to LocalStack in performance? MiniStack starts in ~2 seconds vs. 15 to 30 seconds for LocalStack, and uses ~30MB RAM at idle vs. ~500MB. ### Can I use MiniStack with Terraform, CDK, or Pulumi? Yes. MiniStack is endpoint-compatible with all major AWS SDKs and IaC tools. You only need to override the endpoint URL to http://localhost:4566. ### Is MiniStack production-ready? MiniStack is stable for local development and CI/CD pipelines. It has 900+ tests and is actively maintained, but it is still a young project, so verify your specific service requirements before migrating from LocalStack. ### Is floci completely free? Yes. floci is MIT-licensed with no account, API key, or feature gates. No authentication or telemetry. ### How does floci compare to MiniStack? floci optimizes for ms-class startup and tiny RAM; MiniStack optimizes for real Postgres/MySQL/Redis/ECS containers and broader service coverage (advertised 60+ services as of mid-2026; verify release notes). Both are MIT-licensed. Choose floci for speed-critical CI; MiniStack when tests need real DB semantics. --- *Source: https://www.joinhorizon.co/blog/ministack-free-localstack-alternative-aws-emulator/*