Forem: Rami Rosenblum

I built a feature flag tool after our LaunchDarkly bill hit $3k/mo. Here's what changed.

Rami Rosenblum — Mon, 02 Mar 2026 13:56:10 +0000

A few months ago, our startup was deep in launch mode. We loved LaunchDarkly—powerful, reliable, great for experimentation. But then the pricing conversation came up.
"To unlock the features we actually need, it'll be several thousand dollars a month."
We paused. Were we paying for capabilities we barely used? What happens when we scale 10x—does the bill 10x too? And after the recent LD outage, the question got sharper: What if our flag provider goes down during a critical deploy?
So I did what any stubborn engineer would do: I built ToggleTown.
While we were migrating, we had a moment that proved it was worth it. During a routine deploy, one of our new features started throwing edge-case errors. In the past, this meant: panic, hotfix branch, App Store review, waiting 24–48 hours.
With ToggleTown? I opened the dashboard, flipped a toggle, and the feature was disabled for 100% of users in <2 seconds. No new build. No review. No downtime.
That's exactly why I built ToggleTown—feature flags that give you control after you ship, without vendor lock-in or surprise invoices.
🏠 The house analogy I keep using:
LaunchDarkly is like renting a luxury mansion—you get everything, but you pay for the whole estate whether you use it or not.
ToggleTown is like a well-designed apartment: you pay for the space you actually live in, and you can rearrange the furniture anytime without asking permission.
Current features:
✅ Core LD parity: feature flags, targeted rollouts, A/B testing, basic analytics
✅ Transparent, usage-based pricing (no "contact sales", no surprise overages)
✅ Built-in flag health monitoring to catch stale or unused flags early
✅ Developer-first SDKs with fast evals and graceful fallbacks
✅ Free tier to start—no credit card required
If you ship software and "release anxiety" is part of your job description, ToggleTown was built for you.
👉 toggletown.com
Happy to answer questions about:
• Migrating away from LD (or other providers)
• How we designed for cost predictability at scale
• What we learned building a flag system from scratch
• Or just: "Does this actually work with React/Node/iOS?"
AMA 🙏
Full disclosure: I'm a founder at ToggleTown. We built this because we needed it. If you try it and hate it, I genuinely want to know why.

LaunchDarkly Is Down Again — And That's a Problem

Rami Rosenblum — Thu, 26 Feb 2026 16:11:28 +0000

Feb 26, 2026 — LaunchDarkly is currently investigating issues with their web application and authentication system. Some customers can't access the dashboard or log in at all.
Why This Matters
When your feature flag provider goes down, you lose the ability to:

Toggle features on/off in an emergency
Roll back a bad deployment quickly
Monitor flag evaluations and targeting rules
Manage access controls and permissions

Feature flags are supposed to be your safety net. When the safety net itself fails, teams are left flying blind during the exact moments they need control the most.
The Bigger Picture
This isn't the first time LaunchDarkly has had availability issues. For a service that sits in the critical path of deployment workflows and production feature management, reliability isn't optional — it's the entire value proposition.
To be fair, LaunchDarkly's SDK architecture is designed so that flag evaluations continue working even when the dashboard is down (SDKs cache flag states locally). But losing dashboard access during an incident — when you most need to flip a kill switch — is exactly the wrong time for an outage.
What Teams Should Consider

Local evaluation resilience: Make sure your SDK setup includes proper caching and fallback defaults so flag evaluations continue working even when the dashboard is down.
Runbook for provider outages: Have a plan for when your feature flag service itself is unavailable. Can you override flags via config or environment variables?
Evaluate alternatives: The feature flag space has grown significantly. You don't have to choose between "pay enterprise pricing" and "self-host everything yourself."

Why I Built ToggleTown

Full disclosure — this is exactly the kind of incident that motivated me to build ToggleTown, a managed feature flag platform starting at $29/month.
The core thesis is simple: feature flags shouldn't cost $40K–$120K per year, and you shouldn't lose the ability to manage your flags at the worst possible moment. Here's what ToggleTown does differently:

Local-first SDK evaluation — flags are evaluated client-side with low-latency caching, so your app keeps working even if our dashboard has a bad day.
AI-powered stale flag cleanup — auto-generates PRs to remove dead flags so you don't drown in technical debt.
Transparent pricing — no per-seat traps, no surprise bills, no sales calls to find out what it costs.
OpenFeature native — no vendor lock-in. If you ever want to switch, you can.

If you're currently paying LaunchDarkly prices and watching their status page turn orange, it might be worth checking it out.
Bottom Line
Feature flags are infrastructure. Treat your feature flag provider with the same scrutiny you'd give your database or your CDN. If it's in your critical path, it needs to be rock solid — or you need a contingency plan for when it's not.

Feature Flags for Startups Who Can't Afford LaunchDarkly

Rami Rosenblum — Sun, 22 Feb 2026 18:35:08 +0000

You need feature flags. You don't need a $1,200/year bill to get them.

Every startup reaches the same moment. You're shipping fast, breaking things, and someone says: "We should really be using feature flags." So you Google it, find LaunchDarkly, click on pricing — and close the tab.

$10/seat/month. Five engineers? That's $600/year. Ten engineers next quarter? $1,200. And that's before you discover A/B testing is locked behind the Enterprise plan with no public pricing.

You're a startup. Every dollar matters. But shipping without feature flags is like driving without brakes — you'll crash eventually.

Here's the good news: you don't have to choose between your runway and safe deployments.

Why Startups Need Feature Flags (Even at 3 People)

Feature flags aren't an enterprise luxury. They solve problems that hit hardest at the startup stage:

1. You can't afford downtime
A bad deploy at Google costs embarrassment. A bad deploy at your startup costs customers you'll never get back. Feature flags let you kill a broken feature in seconds — no rollback, no revert, no downtime.

2. You ship faster when you decouple deploy from release
Merge to main every day. Hide unfinished features behind flags. Release when ready, not when the branch is clean. Your team ships 2-3x faster because nobody waits on anyone else.

3. You need to validate before you build
Before spending 3 weeks building that billing redesign, roll it out to 10% of users. Measure. Decide. Feature flags turn "we think users want this" into "we know users want this."

4. You need to impress enterprise prospects
Trying to land your first enterprise deal? "We use feature flags for gradual rollouts and canary releases" signals maturity without actually needing a 50-person platform team.

What LaunchDarkly Gets Right (And Where It Falls Short for Startups)

Let's be fair. LaunchDarkly is a great product. They pioneered the category. Their SDK coverage is unmatched (25+ languages), their real-time streaming is fast, and enterprises trust them.

But LaunchDarkly was built for enterprises, and it shows:

Pain Point	What Happens
Per-seat pricing	Your bill grows every time you hire. At 10 seats, you're paying $1,200+/year for feature flags.
A/B testing is Enterprise-only	Want to run experiments? Prepare for a sales call and a price you won't like.
Complex onboarding	Their SDK docs are thorough — and overwhelming. Budget 30+ minutes to get your first flag working.
No real free tier	14-day trial, then pay or leave. No option to keep using it for side projects or MVPs.
Flag cleanup is Enterprise-only	Stale flags pile up. LaunchDarkly's flag lifecycle tools? Enterprise plan only.

None of this matters when you're a 500-person company with a platform team. All of it matters when you're 5 people burning $40k/month.

What to Look for in a Startup-Friendly Feature Flag Tool

Before you pick a tool, here's your checklist:

[ ] Flat pricing — not per-seat. Your costs shouldn't scale with headcount.
[ ] Free tier — real free tier, not a trial. You need to evaluate without a deadline.
[ ] 5-minute setup — if it takes longer than your coffee break, it's too complex.
[ ] A/B testing included — experiments shouldn't require an enterprise contract.
[ ] Flag health monitoring — because stale flags become tech debt fast.
[ ] Audit logs on every plan — compliance matters even at seed stage.

ToggleTown: Built for Teams Like Yours

Full disclosure: this is our product. But we built it because we had the exact problem described above.

Pricing That Doesn't Punish Growth

	ToggleTown	LaunchDarkly
Free tier	3 projects, 50 flags, 1,000 MAU — forever	14-day trial
Paid plan	$29/mo flat — unlimited team members	~$10/seat/month
10-person team cost	$29/mo ($348/year)	$100+/mo ($1,200+/year)
A/B testing	Included in Pro	Enterprise only
Flag health dashboard	Included in Pro	Enterprise only

That's not a typo. A 10-person team saves $850+/year. A 20-person team saves even more because our price stays the same.

Startups and nonprofits get 50% off. That's $14.50/mo for the full Pro plan.

Setup in 5 Minutes, Not 50

Install the SDK:

npm install @toggletown/sdk-js

Initialize it:

import { ToggleTown } from '@toggletown/sdk-js';

const client = new ToggleTown({
  apiKey: 'your-environment-key',
});

await client.initialize();

Check a flag:

const showNewCheckout = client.getBooleanFlag('new-checkout', false);

if (showNewCheckout) {
  renderNewCheckout();
} else {
  renderOldCheckout();
}

That's it. Three steps. Your first feature flag is live.

A/B Testing Without the Enterprise Tax

Most startups don't A/B test — not because they don't want to, but because the tools are too expensive or too complex.

ToggleTown includes experiments in the $29/mo Pro plan:

Create experiments linked to feature flags
Split traffic across 2-10 variants
Track impressions and conversions automatically
Get statistical significance calculated for you (z-test, p < 0.05)
Declare a winner and apply it to production in one click

No separate analytics tool. No enterprise upgrade. Just create an experiment and start learning.

Flag Health: Because Stale Flags Are Tech Debt

Every feature flag you create is a promise to clean it up later. Most teams don't.

ToggleTown's Flag Health Dashboard automatically detects:

Stale flags — 100% rolled out for 14+ days (just remove the flag and keep the code)
Inactive flags — no changes in 30+ days (are you still using this?)
Project health score — 0-100 score so you know when cleanup is overdue

You also get a weekly email digest showing which flags need attention. No more "we'll clean that up later" turning into permanent tech debt.

AI-Native: Manage Flags From Your Editor

This is something no other feature flag tool offers yet.

ToggleTown ships an MCP server that lets you manage flags directly from Claude Code, Cursor, or GitHub Copilot:

"Toggle the dark-mode flag to true in production"
"Create a new boolean flag called redesigned-navbar"
"Show me the audit log for the checkout-v2 flag"

12 tools. Full CRUD. Works on every plan including free.

If your team is already using AI-assisted development, your feature flags now live in the same workflow.

Honest Comparison: Where LaunchDarkly Still Wins

We're not going to pretend we're better at everything:

Capability	LaunchDarkly	ToggleTown
SDK languages	25+ (including iOS, Android, Flutter)	6 (JS, React, Node, Python, Go, MCP)
Real-time updates	WebSocket streaming	Polling (30s default)
Enterprise SSO/SAML	Yes	Not yet
Community size	Large, mature	Growing
Mobile SDKs	iOS, Android, React Native, Flutter	Not yet (on roadmap)

If you're building a mobile-first app in Swift and need real-time flag updates with SAML SSO, LaunchDarkly is the better choice today.

If you're a web-focused startup that needs feature flags, experiments, and flag lifecycle management without spending $1,200/year — we built ToggleTown for you.

The Math That Matters

Here's what $29/mo gets you with ToggleTown Pro:

Unlimited team members (not per-seat)
10 projects, 500 flags per project
10,000 monthly active users
A/B testing with statistical significance
Flag health monitoring and weekly digests
90-day audit logs
User segments and targeting rules
Percentage rollouts with consistent bucketing
Webhooks (3 endpoints)
Scheduled flag changes
All SDKs (JS, React, Node, Python, Go, MCP)
99.5% uptime SLA

The equivalent feature set at LaunchDarkly requires their Enterprise plan. We've never seen a public price for it, but industry estimates put it at $500-1,000+/month.

Get Started in 5 Minutes

Sign up at toggletown.com — no credit card required
Create a project and your first feature flag
Install the SDK (npm install @toggletown/sdk-js)
Evaluate your first flag in < 10 lines of code
Upgrade to Pro when you're ready — or keep the free tier forever

Your startup deserves safe deployments. You shouldn't have to choose between feature flags and runway.

ToggleTown offers 50% off for verified startups with less than $1M in funding. [Apply here.]

Feature Flags in 5 Minutes with Node.js

Rami Rosenblum — Thu, 19 Feb 2026 14:47:59 +0000

Feature flags let you deploy code without releasing it. You push to production, but new features stay hidden behind a flag until you flip the switch. No more long-lived feature branches, no more "release day" anxiety.

In this tutorial, you'll add feature flags to a Node.js app using ToggleTown's Node SDK. The whole thing takes about 5 minutes.

1. Create a ToggleTown account

Sign up at app.toggletown.com — it's free for up to 5 flags, no credit card required. Create a project, and you'll get an environment API key (starts with env_).

2. Install the SDK

npm install @toggletown/sdk-node

3. Initialize the client

The SDK fetches your flag configuration on startup and evaluates flags locally — no network call per check, zero latency.

import { ToggleTownNode } from '@toggletown/sdk-node';

const client = new ToggleTownNode({
  apiKey: process.env.TOGGLETOWN_API_KEY, // env_xxx
});

await client.initialize();
console.log('ToggleTown ready —', client.flagCount(), 'flags loaded');

The SDK polls for updates every 30 seconds by default, so flag changes propagate without restarting your app.

4. Wrap your feature

Use getBooleanFlag to check whether a feature should be enabled. Pass the flag key, a default value, and an optional user context for targeting.

app.get('/dashboard', (req, res) => {
  const showNewDashboard = client.getBooleanFlag(
    'new-dashboard',
    false, // default if flag doesn't exist
    { userId: req.user.id, email: req.user.email }
  );

  if (showNewDashboard) {
    return res.render('dashboard-v2');
  }

  return res.render('dashboard');
});

The user context enables targeting rules — roll out to specific users, emails matching a pattern, or a percentage of traffic.

5. Create the flag in ToggleTown

Head to the ToggleTown dashboard, create a boolean flag called new-dashboard, and toggle it on. Your app picks up the change within 30 seconds.

Want to be more careful? Use percentage rollout to enable the flag for 10% of users first, then ramp up to 50%, then 100%. If something breaks, flip the flag off instantly — no deployment needed.

Beyond booleans

ToggleTown supports four flag types. Use the right one for your use case:

// Boolean — on/off toggles
const enabled = client.getBooleanFlag('new-feature', false);

// String — variant selection, themes, copy testing
const theme = client.getStringFlag('app-theme', 'light');

// Number — limits, thresholds, tuning
const maxRetries = client.getNumberFlag('max-retries', 3);

// JSON — complex configuration
const config = client.getJsonFlag('onboarding-flow', {
  steps: ['welcome', 'setup'],
});

Recap

Sign up and get your environment API key
npm install @toggletown/sdk-node
Initialize the client with your API key
Wrap features with getBooleanFlag (or other flag types)
Create and toggle flags in the dashboard

Next steps

Read the full SDK docs for targeting rules, segments, and experiments
Check out the feature flag best practices guide
We also have SDKs for JavaScript, React, Python, and Go

ToggleTown is a simple, open feature flag platform for modern teams. Free tier available, no credit card required.