Floci vs LocalStack

Gauransh Mathur

Gauransh Mathur

— 4 min read
Share
Floci vs LocalStack
Photo by Pero Kalimero / Unsplash

When you are working on deploying infrastructure, especially expensive enterprise stacks, always deploying to AWS might not be necessary or even useful cost wise. Most of the time you just want to prove that your configuration works. Your Terraform plans cleanly, your Lambda actually triggers off that SQS queue, your IAM policy has proper least privilege. So when you do deploy for real, you deploy exactly what you need, once.

This matters the most for two groups of people.

Small startups, where every dollar of cloud spend counts and nobody wants to explain a $400 bill that came from testing random multi AZ RDS setups or CloudWatch log ingest.

Students and people learning IaC. The fastest way to learn Terraform is to run apply and destroy fifty times in an afternoon. You really don't want to be doing that against a real AWS account with your credit card attached.

The answer for both is local AWS emulation. A container that pretends to be AWS, speaks the real AWS APIs and accepts your real SDK/CLI/Terraform calls at http://localhost:4566.

LocalStack

LocalStack has been the main solution for a while. It's mature, well documented and has the biggest ecosystem support. Testcontainers has a first class LocalStackContainer, every CI tutorial references it, and tooling like tflocal and awslocal wraps Terraform and the AWS CLI to point at it automatically.

It used to have a free Community edition covering 30+ core services (S3, SQS, SNS, DynamoDB, Lambda and friends), with paid tiers unlocking the more obscure enterprise services and things like cloud hosted ephemeral instances. Those are LocalStack endpoints running in their cloud, which is actually useful for teams that want shared test environments without managing anything themselves.

But LocalStack removed the Community edition in March 2026. The image now requires you to create an account and provide an auth token just to pull and run the emulator, and security updates on the last Community release are frozen.

If you are a student, the GitHub Student Developer Pack still gets you the paid tier for free which is honestly a great deal.

Floci

It launched in February 2026 as an alternative.

It runs the same way LocalStack does, a Docker container exposing AWS endpoints on port 4566, but under the hood it is very different. It's built on Quarkus and compiled to a GraalVM native image and the numbers are kind of absurd:

  • ~24ms startup vs LocalStack's ~3.3s
  • ~13 MiB idle memory vs ~143 MiB
  • ~90 MB Docker image vs ~1.0 GB

For a local dev this is a nice to have. For CI, you can afford to spin up a fresh emulator per test instead of sharing one dirty instance.

Coverage is at 47 services now. And the important part, services like Lambda, RDS, ECS, EC2, EKS and OpenSearch use real Docker backed execution instead of shallow mocks. Your Lambda will actually run in a container and your "RDS" is a real Postgres.

Persistence, which LocalStack kept behind paid tiers, is free here and more granular. You can pick memory, hybrid, persistent or write ahead log storage modes per service. So your DynamoDB can survive restarts while S3 stays fast in memory.

Migrating is basically one line

Floci translates LocalStack environment variables automatically, runs init scripts from the same /etc/localstack/init/ paths, serves the same health endpoints and even prints the LocalStack style outputs.

services:
  floci:
    image: floci/floci:latest   # was: localstack/localstack
    ports:
      - "4566:4566"
    volumes:
      - floci-data:/var/lib/floci
      - /var/run/docker.sock:/var/run/docker.sock  # needed for Lambda/ECS/RDS

And Terraform doesn't care either way, you just override the provider endpoints:

provider "aws" {
  access_key                  = "test"
  secret_key                  = "test"
  region                      = "ap-southeast-1"
  skip_credentials_validation = true
  skip_requests_from_metadata = true

  endpoints {
    s3       = "http://localhost:4566"
    dynamodb = "http://localhost:4566"
    sqs      = "http://localhost:4566"
    lambda   = "http://localhost:4566"
  }
}

Floci is still very new. But it already has 10k+ GitHub stars and very fast development.

But it does not have LocalStack's years of edge case hardening. It also has no hosted cloud offering, it is local or in your CI only.

What emulators can't tell you

IAM is not fully enforced. Your policy can be completely broken and the emulator will happily let everything through.

Quotas, limits and pricing don't exist locally. Nothing stops you from "provisioning" a 96 vCPU instance in an emulator.

Real AWS behaves differently in the edges. Eventual consistency, throttling, cold starts. None of that shows up in a mock.

The right way to think about it, emulators validate your configuration and your application logic, not AWS itself. They get you 90% of the confidence for 0% of the cost.

So which one should you use?

If you are a student, this is a closer call than it used to be. The GitHub Student Pack gets you LocalStack's paid tier for free, and their hosted instances mean you skip the whole CI setup learning curve. But Floci needs no signup and zero tokens, you are running in under a minute and everything you learn transfers 1:1. Start with whichever removes friction for you today. Switching later is a one line image swap anyway.

If you are experienced and picking for a team, Floci is probably the better default now. Free LocalStack does not exist in the form most teams relied on, managing tokens in CI is annoying overhead for what should be throwaway infrastructure, and Floci's startup speed genuinely changes your test setup. Keep LocalStack in mind if you specifically need the paid features.

Read more