Gradual Canary Rollouts
Route a controlled percentage of production traffic to new code paths. Target by user ID, region, or custom attributes. Expand exposure only after error rates and latency remain stable.
Real-time feature management
Deploy Without Fear.
Rollback Instantly.
Gradually roll out risky code, isolate failures to small user groups, and instantly disable broken releases without redeploying.
Start Free
No credit card required
PaymentsMiddleware.cs
// Evaluated on the hot path with zero network I/O
if (flags.GetBool("payments-v2"))
{
app.UseNewPaymentsPipeline();
}
else
{
app.UseLegacyPaymentsPipeline();
}Instant Kill Switches
Disable a broken release globally in milliseconds. Flag state propagates over persistent SSE connections — no redeploy, no pipeline run, no waiting for container restarts.
Offline-First Reliability
O(1) in-memory reads against an immutable snapshot. When the control plane is unreachable, the SDK serves the last persisted disk cache — your hot path never blocks on network I/O.
SDK ecosystem
Integrate Into Your Stack in Minutes
Production-ready SDKs with O(1) local evaluation, persistent caching, and real-time synchronization.
Backend
Frontend
Mobile
Program.cs
using Soasap.Sdk;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSoasap("your-api-key")
.PreloadFlags();
var app = builder.Build();
app.MapGet("/", (ISOASAPClient flags) =>
{
if (flags.GetBool("new-checkout"))
{
return "New checkout enabled";
}
return "Old checkout";
});
app.Run();
app.ts
import { createSoasapClient } from "@soasap-com/node-sdk";
const flags = createSoasapClient({
apiKey: process.env.SOASAP_API_KEY!,
preload: true,
});
// Sync reads — never throw, never hit the network
if (flags.getBool("new-checkout")) {
console.log("New checkout enabled");
}
app.py
import os
from soasap import create_soasap_client
flags = create_soasap_client(
api_key=os.environ["SOASAP_API_KEY"],
preload=True,
)
# Sync reads — never throw, never hit the network
if flags.get_bool("new-checkout"):
print("New checkout enabled")
CheckoutPage.tsx
import { useSoasapBool } from "@soasap-com/react-sdk";
export function CheckoutPage() {
const newCheckout = useSoasapBool("new-checkout");
return newCheckout
? <NewCheckout />
: <LegacyCheckout />;
}
checkout.component.ts
import { Component, inject, type Signal } from "@angular/core";
import { SoasapService } from "@soasap-com/angular-sdk";
@Component({ selector: "app-checkout" })
export class CheckoutComponent {
private readonly soasap = inject(SoasapService);
readonly newCheckout: Signal<boolean> = this.soasap.bool("new-checkout");
}
CheckoutScreen.tsx
import { useSoasapBool } from "@soasap-com/react-native-sdk";
export function CheckoutScreen() {
const newCheckout = useSoasapBool("new-checkout");
return newCheckout
? <NewCheckout />
: <LegacyCheckout />;
}
CheckoutView.swift
import SoasapSDK
struct CheckoutView: View {
@ObservedObject var flags = SoasapClient.shared
var body: some View {
if flags.bool("payments-v2") {
NewPaymentsView()
} else {
LegacyPaymentsView()
}
}
}
CheckoutScreen.kt
import soasap.sdk.SoasapClient
import soasap.sdk.SoasapOptions
val options = SoasapOptions("your-api-key").apply {
preloadFlags = true
}
SoasapClient(options).use { client ->
if (client.getBool("new-checkout")) {
println("New checkout enabled")
}
}Architecture
Built for Production Systems
SOASAP evaluates feature flags locally using immutable in-memory snapshots synchronized in real time.
Applications never perform request-time network calls during flag evaluation and continue operating normally during API outages.
The SDK is designed to stay outside your request path and remain operational under failure.
- No startup blocking
- Local in-memory evaluation
- Immutable snapshot architecture
- Automatic reconnect with backoff
- Persistent disk cache
- Graceful offline operation
- Thread-safe singleton client
Runtime Architecture
Normal operation
SOASAP Control Plane
Continuous State Sync
Persistent Local Snapshot
Instant Feature Evaluation
Application Runtime
Request path
Incoming Request
GetFlag("payments-v2")
Read Local Snapshot
Return Cached Value
- ~O(1) evaluation
- No request-time I/O
- No async network calls
Failure mode
API Unreachable
Serve Last Snapshot
Continue Processing Requests
- Automatic reconnect
- Exponential backoff
- Persistent disk cache
- Graceful offline operation
Getting started
From Project Creation to Safe Production Rollouts
Create isolated environments, configure feature flags, integrate the SDK, and safely release features without redeploying. Full guide in docs.
Installation
dotnet add package Soasap.SdkProgram.cs
builder.Services
.AddSoasap("your-api-key")
.PreloadFlags();payments-v2
Exposure
10%
Instant disable available — no redeploy required.
FAQ
Does SOASAP delay application initialization?
No. SDKs initialize in the background and never block application execution while synchronizing feature state.
What happens if the SOASAP API goes down?
Applications continue operating normally using the last synchronized local snapshot. Feature evaluation does not depend on live network requests.
Are feature flags evaluated locally?
Yes. Feature flags are evaluated locally using synchronized runtime state for predictable low-latency access.
Does the SDK work offline?
Yes. SOASAP persists synchronized state using local storage and automatically falls back to offline operation during connectivity issues.
Which SDKs are currently available?
Production SDKs: .NET, Node.js, Python, React, Angular, React Native, and Kotlin. Swift is in development.
All SDKs are designed around the same core runtime principles:
- local feature evaluation
- persistent caching
- continuous state synchronization
- graceful offline operation
Is SOASAP suitable for production systems?
Yes. SOASAP is designed for real production environments with synchronized local state, persistent caching, automatic reconnect handling, and graceful failure behavior.
Can I use SOASAP for gradual rollouts and canary releases?
Yes. You can safely roll out features to specific environments, user groups, or rollout percentages before enabling them globally.
Does SOASAP support multiple environments?
Yes. Projects support isolated Development, Staging, and Production environments with independent flags, values, and API keys.
Is SOASAP safe for concurrent applications?
Yes. SOASAP SDKs are designed for long-lived application runtimes and safely support concurrent feature evaluation across modern platforms.
How much does SOASAP cost?
Detailed pricing information is available on the Pricing page.
SOASAP is currently free for early adopters until December 1st, including full access to all Pro plan features.