← All work
DEVELOPER & INFRASTRUCTURELIVELatchFeature flags written as sentences
Developer & infrastructureLivelatch.inkress.com ↗

Latch

Feature flags a whole team can read: switch a feature on for everyone, one customer or a slice of customers, with every flag written out as a plain sentence.

33
database tables, each reached only through a workspace-scoped handle
167
automated test files across the monorepo
Byte-identical
rollout bucketing, so customers keep their bucket after the move

The problem

Turning a feature on for one customer, or a few, usually takes a developer and a release. The flag tools that exist are written for engineers, so founders and support staff can't see who has what, let alone change it safely.

What it does

Latch lets a team switch product features on or off separately in each environment, such as Testing and Production. Every flag is shown as a sentence anyone can read, for example "On for Lisbon Bikes. Everyone else: off."

People sign in with an emailed code or Google and work inside workspaces and projects with roles, so it's clear who may change what. Each environment gets its own SDK key, and scripts get scoped admin tokens that are shown once and then stored only as a fingerprint.

Flag answers are designed to come from a small worker at the network edge, close to the people using an app. The API already compiles each environment's rules and publishes them to that edge worker, and the public endpoint that apps will ask is being finished now.

Key features

  • Flags as plain sentences

    Anyone on the team, technical or not, can read exactly who gets a feature without decoding rule syntax.

  • Separate environments

    A feature can be on in Testing and off in Production, so a change is tried safely before real customers see it.

  • Roles per workspace

    Founders, support and engineers share one tool while the right people hold the right to change production.

  • Keys shown once

    SDK keys and admin tokens are displayed a single time and kept only as fingerprints, so a database leak doesn't hand out working keys.

  • Same answers as the old engine

    Flags moved from Inkress's original engine behave exactly as before, so migrating changes nothing for the people using an app.

  • Rules run at the edge

    Rules are compiled once and pushed out, so checking a flag won't need a round trip to a central server.

Where it stands

Launched in November 2026: sign-up, workspaces, flags, environments and keys are live. Answering flags from customer apps at the edge, the SDKs, flag history, approvals and scheduled changes, and paid plans are in progress and not yet released.

Under the hood: for the technically-minded

How it's built

Latch is a TypeScript monorepo: an API on Hono, a web app in React Router, a Cloudflare Worker for the edge, a background worker, and shared packages for the decision engine, the database and the API contract.

The decision engine is a pure package with no runtime dependencies, ported from Inkress's Elixir flag engine, and its build rules forbid anything that wouldn't run in both Node and the edge runtime. Percentage rollouts use a bucket hash that matches the original byte for byte, so a customer lands in the same bucket after the move.

Tenant isolation is enforced in the code, not left to habit. Tables can only be reached through a handle scoped to one workspace, the raw schema isn't exported, and a lint rule blocks any shortcut around it.

The hard problems

  • Matching the original engine exactly

    A fixture exporter records real answers from the Elixir engine, and a CI gate replays them against the new engine in both Node and the edge runtime. Tens of thousands of cases must match before a change merges, with the few regular-expression differences written down rather than hidden.

  • Customer regex on a free-tier edge

    Rules can contain regular expressions, which can burn CPU. They're translated into a safe subset with a work budget, and rule sets are compiled ahead of time with a per-request CPU budget.

  • Keys and sign-in under abuse

    A security review found races in key creation, code guessing and invite spam. Each was closed with unique database indexes, rate limits and concurrency tests.

Built with

  • TypeScript
  • Hono
  • Cloudflare Workers
  • PostgreSQL
  • React Router

Building something in this space?

Work with us →