Skip to main content
    listerineh.dev
    • About
    • Experience
    • Projects
    • Skills
    • Blog
    • Talks
    • Contact
    • Why
    • About
    • Experience
    • Projects
    • Skills
    • Blog
    • Talks
    • Contact
    • Why

    © 2026 Sebastian Alvarez

    Back to Blog

    Floci: The AWS Local Emulator That Starts in 24ms and Costs $0

    When LocalStack went paid I tried Floci, a free, MIT-licensed AWS emulator. It starts in 24ms and runs real engines. How I use it with Terraform, and where it still falls short.

    Sebastian Alvarez

    May 21, 2026·8 min read·
    Loading...
    • AWS
    • Floci
    • LocalStack
    • Docker
    • Terraform
    • IaC
    • DevOps
    • Local Development
    Floci: The AWS Local Emulator That Starts in 24ms and Costs $0
    Table of Contents

    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?

    Loading reactions...

    Found this article helpful? Share it!

    Help others discover this content by sharing it on your favorite platform.

    Previous articleAI and Security: The Same Tool on Both SidesNext articleYour Portfolio Speaks Before You Do: Design Language and Design Systems

    Keep reading

    More Articles
    • January 14, 2026 · 8 min read

      Terraform: Scaling Infrastructure Without Breaking the Bank

      How I run dev, staging and prod from one Terraform codebase, size each environment for what it actually needs, and grow infrastructure only when the product does.

    • September 1, 2025 · 6 min read

      Let's Talk Microservices: Lessons Learned in the Real World

      I have split monoliths into microservices and merged microservices back into a monolith. Using a bank as the example: when they pay off, when they don't, and what to get right.

    • February 24, 2026 · 8 min read

      Python in the AI Era: Why It Ended Up Everywhere

      Five years of writing Python: why it became the default for AI, what is genuinely new in the language, where it still isn't the right tool, and why the "Python is slow" argument misses the point.

    Don't miss the next post

    Secure · Private · Unsubscribe

    listerineh.dev

    Full-stack engineer building AI agents, cloud platforms and web products. Based in Quito, working remotely.

    Open to new projects

    Work

    • Projects
    • Experience
    • Skills
    • Blog
    • Talks

    About me

    • About
    • Why Listerineh?
    • Contact

    Connect

    • GitHub
    • LinkedIn
    • Instagram
    • Email

    © 2026 Sebastian Alvarez · All rights reserved.

    • Privacy Policy
    • Terms of Use
    • Unsubscribe from the newsletter
    • Component Library