Skip to content
lube

Feature flags

Typed valuesPer environmentTargetingAudited

Ship it to 5% of users, not all of them.

More than an on/off switch. Ship typed values, ramp a percentage without ever flipping a user back, and target the exact accounts you mean. Every change lands in the audit log.

Start free

checkout-v2

  • productionoff
  • stagingon
  • developmenton
  • previewon
One flag, every environment

Its place in the loop

Flags gate the rollout inside Release.

One connected loop, held on the stage this capability serves. The other stages stay as context so you can see what feeds in and what comes next.

BD
Discovery
Feedback
Product
Engineering
Release
Reliability
Evidence

Stage inventory

Release

Carry the change into production.

Deployment history

Review deployment evidence beside the service and environment it affected.

Available now

Feature flags

Keep rollout controls visible beside release context.

Available now

Automatic changelogs

Carry the change into production.

Coming later

Coming later reflects product vision, not a delivery commitment.

How a rollout actually works

Watch one flag become a controlled rollout.

flag: checkout-v2

false

Off everywhere. A safe default while you build.

productionoff

  1. Default

    Every flag starts off.

    Off in every environment, with a typed default value. Nothing reaches a user because the flag simply exists.

  2. Per environment

    Turn it on where it's safe.

    Each environment carries its own config, so a flag can be live in development and staging while production stays untouched.

  3. Deterministic rollout

    Ramp without the flicker.

    A SHA-256 hash of flag, environment, salt, and subject buckets each user consistently, so nobody flips between old and new as you climb from 10 to 100%.

  4. Targeting

    Aim at the exact subjects.

    Ordered groups combine matchers with AND/OR logic and return their own typed value. The most specific match wins, so a tight rule beats a broad one.

  5. Full and reversible

    Ship it, with a way back.

    Fully rolled out, signed for tamper-evident delivery, traced per evaluation, and one restore away from any prior revision.

Authoring, not just on/off

Author typed flags with the right editor for each type.

A flag is a typed value, not a boolean checkbox. The dashboard renders a control that fits the type — a toggle, a bounded slider, a segmented enum, weighted variants, or a JSON editor — so you never hand-edit a raw blob.

  • booleancheckout-v2true
  • numbermax-batch-size64
  • stringbanner-stylecompact
  • jsonpricing-experimentcontrol / A / B
  • arrayallowed-regions["us-east", "eu-west"]
    ["us-east", "eu-west"]
One editor per flag type

Evaluation, step by step

Rules are checked in order until one matches.

For a given subject, the engine walks the ordered rules top to bottom and stops at the first match. The winning rule returns its typed value; the rules below it never run.

evaluate · acct_8842 · plan=enterprise · region=EU

first match wins
  • 01Internal staffemail endsWith @lube.workskip
  • 02Beta cohortattr beta = trueskip
  • 03Enterprise · EUplan = enterpriseregion = EU{ variantB }
  • 04All enterpriseplan = enterprise—
  • defaultfalse
First matching rule wins

The dials behind a rollout

Three ways a flag decides.

Percentage rollout

Ramp climbs stage by stage.

A scheduled rollout advances the percentage through set stages. The same hashed bucket keeps a user on one side the whole way up.

deterministicscheduledsticky buckets

checkout-v2

scheduled
  • Canary10%
    done
  • Quarter25%
    done
  • Half50%
    current
  • Full100%
    queued
Scheduled percentage ramp

Weighted variants

A subject drops into one bucket.

Split traffic across typed variants by weight. The deterministic hash lands each subject in exactly one bucket and keeps it there.

weighted splittyped variantsone bucket

checkout-v2

hashed split
50%30%20%
  • control
  • variantA · assigned
  • variantB
Hashed into one variant

Ordered targeting

The most specific group wins.

Groups combine matchers with AND/OR and are tried in order. A tight rule beats a broad one, and each returns its own typed value.

AND / ORspecificitytyped return
  • 01Enterprise · EUmatch all
    plan=enterpriseregion=EU→ variantB
  • 02Beta cohortmatch any
    attr beta=true→ variantA
  • 03US rolloutmatch all
    country=US→ true
  • default→ false
Ordered targeting groups

Rollout, not experimentation

lube runs and records rollouts, and records every exposure. It does not run A/B significance testing, so exposures and metrics are counts, not experiment verdicts. Attribute matching lives in the targeting groups; legacy rules cover IP, country, and region.

Signed, verifiable evaluation

Values you can verify, not just trust.

Ask for a signed evaluation and the API returns the resolved flags inside an ES256-signed JWT. Your app verifies it against the published public key before it trusts a single value, so a tampered payload is rejected.

evaluate/signed · production

ES256

subject · acct_8842

  • checkout-v2true
  • banner-stylecompact
  • max-batch-size64

eyJhbGciOiJFUzI1NiJ9.eyJmbGFncyI6Wy4uLl19.q3Vf8Zr

verified · public key
Signed with ES256

Every evaluation is traced and counted

See how each value was reached.

Evaluations roll up by result source — a targeting group, the environment default, or the flag default — with recent exposures and per-evaluation debug traces on hand. These are counts, not experiment verdicts.

  • Targeting group1,284
  • Config default842
  • Flag default346
Evaluations by result source

Change history, not a mystery

Every change is a revision you can restore.

Every edit — metadata, a config change, a rollout action — writes an immutable revision with who did it and why. Restore any earlier revision exactly as it was, and that restore is itself recorded as a revision.

checkout-v2 · history

append-only
  • #14Advanced production rollout to 100%rollout_action · mayalive
  • #13Added Enterprise · EU targeting groupconfig_update · danrestore
  • #12Resumed the scheduled ramprollout_action · mayarestore
  • #11Renamed and tagged the flagmetadata_update · danrestore
  • #10Created checkout-v2 (boolean)create · mayarestore
Append-only revision trail

The SDK your app talks to

Typed flags, from the dashboard to your code.

Typed generation

Author in the dashboard, generate typed bindings.

The dashboard is the source of truth. Generate a typed FLAGS map and hooks from your live definitions, so a flag key that does not exist fails at compile time instead of at runtime.

FLAGS maptyped hookscompile-time safe
  1. 01

    Author

    create the flag in the dashboard

  2. 02

    Generate

    typed FLAGS map and hooks

  3. 03

    Consume

    reference only generated keys

From dashboard to typed code

Adapters

OpenFeature, NestJS, and React, out of the box.

One client, four dedicated entry points. Drop it into an OpenFeature web or server app, a NestJS service, or React components with typed hooks — no glue code to write.

OpenFeatureNestJSReact
@lubed/feature-flags
React hooks · /react
OpenFeature web · /openfeature/web
OpenFeature server · /openfeature/server
NestJS module · /nestjs
One client, four adapters

Durable snapshots

Signed snapshots keep serving if the API blinks.

The client verifies each signed evaluation and can persist it as a durable snapshot, so your app keeps resolving the last known-good values instead of failing open when the network does.

signed snapshotverify offlineknown-good values
  1. 01

    Evaluate

    signed ES256 payload

  2. 02

    Verify

    against the public key

  3. 03

    Persist

    durable local snapshot

  4. 04

    Serve

    known-good on outage

Evaluate, verify, persist

Developer preview

The SDK is published but pre-1.0: it is in developer preview while the platform opens up, so pin versions and expect changes. It reads already-evaluated values — flags are always authored in the dashboard, never hand-written as loose strings in code. A generate, audit, and cleanup CLI keeps your code and your flag catalog in sync.

One engine, a lot of dials

The parts most tools leave out.

Every one of these is real. Flags return typed values, matching spans four kinds with fourteen attribute operators, and the dashboard renders the right editor for each type instead of raw JSON.

Flag value types

Not just on/off.

booleanstringnumberjsonarray

Matcher types

How a group decides.

ipRange (CIDR)countryregionattribute

Attribute operators

Fourteen, with nested paths.

equalsnotEqualscontainsstartsWithendsWithinnotIngreaterThanlessThanisSetisNotSet+3

Rollout modes

How a ramp advances.

manualscheduledpauseresumecancel & revert

Smart editors

The right control per type.

slidersegmentedtoggle mapvariantsdurationcolorjson

Environments

Typed and color-coded.

productionstagingdevelopmentpreviewtesting

The engine, in numbers

5

typed value kinds, not just on and off

14

attribute operators for targeting

100%

deterministic: same user, same variant

4

matcher types, from CIDR to attribute

Connected context

See what a flag sits beside.

Deployments

Where it shipped

Services and environments.

Audit logs

What changed

Flag changes in history.

Uptime

Did it hold?

Monitors and incidents.

Turn it on for ten people first.

Start free

Typed, targeted, environment-aware flags in your workspace.