Quick Start

This guide walks you through the minimum path from an empty SOASAP account to a working local flag evaluation. Complete the dashboard steps first, then copy the SDK example for your stack.

What you will accomplish

By following this guide, you will:

• Create a project
• Create a feature flag
• Copy your API key
• Install an SDK
• Evaluate a flag locally

By the end of this guide, your application will read a feature flag from SOASAP using local evaluation and real-time synchronization.

Steps

1. Step 1 — Create a project

   Sign up if you need an account, then create a project for your application. A project scopes your flags and environments. SOASAP creates Development, Staging, and Production environments automatically.

2. Step 2 — Create a feature flag

   Add a boolean flag — for example new-checkout. The flag key is defined once at project scope; you set its value per environment in the dashboard.

3. Step 3 — Copy the API key

   Each environment receives an API key automatically when it is created. Open your project's Development environment in the dashboard and copy the key — it tells the SDK which configuration to synchronize.

   Dashboard flow

   Organization

   ↓

   Project

   ↓

   Development Environment

   ↓

   API Key

   ↓

   SDK

   The SDK connects to a specific environment using its API key. The environment determines which flag values the application receives.

4. Step 4 — Install an SDK

   Install the official SDK for your platform using the commands below. All SDKs share the same runtime model: local snapshot, SSE sync, and persistent cache.

5. Step 5 — Initialize the client

   Register the SDK at application startup with your Development API key. Enable preload where supported for the best startup experience.

6. Step 6 — Evaluate the flag

   Read the flag in your application code. The SDK returns the current value from its in-memory snapshot — no network call on the read path.

Install and initialize your SDK

Replace YOUR_API_KEY with your Development environment key from Step 3.

.NET

dotnet add package Soasap.Sdk

builder.Services.AddSoasap("YOUR_API_KEY").PreloadFlags();
// Inject ISOASAPClient: flags.GetBool("new-checkout")

Node.js

npm install @soasap-com/node-sdk

import { createSoasapClient } from '@soasap-com/node-sdk';

const flags = createSoasapClient({
  apiKey: process.env.SOASAP_API_KEY!,
  preload: true,
});
flags.getBool("new-checkout");

Python

pip install soasap

from soasap import create_soasap_client

flags = create_soasap_client(api_key="YOUR_API_KEY", preload=True)
flags.get_bool("new-checkout")

React

npm install @soasap-com/react-sdk react

import { SoasapProvider, useSoasapBool } from '@soasap-com/react-sdk';

<SoasapProvider options={{ apiKey: "YOUR_API_KEY", preload: true }}>
  {/* useSoasapBool("new-checkout") in children */}
</SoasapProvider>

Angular

npm install @soasap-com/angular-sdk

provideSoasap({ apiKey: "YOUR_API_KEY", preload: true })
// inject SoasapService and read reactive signals

React Native

npm install @soasap-com/react-native-sdk @react-native-async-storage/async-storage react react-native

<SoasapProvider options={{ apiKey: "YOUR_API_KEY", preload: true }}>
  {/* useSoasapBool("new-checkout") */}
</SoasapProvider>

Kotlin

implementation("com.soasap:soasap:1.0.3")

val options = SoasapOptions("YOUR_API_KEY").apply { preloadFlags = true }
SoasapClient(options).use { client ->
    client.getBool("new-checkout")
}

Expected result

With the flag disabled in the Development environment:

getBool("new-checkout") → false

After you enable the flag in the dashboard:

getBool("new-checkout") → true

Dashboard changes are synchronized automatically over SSE and become available locally — without redeploying your application.

Success checklist

• ✓ Project created
• ✓ Boolean flag created
• ✓ Development API key copied
• ✓ SDK initialized
• ✓ getBool("new-checkout") returns a value
• ✓ Dashboard changes update the application without redeploying

What happens behind the scenes?

• The SDK downloads environment configuration on startup and when changes occur
• Configuration is stored locally in memory and on disk for cold starts
• Flags are evaluated from memory — constant-time reads from the snapshot
• No network requests occur during evaluation

Need more details?

This guide intentionally focuses on the fastest path to your first flag evaluation.

For advanced setup, configuration, and runtime behavior, continue with the guides below.

Next steps

• Create Your First Flag — learn flag types, defaults, and environment values.
• SDK Installation — platform-specific installation and configuration guides.
• Architecture — understand local evaluation, SSE synchronization, persistent cache, and offline operation.