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

Shipping faster shouldn’t mean gambling with production. With LaunchDarkly Developer (free), you can sign up in minutes, wire in a feature flag, and control what’s live in your app—no redeploys required. This guide walks through exactly how to sign up and create your first feature flag, step by step.

Quick Answer: LaunchDarkly Developer (free) gives you unlimited feature flags and seats so you can start controlling releases immediately. Sign up with your email, create a project and environment, then define a feature flag in the UI and evaluate it from your code using one of LaunchDarkly’s SDKs.

The Quick Overview

What It Is: LaunchDarkly Developer (free) is the forever-free plan that gives individual developers and small teams feature flags, experimentation, and observability to control code behavior at runtime.
Who It Is For: Builders who want to ship faster, test safely, and avoid 2am fire drills—without needing a dedicated platform team or a complex procurement process.
Core Problem Solved: It removes the “deploy or rollback” binary. You can turn features on or off, target users, and roll out progressively in production without shipping another deploy.

How It Works

LaunchDarkly evaluates feature flags at runtime via SDKs connected to the LaunchDarkly service. You define a flag in the UI, configure targeting rules, then call that flag from your application code. Every time your app evaluates the flag, LaunchDarkly returns the right value based on your rules—updated globally in under 200ms.

At a high level, getting started looks like this:

Sign up and set up your account:
Create a LaunchDarkly Developer (free) account, define your first project, and use the default environments (usually Production and Test).
Create your first feature flag in the UI:
Define a flag key (your stable identifier in code), choose its type (boolean is common for first flags), and set default values and targeting.
Connect your app and evaluate the flag:
Install a LaunchDarkly SDK, initialize it with your environment key, and wrap your new feature in a simple if statement driven by the flag.

From there, you can flip the flag, target segments, and roll out progressively—without touching the codebase again.

Step 1: Sign Up for LaunchDarkly Developer (Free)

1. Go to LaunchDarkly

Open https://launchdarkly.com in your browser.
Click Get started free or Start a trial. For individuals or small teams, choose the Developer option.

The Developer plan is free forever, no credit card required, with:

Unlimited seats

Unlimited feature flags

Access to LaunchDarkly’s SDKs and core capabilities

2. Create Your Account

Sign up with your work email (or GitHub/SSO if available).
Enter your name, company/project name, and basic details about your role.
Choose your primary language or framework if prompted—this helps LaunchDarkly show relevant Quickstarts.

Once you complete signup, your 14-day trial of broader functionality may start, but the Developer (free) plan remains available and free after that.

Step 2: Understand Your Default Setup

When you first log in, LaunchDarkly creates a default project and a couple of environments for you.

Project: A logical grouping of flags for one application or product.
Environment: A runtime context, like Production, Staging, or Development, each with its own keys and flag states.

For your first feature flag, you can use:

Project: Default (or rename/create one to match your app)
Environment: Test (for safe experimentation) and Production for when you’re ready

You can manage these under Project settings in the left-hand navigation.

Step 3: Create Your First Feature Flag

Now we’ll create a simple, boolean feature flag—perfect for controlling a new UI element, endpoint, or behavior.

1. Navigate to Flags

In the left nav, click Flags.
Ensure the correct project and environment are selected at the top of the UI.

2. Create the Flag

Click + Flag or Create flag.
Fill in the basics:
- Name: A human-readable name, e.g., New onboarding flow.
- Key: The stable identifier you’ll use in code, e.g., new-onboarding-flow.
- Description: Optional but helpful for future you and your team.
- Flag type: For your first flag, choose Boolean (true/false).
Click Save flag (or equivalent) to create it.

3. Configure Default Rules

After saving, you’ll see the flag’s Targeting page.

You can:

Set the default value for all users (e.g., Off in Production, On in Test).
Add targeting rules to turn the feature on for specific users or segments.

For your first pass, a simple setup works:

In Test: set the default value to On (true).
In Production: set the default value to Off (false) for now.

You can always come back to add rules and percent rollouts once you’re wired into your app.

Step 4: Connect Your Application via an SDK

LaunchDarkly evaluates flags at runtime using 25+ native SDKs (and more). The flow is:

Initialize the SDK in your app with your environment key.
Provide a user (or context) object.
Call variation (or equivalent) with the flag key.

1. Find Your Environment Key

Click the gear icon (Project settings) → select your project.
Go to Environments and select Test (for your first integration).
Copy the SDK key (sometimes labeled Client-side ID or SDK key depending on SDK type).

Keep this key secure based on SDK type (server-side vs client-side).

2. Use a Quickstart

From the LaunchDarkly UI, you’ll see suggestions for SDKs based on your chosen language.

You can also navigate to:

Docs → SDKs to pick your stack, or
Use the in-app Quickstart to get copy-paste code tailored to your language.

Step 5: Evaluate the Flag in Code

Below are simplified examples for a boolean flag called new-onboarding-flow. Always refer to the latest official SDK docs for exact syntax.

Example: Node.js (Server-Side)

npm install launchdarkly-node-server-sdk

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

const sdkKey = process.env.LD_SDK_KEY; // set this to your Test environment key

const client = LDClient.init(sdkKey);

client.waitForInitialization().then(async () => {
  const user = {
    key: 'user-123',
    email: 'user@example.com'
  };

  const showNewOnboarding = await client.variation(
    'new-onboarding-flow', // flag key from the UI
    user,
    false // default value if anything fails
  );

  if (showNewOnboarding) {
    // New experience
    console.log('Showing NEW onboarding flow');
  } else {
    // Old experience
    console.log('Showing EXISTING onboarding flow');
  }

  // Optionally close the client on shutdown
  // await client.flush();
  // client.close();
});

Example: JavaScript (Client-Side Web)

npm install launchdarkly-js-client-sdk

import * as LDClient from 'launchdarkly-js-client-sdk';

const clientSideId = 'YOUR_CLIENT_SIDE_ID'; // from Test environment
const user = { key: 'user-123' };

const client = LDClient.initialize(clientSideId, user);

client.on('ready', () => {
  const showNewOnboarding = client.variation(
    'new-onboarding-flow',
    false // default value
  );

  if (showNewOnboarding) {
    renderNewOnboarding();
  } else {
    renderExistingOnboarding();
  }
});

Once this is wired in, you’re live: toggling the flag in the LaunchDarkly UI changes behavior in your app in under 200ms, no redeploy required.

Step 6: Flip the Flag and Watch It Change

With code integrated and flag evaluations flowing:

Go back to the LaunchDarkly UI → Flags.
Select your new-onboarding-flow flag in the Test environment.
Toggle Targeting from Off to On (or vice versa).
Watch your app change behavior in real time.

This is the core runtime control surface: you can now manage blast radius and recover instantly if something breaks by flipping a kill switch—not shipping another deploy.

Features & Benefits Breakdown

Core Feature	What It Does	Primary Benefit
Feature Flags	Control code paths with boolean, multivariate, or JSON flags at runtime.	Turn features on/off instantly, reduce blast radius, and avoid rollback deploys.
Targeting & Segmentation	Serve different flag values to specific users, segments, or environments.	Safely test with subsets of traffic and personalize experiences without branching releases.
Progressive Rollouts & Kill Switches	Gradually roll out to % of users and instantly disable if issues appear.	Reduce risk of regressions, recover from incidents in seconds, and keep releases boring.

Ideal Use Cases

Best for trying out a new feature in production safely:
Because you can enable it for internal users or a small beta cohort first, then roll out progressively as metrics and errors look healthy.
Best for replacing long-lived branches with runtime control:
Because you can merge code behind a flag, deploy it dark, and only expose it when you’re ready—reducing merge conflicts and integration pain.

Limitations & Considerations

You still need to integrate an SDK:
LaunchDarkly is not “magic config.” You’ll need to add a small amount of code to initialize the SDK and evaluate flags. Use the in-app Quickstart to copy/paste minimal setup for your stack.
Flag lifecycle requires discipline:
Feature flags are powerful but can become technical debt if left around forever. Use LaunchDarkly’s flag statuses, TTLs, and cleanup workflows to retire flags that are no longer needed.

Pricing & Plans

The Developer plan is designed for individual developers and small teams who want production-grade feature management without friction.

Key details from the Developer plan:

Free forever
No credit card required
Unlimited seats
Unlimited feature flags
Access to 30 idiomatic SDKs
Included observability quotas (for logs, traces, and replay/error events) with calculators to plan usage

Example plan positioning:

Developer (Free): Best for solo developers or small teams needing runtime feature flags, basic experimentation, and observability to control releases without procurement overhead.
Paid Plans (Team/Enterprise): Best for larger teams needing advanced governance (release pipelines, policies, approvals, audit logs), higher observability volumes, and enterprise-scale support and security.

You can start on Developer and upgrade later without redoing your flag implementation—your flags and SDK integration stay the same.

Frequently Asked Questions

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

Short Answer: No, you can use the Developer plan free forever without a credit card.

Details:
When you sign up from launchdarkly.com and choose the Developer option, you get immediate access to the platform with no billing setup required. You may see a 14-day trial for additional features, but the core Developer plan—unlimited seats and flags—is free and continues to work after the trial ends.

How long does it take to create my first feature flag and see it working?

Short Answer: Typically under 30 minutes, often faster if you follow the Quickstart.

Details:
The workflow is intentionally minimal:

Sign up and log in (a few minutes).
Create a boolean feature flag in your project and Test environment.
Install the SDK for your language, paste the Quickstart initialization code, and wrap your feature in a single if check.
Flip the flag in the UI and see behavior change live.

Because LaunchDarkly propagates flag changes globally in <200ms, you can iterate quickly: adjust targeting, tweak rollouts, and verify behavior without redeploys.

Summary

Using LaunchDarkly Developer (free), you can move from “deploy-or-rollback” to runtime control in minutes. Sign up with no credit card, create your first feature flag, wire in an SDK, and you’ve got a safe kill switch for new features in production. From there, you can expand into progressive rollouts, targeting, and experimentation—reducing blast radius and making releases boring instead of stressful.

Next Step

Get Started