Quickstart

Get FeatureSignals running locally in under 5 minutes using Docker Compose.

:::tip Try without installing Want to explore FeatureSignals without any setup? Start a free trial — sign up with your email to get full Pro access for 14 days, no credit card required. :::

Prerequisites

• Docker and Docker Compose v2+
• Node.js 18+ (for SDK integration)

1. Clone and Start

git clone https://github.com/dinesh-g1/featuresignals.git
cd featuresignals
docker compose up -d

This starts:

• PostgreSQL on port 5432
• API Server on port 8080
• Flag Engine on port 3000

Database migrations run automatically on startup.

2. Create Your Account

Open https://app.featuresignals.com and register a new account. This creates:

• Your user account
• A default organization
• A Default Project with three environments: dev, staging, production

3. Create a Feature Flag

1. Navigate to Flags in the sidebar
2. Click Create Flag
3. Enter:
   • Key: new-checkout
   • Name: New Checkout Flow
   • Type: boolean
4. Click Create

4. Enable the Flag

1. Open the flag detail page
2. Switch to the dev environment tab
3. Toggle the flag ON

5. Evaluate in Your App

Create an API Key

1. Go to Settings → API Keys
2. Create a server API key for the dev environment
3. Copy the key (shown only once)

Install an SDK

Node.js

npm install @featuresignals/node

import { FeatureSignalsClient } from '@featuresignals/node';

const client = new FeatureSignalsClient('YOUR_API_KEY', {
  envKey: 'dev',
  baseURL: 'https://api.featuresignals.com',
});

await client.waitForReady();

const enabled = client.boolVariation('new-checkout', { key: 'user-123' }, false);
console.log('New checkout enabled:', enabled);

Go

go get github.com/featuresignals/sdk-go

package main

import (
    "fmt"
    fs "github.com/featuresignals/sdk-go"
)

func main() {
    client := fs.NewClient("YOUR_API_KEY", "dev",
        fs.WithBaseURL("https://api.featuresignals.com"),
    )
    defer client.Close()
    <-client.Ready()

    enabled := client.BoolVariation("new-checkout", fs.NewContext("user-123"), false)
    fmt.Println("New checkout enabled:", enabled)
}

Python

pip install featuresignals

from featuresignals import FeatureSignalsClient, ClientOptions, EvalContext

client = FeatureSignalsClient(
    "YOUR_API_KEY",
    ClientOptions(env_key="dev", base_url="https://api.featuresignals.com"),
)
client.wait_for_ready()

enabled = client.bool_variation("new-checkout", EvalContext(key="user-123"), False)
print("New checkout enabled:", enabled)

Java

<dependency>
  <groupId>com.featuresignals</groupId>
  <artifactId>sdk-java</artifactId>
  <version>0.1.0</version>
</dependency>

import com.featuresignals.sdk.*;

var options = new ClientOptions("dev").baseURL("https://api.featuresignals.com");
var client = new FeatureSignalsClient("YOUR_API_KEY", options);
client.waitForReady(5000);

boolean enabled = client.boolVariation("new-checkout", new EvalContext("user-123"), false);
System.out.println("New checkout enabled: " + enabled);

.NET

dotnet add package FeatureSignals

using FeatureSignals;

var options = new ClientOptions { EnvKey = "dev" };
using var client = new FeatureSignalsClient("YOUR_API_KEY", options);
await client.WaitForReadyAsync();

bool enabled = client.BoolVariation("new-checkout", new EvalContext("user-123"), false);
Console.WriteLine($"New checkout enabled: {enabled}");

Ruby

gem install featuresignals

require "featuresignals"

options = FeatureSignals::ClientOptions.new(env_key: "dev", base_url: "https://api.featuresignals.com")
client = FeatureSignals::Client.new("YOUR_API_KEY", options)
client.wait_for_ready

enabled = client.bool_variation("new-checkout", FeatureSignals::EvalContext.new(key: "user-123"), false)
puts "New checkout enabled: #{enabled}"

React

npm install @featuresignals/react

import { FeatureSignalsProvider, useFlag } from '@featuresignals/react';

function App() {
  return (
    <FeatureSignalsProvider sdkKey="YOUR_API_KEY" envKey="dev">
      <Checkout />
    </FeatureSignalsProvider>
  );
}

function Checkout() {
  const enabled = useFlag('new-checkout', false);
  return <div>New checkout: {enabled ? 'v2' : 'v1'}</div>;
}

Vue

npm install @featuresignals/vue

// main.ts
import { createApp } from "vue";
import { FeatureSignalsPlugin } from "@featuresignals/vue";

createApp(App)
  .use(FeatureSignalsPlugin, { sdkKey: "YOUR_API_KEY", envKey: "dev" })
  .mount("#app");

<script setup>
import { useFlag } from "@featuresignals/vue";
const enabled = useFlag("new-checkout", false);
</script>

6. Toggle and Observe

Go back to the Flag Engine, toggle the flag OFF, and re-run your app. The value changes instantly (or within the polling interval).

Next Steps

• Create Your First Flag — deeper walkthrough
• Core Concepts — understand flag types, targeting, and rollouts
• SDK Documentation — full SDK reference for all languages