LocalStack Just Killed Its Free Tier and I Almost Panicked — Then I Found Floci and Migrated 47 Tests in a Weekend

LocalStack Just Killed Its Free Tier and I Almost Panicked — Then I Found Floci

I got the email on a Monday morning. March 3rd, 2026. Coffee in hand, Slack already buzzing. "LocalStack Community Edition sunset notice." I read it three times because I genuinely could not believe what I was seeing.

Starting March 2026, LocalStack's community edition requires an auth token. CI/CD pipelines without a paid plan? Cut off. Security updates for the free tier? Frozen. The tool that half the AWS developer community relied on for local development just put up a velvet rope and hired a bouncer.

My immediate reaction was to check our CI pipeline. We had 47 integration tests that ran against LocalStack in GitHub Actions. Every pull request, every merge to main. Zero AWS costs for testing. It was beautiful. And it was about to break.

What Happened to LocalStack?

To be fair to LocalStack, they have been signaling this for a while. The community edition has been getting thinner with each release — features moving to Pro, API parity falling behind, documentation pointing you toward paid tiers. But the auth token requirement was the kill shot. You cannot run a free tool that requires phoning home to verify a license on every startup. That is not free. That is a trial with extra steps.

The blog post framed it as "focusing resources on the best possible experience." Translation: we need revenue and the free tier was not converting enough.

I get it. Open-source sustainability is genuinely hard. But the timing could not have been worse for the thousands of teams — including mine — who had LocalStack baked into their development workflows.

Enter Floci: 24 Milliseconds to Start, Zero Strings Attached

Floci appeared on Hacker News about two weeks after LocalStack's announcement, and it felt almost suspiciously well-timed. A free, open-source, MIT-licensed local AWS emulator that runs 20+ services with zero auth requirements. Built by someone who clearly saw the same email I did and thought "I can fix this."

The name comes from "floccus" — a cloud formation that looks like popcorn. The README says "Light, fluffy, and always free." I appreciate the commitment to a theme.

But cute branding aside, the numbers are what sold me:

Read that table again. Floci's free tier has features that LocalStack reserved for paid plans. Cognito emulation. RDS with IAM auth. API Gateway v2. ElastiCache with Redis. All free. All MIT-licensed.

Setting Up Floci: I Timed It at 47 Seconds

Here is the entire setup process:

# docker-compose.yml
services:
  floci:
    image: hectorvent/floci:latest
    ports:
      - "4566:4566"
    volumes:
      - ./data:/app/data

docker compose up

That is it. No environment variables. No license keys. No config files. The container pulls the ~90MB image, starts in under a second, and all services are available at http://localhost:4566.

For comparison, our LocalStack docker-compose.yml was 34 lines long with environment variables for feature flags, volume mounts for persistence, and a health check that waited 30 seconds for startup. I replaced all of it with five lines.

Pointing Your AWS SDK at Floci

Every AWS SDK supports endpoint overrides. Point it at localhost:4566 and use any credentials — Floci does not validate them (intentionally, for local dev).

# Environment variables (works with any SDK)
export AWS_ENDPOINT_URL=http://localhost:4566
export AWS_DEFAULT_REGION=us-east-1
export AWS_ACCESS_KEY_ID=test
export AWS_SECRET_ACCESS_KEY=test

# Test it
aws s3 mb s3://my-bucket
aws sqs create-queue --queue-name my-queue
aws dynamodb list-tables

Our Python services use boto3 with a wrapper that checks for a LOCAL_AWS environment variable. If set, it overrides the endpoint URL. Migrating from LocalStack to Floci required changing exactly zero lines of application code.

The 47 Integration Tests: A Migration Story

Here is where the rubber meets the road. I needed to migrate our CI pipeline — 47 integration tests that create S3 buckets, SQS queues, DynamoDB tables, and Lambda functions — from LocalStack to Floci over a weekend.

Friday night, 8 PM. I forked our CI workflow and swapped the LocalStack container for Floci. Ran the tests.

39 out of 47 passed on the first try.

The 8 failures broke down like this:

• 3 tests used LocalStack-specific API extensions (the /_localstack/ internal endpoints). These are not part of the AWS API and have no equivalent in Floci. I rewrote them to use standard AWS API calls. Took about 20 minutes.
• 2 tests relied on Lambda execution, which Floci handles differently. LocalStack spins up Docker containers for each Lambda invocation; Floci uses an embedded runtime that is faster but has subtle behavior differences with environment variables. I adjusted the assertions.
• 2 tests had timing issues — they used sleep-based waits that were calibrated for LocalStack's 3-second startup. Floci starts so fast that the tests tried to create resources before the container was fully initialized. Ironic. Added a simple health check poll instead.
• 1 test used S3 presigned URLs with a specific signature algorithm that Floci did not support yet. I opened a GitHub issue and the maintainer fixed it in 4 hours. On a Saturday. For a free tool. I nearly cried.

By Saturday afternoon, all 47 tests were green. Total migration effort: about 6 hours, and most of that was fixing our own tech debt, not Floci issues.

Performance in CI: The Numbers That Made My Manager Smile

Our GitHub Actions workflow used to take 8 minutes and 22 seconds on average. Most of that was LocalStack — pulling the 1GB Docker image and waiting for it to initialize.

With Floci:

That 42% CI time reduction translates directly to faster feedback loops and lower GitHub Actions bills. For our team of 8 developers averaging 5 PRs per day, we are saving roughly 14 hours of CI compute per month.

My manager, who usually glazes over when I mention infrastructure improvements, actually asked me to present this at the next team standup. That has never happened.

Floci vs LocalStack vs Moto vs ElasticMQ: The Full Landscape

*Floci also ships as a native binary (~40MB) that runs without Docker. I have not tested this extensively, but for quick local dev it eliminates the Docker dependency entirely.

The Elephant in the Room: Can You Trust a New Tool?

This is the fair question. LocalStack has been around since 2017. It has hundreds of contributors, enterprise customers, and battle-tested edge cases. Floci is weeks old.

Here is my honest assessment:

For development and testing: Floci is ready. The 408/408 SDK test pass rate is not a vanity metric — it means the S3, SQS, DynamoDB, and other core services behave like the real AWS APIs. If your tests pass against Floci, they will pass against AWS.

For staging environments: Wait. Floci does not yet support the long-tail of AWS services (Step Functions, EventBridge, AppSync). If your architecture depends on these, you are still in LocalStack Pro territory.

For production: No. But you should not be using any local emulator in production. That is what actual AWS is for.

My colleague Priya — she runs infrastructure at a Series B startup — tried Floci for their Terraform integration tests and reported back: "It caught the same S3 bucket policy bugs that LocalStack caught. And it is fast enough that our developers actually run the tests locally now instead of waiting for CI." That last part might be the biggest win — a fast emulator that developers actually use is infinitely more valuable than a comprehensive one they skip because it takes too long to start.

How I Set Up Our Dev Environment (Complete Guide)

For anyone making the switch, here is our complete setup:

1. Docker Compose (development)

services:
  floci:
    image: hectorvent/floci:latest
    ports:
      - "4566:4566"
    volumes:
      - floci-data:/app/data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4566/_floci/health"]
      interval: 5s
      timeout: 2s
      retries: 3

volumes:
  floci-data:

2. GitHub Actions (CI)

services:
  floci:
    image: hectorvent/floci:latest
    ports:
      - 4566:4566
    options: --health-cmd="curl -f http://localhost:4566/_floci/health" --health-interval=2s --health-timeout=1s --health-retries=5

3. Application config (Python/boto3)

import boto3
import os

def get_client(service):
    kwargs = {}
    if os.getenv("LOCAL_AWS"):
        kwargs["endpoint_url"] = "http://localhost:4566"
        kwargs["region_name"] = "us-east-1"
    return boto3.client(service, **kwargs)

That is the entire migration. Three files. If your application already supports endpoint overrides (and it should — that is standard practice for any AWS SDK integration), the switch is trivially simple.

What I Wish Floci Had (Feature Requests From the Trenches)

No tool is perfect, and Floci has gaps:

• Step Functions: We use these heavily for orchestration. Not supported yet.
• EventBridge: Critical for event-driven architectures. Missing.
• CloudFormation / CDK deploy: Would be amazing for testing IaC locally.
• Web dashboard: LocalStack Pro has a nice UI for inspecting resources. Floci is CLI-only.
• Persistence across restarts: The volume mount helps, but some state is lost on container restart.

I opened issues for all of these. The maintainer responded to each within hours, and two are already tagged for the next release. For a free, MIT-licensed project maintained by (as far as I can tell) one very motivated person, the responsiveness is remarkable.

The Bottom Line: Free Actually Means Free

Floci is not a LocalStack replacement for everyone. If you need 80+ AWS services, enterprise support, and a team dashboard, LocalStack Pro is still the answer — and it is worth the money.

But if you are in the much larger camp of developers who used LocalStack Community for S3, SQS, DynamoDB, Lambda, and a handful of other core services — and you just got blindsided by the auth token requirement — Floci is not just an alternative. It is arguably better. Faster startup. Smaller footprint. More features in the free tier. And a license that will never ask you to phone home.

I have been running Floci in development and CI for two weeks now. Zero issues. Zero costs. Zero anxiety about another "sunset notice" email.

And honestly? The 24-millisecond startup time alone is worth the migration.

Get Floci: github.com/hectorvent/floci — MIT licensed, free forever.

Requirements: Docker (or native binary for macOS/Linux), ~90MB disk space, any AWS SDK.