Local AWS was always the annoying part
I've been building on AWS for years, and local development has always been the part I dreaded. LocalStack was the default answer, but it came with its own problems: slow startup, fiddly configuration, a lot of memory, and constant tweaking before things actually worked. Every time I brought up a local environment I knew I was in for a few minutes of waiting and a bit of hoping.
Then, in March 2026, two things happened. LocalStack archived its community edition and went fully paid, and a project called Floci launched.
I tried Floci, changed one line in my Docker setup, and it just worked. 24ms startup, 13 MiB of memory, 51 AWS services, no cost, no auth token, MIT license. My local workflow got dramatically faster, mostly because the waiting disappeared.
This post is about why I think Floci is more than a LocalStack replacement: Terraform, architecture design, learning AWS, testing, and also where it still falls short.
What happened with LocalStack
On March 23, 2026, LocalStack changed its model. The community edition was archived, auth tokens became mandatory for everyone, security updates stopped for the free tier and many services became paid-only.
A lot of CI pipelines broke overnight, and teams that had built their whole local workflow around LocalStack had to choose between migrating and paying. For reference, LocalStack Pro costs around $50 to $100+ per developer per month. For a team of ten, that's $6,000 to $12,000 a year just to test AWS locally.
The community's answer was Floci.
What Floci is
Floci (named after floccus, the cloud formation that looks like popcorn) is a free, open-source AWS emulator built with Quarkus Native and GraalVM. Its own pitch: "Light, fluffy, and always free. No account. No auth token. No feature gates. Just docker compose up."
The numbers it publishes:
- 24ms to start, against roughly 3,300ms for LocalStack
- 13 MiB of memory at idle, against 143 MiB
- 51 AWS services, several of them never available in LocalStack Community
- MIT license, so there's no community edition to sunset
- drop-in replacement: same port (4566), same protocols
And every service is unlocked. No paid tier, no enterprise features, no tokens.
Why it changed my workflow
Speed you actually notice
# LocalStack Community
docker run localstack/localstack
# ~3,300ms until ready
# Floci
docker run floci/floci:latest
# ~24ms until ready
That's about 138 times faster to start. In CI it adds up: if your tests bring up the emulator 50 times a day, that's around 2.7 minutes saved every day, and hours over a month. Using about 91% less memory also means smaller (cheaper) runners and more containers on the same machine.
Real engines behind the complex services
This is the part I like most. For the heavy services, Floci runs real engines in Docker instead of shallow mocks:
- Lambda: the real AWS runtimes, in containers
- RDS: real PostgreSQL, MySQL and MariaDB
- ElastiCache: real Redis/Valkey
- MSK: Kafka, through Redpanda
- EKS: Kubernetes, through k3s
- OpenSearch: real OpenSearch clusters
So you're testing against the protocols and behavior your code will meet in production, not against an approximation of them.
IAM that actually checks things
Floci implements real IAM authentication and SigV4 validation for Lambda, ElastiCache, RDS, ECS, EC2, MSK, EKS, OpenSearch, ECR and CodeBuild. Your policies and auth flows behave locally the way they will in AWS, which kills a whole class of "works locally, fails in AWS because of IAM" bugs.
Terraform, entirely on your laptop
For infrastructure work this is where it really pays off. Point the AWS provider at Floci:
provider "aws" {
region = "us-east-1"
access_key = "test"
secret_key = "test"
skip_credentials_validation = true
skip_metadata_api_check = true
skip_requesting_account_id = true
endpoints {
s3 = "http://localhost:4566"
dynamodb = "http://localhost:4566"
lambda = "http://localhost:4566"
# ...one line per service you use
}
}
Then work as usual:
docker run -d -p 4566:4566 \
-v /var/run/docker.sock:/var/run/docker.sock \
floci/floci:latest
terraform init
terraform apply
Your S3 buckets, Lambda functions, DynamoDB tables and SQS queues run on your laptop. Iterating is terraform destroy and terraform apply again, with no cloud bill, no waiting for resources and nothing to clean up. When you're confident, you point the provider back at AWS. Same code, same resources.
Designing architecture without risk
What Floci really unlocks is experimenting without consequences.
Learning AWS. The classic path is reading the docs, deploying to AWS, getting surprised by the bill and deleting everything in a panic. With Floci you bring up whatever service you want, break things and learn by doing, for free. For beginners that's a big deal.
Prototyping. You can build two or three versions of an architecture in parallel on your laptop, compare them and decide with data. It costs nothing and takes hours instead of days.
Replicating big environments. If production has 15 microservices, 8 databases and 12 Lambda functions, a full copy in AWS for testing can cost hundreds of dollars a month. Locally, it's docker compose up and terraform apply, and a few minutes later the whole thing is running.
Compared with LocalStack
It's free, and stays free. LocalStack Community is frozen and Pro is paid. Floci is MIT.
It's faster and lighter. 138x faster startup and 13 MiB against 143 MiB are measurable, and your CI will feel both.
It has more services for free: ElastiCache, RDS, API Gateway v2 with WebSocket, Route53, Auto Scaling, Textract, Neptune, EKS and CodeBuild, none of which LocalStack Community offered.
It leans on real engines for the heavy services, which matters when you test realistic workloads.
No tokens. Pull the image and run it. No sign-up, no API keys, no telemetry.
Where it falls short
It's not perfect, and it's worth saying:
- It's young. LocalStack has been around since 2017, Floci since March 2026. Some edge cases won't be covered yet.
- The community is smaller. Fewer Stack Overflow answers and tutorials, so you'll read the docs more.
- It's not 100% AWS. No emulator is. Some quirks of the real thing won't be reproduced exactly.
- It needs the Docker socket for the container-backed services (
/var/run/docker.sock), which is a security concern in some environments.
For me these are small compared to what you get, and the project is moving fast: more than 10,000 GitHub stars in two months.
What this makes possible
A few things I'd love to see become normal:
- One-command dev environments. Clone the repo, run
make dev-env, and every AWS service, database, queue and function is up in about 30 seconds. - AI-assisted architecture. Tools that generate Terraform, test it against Floci, tune it based on what they see locally and only then deploy.
- Training sandboxes. Real AWS services for onboarding new hires or preparing certifications, with no risk of a surprise bill.
- Full environments per pull request. Bring up the whole stack, run integration tests, validate infra changes and tear it down, with no cloud cost and as much parallelism as your runners allow.
Getting started
docker run -d --name floci \
-p 4566:4566 \
-v /var/run/docker.sock:/var/run/docker.sock \
floci/floci:latest
aws --endpoint-url http://localhost:4566 s3 mb s3://test-bucket
aws --endpoint-url http://localhost:4566 s3 ls
Or with Docker Compose:
services:
floci:
image: floci/floci:latest
ports:
- "4566:4566"
volumes:
- /var/run/docker.sock:/var/run/docker.sock
environment:
- FLOCI_STORAGE_MODE=hybrid
Bonus: Azure too
The same team built Floci-AZ, the same idea for Azure: Blob Storage, Queue Storage, Table Storage and Azure Functions, on port 4577, MIT licensed and without an Azure account.
docker run --rm -p 4577:4577 \
-v /var/run/docker.sock:/var/run/docker.sock \
floci/floci-az:latest
If you work across AWS and Azure, you can run both emulators side by side and test cross-cloud setups locally, without vendor lock-in or cloud bills.
Why this matters to me
Floci is more than a LocalStack alternative. It's a statement that local AWS development should be free, fast and available to everyone. When LocalStack went paid, the community built Floci, the same way Terraform's move to the BSL license gave us OpenTofu. Open source tends to find a way.
Day to day, it changed how I work: I design architectures locally first, test infrastructure changes without fear, learn new AWS services for free and bring up complex environments in minutes.
If you're still on the frozen LocalStack Community, paying for Pro, or skipping local AWS testing altogether, give it a try. It's one line of config.
Resources: Floci website · GitHub · Documentation · Migrating from LocalStack
What did you think?
Found this article helpful? Share it!
Help others discover this content by sharing it on your favorite platform.



