Fly Labs
Ask FlyBot

Kedge – Full-stack cloud with forkable VM snapshots and global SQLite

I'm building Kedge, a globally distributed platform for stateful serverless apps. Here's how you make a simple static site: `echo '# Hello world!' | ssh kedge.dev`I helped build Fly.io for 4 years and shared enthusiasm for the founders' vision of a 'global Heroku'. While there, I wrote "The Serverless Server" (https://fly.io/blog/the-serverless-server/) as a study of Lambda and a sketch of a modern serverless product built around lightweight VMs. That essay was the initial inspiration for Kedge.Kedge has a fast VM orchestrator that can create code sandboxes or scale service instances in 3ms, using a combination of forkable VM snapshots and a tree of warm pools (Linux kernel -> base runtime -> app). VMs are memory-dense thanks to shared copy-on-write memory pages. You can run lightweight CGI-style functions, public OCI images, or source code for BuildKit to compile and deploy.Kedge's global control plane sits on an eventually-consistent SQLite database. Taking inspiration from Corrosion and Litestream, I built a local-first, multi-writer CRDT-based replication system backed by object storage, and just recently made it open source (https://github.com/wjordan/syzy).You can also use a SQLite client to query `/shared.db` from any instance for a build-in replicated database in your app. This lets Kedge autoscale services close to your users while each instance queries its local replica for eventually-consistent data, with no need to micro-manage instance or volume placement. (There's also a /shared/ filesystem adapter for convenience.)Kedge can even use this same database for stateful, server-rendered HTML apps. Data attributes bind forms, buttons, and values to records in the app database, Kedge compiles the schema and operations at deploy-time, and then queries the local data to serve requests. As a demo, I made a Hacker News clone with story submiss

Hacker NewsToolDevSource
0Sign in to voteCopy link

FL score

72

out of 100

Verdict

VALIDATE

high confidence

Competition

No competitor data yet

Trend

No signal yet

A VM-based serverless platform that trades cold starts for stateful app support and global distribution, targeting developers who need databases and server-rendered HTML without infrastructure complexity.

The pain

Developers deploying stateful apps face a choice: use traditional VPS/containers (manage infra, scaling, databases) or use serverless (cold starts, stateless only, expensive databases). Neither fits apps that need both simplicity and state. Fly.io solved some of this but requires learning their model. Lambda users hit walls with long-running processes and local state.

The gap

No platform makes it trivial to deploy a stateful, globally-distributed app with built-in replicated data and sub-second scaling. Heroku is dead. Fly requires more ops knowledge. Vercel/Netlify are frontend-focused. Traditional serverless (Lambda, Cloud Functions) can't handle state efficiently. The gap is real but narrow, it's specifically for developers who want Heroku's simplicity but with modern distributed architecture.

Build angle

The founder has deep credibility (4 years at Fly.io, published technical essay that influenced the space, open-sourced the replication layer). The technical approach is sound: forkable snapshots solve cold starts better than container images, CRDT-based SQLite replication is novel and solves a real problem. The demo (HN clone) proves the core thesis works. The risk is whether this solves a problem developers will pay for, or if it's technically impressive but solving a problem most devs don't have.

Strengths

  • Founder has proven execution track record and deep domain expertise from Fly.io
  • Technical innovation is real: 3ms VM spawn time via snapshot forking is materially better than container cold starts
  • CRDT-based SQLite replication is novel and addresses a genuine gap (distributed state without operational burden)
  • Demo proves the core concept works end-to-end
  • Positioning is clear: stateful serverless for developers who want simplicity without sacrificing distribution
  • Open-sourced replication layer (syzy) builds credibility and community

Risks

  • Market size unclear: how many developers actually need this vs. using Fly.io, traditional VPS, or accepting Lambda's limitations?
  • Pricing model not mentioned, if it's more expensive than Fly or Lambda, adoption will be hard
  • Competitive response: Fly.io could add better SQLite support; AWS could improve Lambda state handling
  • Operational complexity hidden: running a global control plane on eventually-consistent SQLite is clever but unproven at scale; consistency bugs could be catastrophic
  • Developer education burden: the mental model (forkable snapshots, CRDT replication, local replicas) is more complex than Heroku or Vercel, even if simpler than Kubernetes
  • No evidence of user traction or willingness to pay; technical credibility ≠ product-market fit
  • The demo is impressive but narrow (HN clone); unclear if this generalizes to real production workloads with complex schemas or high consistency requirements

Questions about this idea?

FlyBot reads the scoring and gives you a second opinion on “Kedge – Full-stack cloud with forkable VM snapshots and global SQLite”.

Open FlyBot