ToggleFleet
Ruby-first release control · flat pricing

Ship the code.Decide who sees it.

ToggleFleet gives Ruby teams the five-gate model they already understand — boolean, actor, group, percentage of actors, and percentage of time — with local evaluation, isolated environments, and a dashboard built for controlled releases.

10 flags freeNo credit cardUnlimited teammatesRuby SDK + REST API
workspace / production
checkout_v2

New checkout

Partial
BooleanOn for everyone
Percentage of actorsSticky rollout
Target actorsSpecific accounts
daveacct_42
Target groupsResolved in your code
admins
CHANGE RECORDEDcheckout_v2 changed in Production

25% rollout · restorable from history

EvaluationLocal in the Ruby process
TargetingFive familiar gates
OperationsHistory and rollback
Pro price$15/month flat
A short path to a safe release

Release control without a platform maze.

Create the flag, target the audience, promote states between environments, and keep a restorable record of every important change.

01 / Define

Create a stable key

Name the release control once. The key stays constant in code while its gates change independently in each environment.

02 / Target

Choose exactly who

Switch it on globally, target actors or groups, or run a sticky percentage rollout without changing application code.

03 / Promote

Copy environment state

Prove a gate set in Staging, then copy the complete state into Production instead of re-entering every value.

04 / Recover

Inspect and roll back

Every flag change enters the audit trail with its prior state, operator, environment, and a one-click rollback.

The five-gate ledger

One flag is on when any gate matches.

The server and Ruby SDK use the same gate order and actor bucketing, so percentage rollouts remain sticky wherever evaluation happens.

01

Boolean

The master switch. Release to everyone in the selected environment.

enabled = true
02

Actor

Target stable user, account, or tenant identifiers.

actors = ["acct_42"]
03

Group

Target groups whose membership rules stay in your application.

groups = ["admins"]
04

% of actors

Ramp from 1% to 100% while the same actor stays in the same bucket.

rollout = 25
05

% of time

Sample a percentage of evaluations for load testing or probabilistic paths.

percentage_of_time = 5
A real operating surface

Know what is live before you touch it.

The dashboard turns flags, environment health, and change history into one direct release-control surface rather than another analytics suite.

  • 01
    Fleet overview

    See on, partial, and off states alongside recent changes.

  • 02
    Environment health

    Know which SDK key connected last without exposing full credentials.

  • 03
    Searchable controls

    Find a flag by key, name, or purpose and edit all five gates in place.

  • 04
    One-time key rotation

    New SDK keys are displayed once and stored only as a one-way hash.

ToggleFleet / Sample workspaceillustrative preview

Release control, at a glance.

fleet overview
Flags7
Partial3
Environments3
Changes · 7d11
FLEET STATE
RECENT CHANGES
checkout_v2 · Production25% rollout · Ada
billing_portal · Stagingactor target · Sam
Ruby SDK connectedProduction · now
The request path stays yours

Fetch in the background. Evaluate locally. Fail safely.

The Ruby SDK is designed so a feature check is not coupled to ToggleFleet availability.

0ms*

Local evaluation

After configuration is loaded, enabled? reads in-process state rather than making a network call. *No ToggleFleet network round-trip on the hot path.

304

Conditional refresh

The SDK sends an ETag on background polls. Unchanged configuration returns HTTP 304 with no JSON body to parse.

last

Last-good configuration

A failed refresh leaves the last loaded state in place. Before the first successful load, unknown flags use your configured safe default.

hash

Deterministic actors

Actor percentages use the same stable bucket on the server and in the gem, preventing rollout flicker.

Ruby SDK and REST API

One initializer, or two JSON endpoints.

Ruby applications get background refresh and local evaluation. Other server-side clients can fetch a complete environment or evaluate one flag directly.

config/initializers/togglefleet.rbRuby SDK
# Gemfile
gem "togglefleet"

ToggleFleet.configure do |config|
  config.sdk_key = ENV["TOGGLEFLEET_SDK_KEY"]
  config.default = false
end

ToggleFleet.start

if ToggleFleet.enabled?(
  :checkout_v2, actor: current_user
)
  render "checkout/v2"
end
server-side HTTPREST API
# Evaluate one flag
curl https://togglefleet.com/v1/evaluate \
  -H "Authorization: Bearer $SDK_KEY" \
  -G --data-urlencode "flag=checkout_v2" \
     --data-urlencode "actor=acct_42"

# Fetch and cache the environment
curl https://togglefleet.com/v1/config \
  -H "Authorization: Bearer $SDK_KEY" \
  -H 'If-None-Match: "…"'

# → 200 with flags, or 304 unchanged
Verified comparison · July 2026

A focused Ruby release tool, not a smaller enterprise platform.

ToggleFleet competes directly on the five-gate workflow and flat team pricing. Flipper Cloud offers a broader set of telemetry and integrations at higher listed tiers.

Monthly planToggleFleetFlipper Cloud
Free flags105
Free team membersUnlimited2
Entry paid price$15/month flat$49/month · up to 10 collaborators
25 collaborators$15/month$149/month
50 collaborators$15/month$299/month
Five gate typesIncludedIncluded
Change historyIncludedIncluded · retention varies by plan
One-click flag rollbackIncludedPaid plans
Flipper Cloud prices, collaborator limits, free flag limit, audit retention, and rollback availability checked against the live pricing page on July 26, 2026.View source pricing ↗

Choose ToggleFleet when

You want the familiar Ruby gate model, local evaluation, unlimited teammates, straightforward environments, history, rollback, and a predictable small-team bill.

Evaluate Flipper Cloud when

You need its broader telemetry, Slack notifications, feature ownership, tags, webhooks, granular permissions, or the support relationship with Flipper's developers.

Two plans. No seat math.

Start free. Pay for flag scale, not headcount.

Prices shown are monthly. No annual commitment is required.

Free
$0 / forever
  • Up to 10 flags
  • Unlimited environments
  • Unlimited team members
  • All five gates
  • Ruby SDK and REST API
  • Change history and rollback
Create a free workspace →
Before you wire it in

Useful answers, up front.

Does every flag check call ToggleFleet?

No. The Ruby SDK refreshes configuration in the background and evaluates locally. The REST /v1/evaluate endpoint is available when a server-side HTTP check is the right integration.

What usage is included in the flat price?

ToggleFleet does not meter local Ruby SDK evaluations, monthly active users, teammates, or environments for billing. REST endpoints are rate-limited for service protection at 600 requests per minute per client IP; local SDK evaluation avoids that request path.

What happens when ToggleFleet is unreachable?

The Ruby SDK keeps its last successfully loaded configuration. If it has never loaded, it uses the fail-safe default you configure; that default is false unless changed.

Are percentage rollouts sticky?

Percentage-of-actors targeting is deterministic for a flag and actor ID. The same actor remains in the same bucket as the rollout changes. Percentage-of-time is intentionally random per evaluation.

Can I recover from a bad flag change?

Yes. Flag state changes record the prior state, operator, and environment. Restorable history entries expose a rollback action in the dashboard.

How are SDK keys stored?

The current key is shown once when generated or rotated. ToggleFleet stores a one-way SHA-256 hash and a short display prefix, not the full credential.

Is this a complete clone of Flipper Cloud?

No. ToggleFleet focuses on the five-gate release-control workflow, local Ruby evaluation, environments, history, and flat pricing. Flipper Cloud includes broader telemetry, integrations, ownership, tagging, and permission features.

The next deploy can start behind a flag

Ship the code. Keep control of the audience.

Open a free workspace, create the flag, generate an environment key, and evaluate locally in Ruby.