How do I sign up for LaunchDarkly Developer (free) and create my first feature flag?

Moving fast shouldn’t mean waking up your on-call at 2am. With LaunchDarkly Developer (free), you can sign up in minutes, wire in feature flags with a few lines of code, and control production behavior in real time—no redeploys required.

Quick Answer: LaunchDarkly Developer is our free-forever plan that gives you feature flagging, observability, and experimentation for your project. You sign up with an email, create an environment, copy an SDK key, and then add your first feature flag to start controlling a feature at runtime.

The Quick Overview

What It Is: LaunchDarkly Developer (free) is a production-grade feature flagging and experimentation plan you can use at no cost to control how and when features roll out.
Who It Is For: Individual developers, side projects, early-stage teams, and anyone who wants to try runtime feature flags without a contract or credit card.
Core Problem Solved: It decouples release from deploy so you can ship code whenever you want, then safely turn features on or off for users in real time.

How It Works

LaunchDarkly evaluates feature flags at runtime through SDKs embedded in your application. Your app sends an evaluation request with a user (or context) to LaunchDarkly, LaunchDarkly evaluates the flag based on your targeting rules, and returns a value—usually a boolean, string, or JSON—that you use to decide what your app should do.

From your perspective, the workflow is simple:

Sign up and create a project:
Create a free Developer account, then use the default project and environment (or define your own) to organize flags.
Add the SDK and connect with an SDK key:
Install a LaunchDarkly SDK in your codebase and initialize it with your environment’s SDK key so your app can evaluate flags in real time.
Create and use a feature flag:
Create a new flag in the LaunchDarkly UI, give it a key, then wrap your new feature in a flag check. Toggle it on or off, or roll it out gradually—no redeploys required.

Below is the process end to end.

Step 1: Sign up for LaunchDarkly Developer (free)

1. Go to the signup page

Open https://launchdarkly.com in your browser.
Click Get started free, Free trial, or any Get started CTA.
Choose the Developer option if presented with plan choices.

The Developer plan is:

Free forever
No credit card required
Includes:
- Unlimited feature flags
- Unlimited seats
- 30 idiomatic SDKs
- 5K Session Replays and Errors
- 10M Logs and Traces

You get the same core runtime control used in production by larger teams, but sized for individual or early-stage use.

2. Create your account

Sign up using:
- Your work or personal email, or
- A supported SSO provider (if shown).
Verify your email if prompted.
Enter basic workspace details (organization name, intended use, etc.).

When you land in the app, LaunchDarkly will typically:

Create a default project
Create standard environments like Production and Test
Walk you through a Quickstart if you want a guided setup

Step 2: Understand projects, environments, and keys

Before creating your first feature flag, it helps to understand how we model releases.

Project: Logical grouping of flags and environments (usually a product, app, or service).
Environment: A stage like Test, Staging, or Production, each with its own configuration and SDK keys.
SDK key: Secret used by your application to connect to a specific environment and evaluate flags.
Client-side ID / Mobile key: Public keys for client or mobile SDKs (not the same as your server-side SDK key).

For your first flag, you’ll usually:

Use the default project
Choose the Test or Production environment
Copy that environment’s SDK key to configure your SDK

You can find these under:

Settings → Projects & environments (names may vary slightly in UI)
Select your project → select your environment → view SDK key

Keep SDK keys secure for server-side SDKs; treat them like any other secret.

Step 3: Add a LaunchDarkly SDK to your application

LaunchDarkly supports 25+ native SDKs (and more via APIs, MCP, CLI, and IDE integrations). The exact install steps differ slightly, but the pattern is consistent:

Install the SDK
Initialize with your SDK key
Identify a user/context
Evaluate the flag and branch behavior

Below is a simple server-side example (Node.js), but you can do the same in Java, .NET, Python, Go, Ruby, front-end JavaScript, mobile, and more.

Example: Node.js server-side setup

Install the SDK:

npm install launchdarkly-node-server-sdk

Initialize in your app:

import LaunchDarkly from 'launchdarkly-node-server-sdk';

const sdkKey = process.env.LD_SDK_KEY; // use your environment's SDK key

const ldClient = LaunchDarkly.init(sdkKey);

ldClient.waitForInitialization()
  .then(() => {
    console.log('LaunchDarkly client successfully initialized');
  })
  .catch(err => {
    console.error('LaunchDarkly initialization failed:', err);
  });

Define a user/context:

const user = {
  key: 'user-123',
  name: 'Test User',
  email: 'test@example.com'
};

You’ll use this context to target features later (e.g., internal users only, certain regions, random cohorts, etc.).

Step 4: Create your first feature flag

Now you’re ready to define a flag in the UI.

1. Open the flags dashboard

In the LaunchDarkly app, choose your project.
Select the environment you’ll test in (Test is a safe starting point).
Go to the Flags tab.

2. Create the flag

Click Create flag and fill in:

Name: Human-readable label, e.g. New onboarding flow
Key: Code-facing identifier, e.g. new-onboarding-flow
- This is what you reference in your SDK calls.
Description (optional): Why this flag exists (helps future you and your teammates).
Flag type: Default is often Boolean (true/false), which is perfect for a simple on/off feature.
- You can also use string, number, or JSON for more complex configuration.

Save the flag. By default, it will appear off or in a default variation state for your chosen environment.

Step 5: Use the flag in your code

With your flag key created, you can now wire it into your application.

Node.js example continued

async function handleRequest(req, res) {
  const user = {
    key: 'user-123',
    name: 'Test User',
    email: 'test@example.com'
  };

  const flagKey = 'new-onboarding-flow';

  // Default value false means: if anything goes wrong, keep the feature off
  const showNewOnboarding = await ldClient.variation(flagKey, user, false);

  if (showNewOnboarding) {
    // Serve the new experience
    res.send('New onboarding experience');
  } else {
    // Fallback to existing behavior
    res.send('Existing onboarding experience');
  }
}

No redeploy is needed to change behavior later. You just toggle or update the flag in LaunchDarkly.

Step 6: Turn the feature on with a controlled rollout

Once your code is deployed with the flag check, you can control rollouts from the LaunchDarkly UI.

Go back to your flag in the UI.
Choose the environment you’re testing in.
Use the targeting panel to control behavior:

Common patterns:

Internal-only release: Target specific users by key, email, or segment.
Percentage rollout: Send, say, 10% of users to the new feature, 90% to the old.
Full rollout: Turn the flag fully on when you’re confident it’s safe.

Example configuration:

Turn Targeting ON.
Under Percentage rollout, set:
- New variation → 10%
- Old variation → 90%

LaunchDarkly will handle consistent bucketing, so users see a stable experience between requests.

If something breaks:

Flip the flag OFF or set the old variation to 100%.
Change takes effect globally in <200ms—no redeploys, no manual config edits.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Feature Flags	Control code paths at runtime with booleans, multivariate flags, and JSON.	Turn features on/off instantly and reduce blast radius.
Targeting & Rollouts	Target users, segments, and percentages per environment.	Safely test in production with progressive, low-risk rollouts.
Developer Plan (Free)	Provides unlimited flags and seats plus observability on a free plan.	Try production-grade control without cost or friction.

Ideal Use Cases

Best for side projects and prototypes:
Because it lets you ship quickly while still having a kill switch if something misbehaves in production.
Best for small teams adopting feature flags for the first time:
Because Developer (free) includes unlimited flags and seats, so engineers, PMs, and designers can share one runtime control surface without worrying about license limits.

Limitations & Considerations

Environment and usage limits:
The Developer plan is optimized for smaller workloads. It includes generous but finite observability usage (e.g., 5K session replays, 10M logs/traces). If you outgrow those, you may need to upgrade to a paid tier.
Governance and compliance needs:
While you get production-grade reliability (99.99% uptime, 45T+ flag evals/day), large enterprises that require advanced policies, custom roles, or strict compliance workflows should consider higher tiers with more governance features.

Pricing & Plans

The Developer plan is:

Free forever
No credit card required
Includes:
- Unlimited feature flags
- Unlimited seats
- 30 idiomatic SDKs
- 5K Session Replays and Errors
- 10M Logs and Traces

As teams grow, they typically move to paid plans to unlock more environments, advanced governance, and larger observability and experimentation usage.

Developer (Free): Best for individual developers or small teams needing feature flags, basic experimentation, and observability for a single project.
Paid Teams / Enterprise Plans: Best for organizations needing multi-project governance, advanced security, higher usage limits, and integrated observability and experimentation at scale.

Frequently Asked Questions

Do I need a credit card to sign up for LaunchDarkly Developer (free)?

Short Answer: No—LaunchDarkly Developer is free forever with no credit card required.

Details:
When you click Get started free on launchdarkly.com, you can create a Developer account using your email. You’ll immediately get access to the Developer plan’s capabilities (unlimited flags and seats, plus observability allocations) without entering payment details. If you decide to upgrade later, you can do that from within the app.

Can I use my first feature flag in production, or is this just for testing?

Short Answer: You can use your first feature flag in production, even on the free Developer plan.

Details:
The Developer plan uses the same runtime control infrastructure as our paid tiers—99.99% uptime, global network, and <200ms flag changes worldwide. As long as you wire the SDK into your production environment with the correct SDK key, you can control production behavior via the LaunchDarkly UI. Many teams start by flagging a single, low-risk feature in production, then expand once they see how easy it is to roll out, monitor, and roll back without redeploys.

Summary

LaunchDarkly Developer (free) gives you a straightforward path from signup to your first feature flag:

Sign up at launchdarkly.com with no credit card.
Use the default project and environment, or define your own.
Install an SDK and initialize with your environment’s SDK key.
Create a feature flag in the UI with a clear key.
Wrap a code path with variation() to control behavior at runtime.
Roll out safely using targeting and percentage rollouts, with the ability to flip a kill switch instantly if something breaks.

You get the speed of shipping whenever you want, and the safety of changing behavior after deploy—without touching the codebase.

Next Step

Get Started