Open Source Project • Built by TechParaglide
Rollout.io

The Architecture of
Instant Change.

A centralized, ultra-low latency feature flag and configuration management system. Designed for complex distributed microservices architectures dealing with dynamic rendering and runtime execution layers.

Explore the Architecture
apigateway ~ rollout-cli

Welcome to Rollout.io CLI

> rollout init --gateway "eureka-primary"

[OK] Bound to Spring Cloud Gateway

> rollout status

[INFO] Identifying Microservices...

[INFO] UserService: ONLINE

[INFO] AuthService: ONLINE

> rollout flag toggle --id 901 --state true

[WARN] Pushing configuration to 4,000 Edge Nodes...

[OK] Distributed Flag Update Complete (L: 21ms)

_
Stateless & Secure

Zero Downtime. Maximum Control.

Rollout.io removes the risk from continuous deployment by separating code releases from feature releases. Safely manage your flag lifecycles with deterministic scale, free of any internal dependencies.

🌋

Stateless Evaluation

Rollout's evaluation engine is completely stateless. We do not store any user tracking data in the database, ensuring you are 100% GDPR compliant and immune to any PII database bloat even at 50M+ users.

⚡

Backend-Side Math

Unlike fragile SDK evaluation, context processing happens safely server-side guaranteeing maximum performance. It prevents configurations from bloating heavily on the client and strictly secures evaluating algorithms.

🛡️

SaaS Machine Auth

SDK and Admin authentications are cleanly separated. Your applications use robust hashed API project secrets while humans authenticate securely via JWTs, following an enterprise-grade dual-auth system.

Core Engine

Advanced Targeting & Control

Rollout goes beyond basic boolean toggles. It provides a complete mathematical rules engine combined with robust lifecycle management for flags.

  • Context-Aware Targeting Rules Evaluate feature variants based on deeply parsed request headers. Target users by custom attributes (e.g., role, plan, country) to enable segmented launches securely.
  • Dynamic Scheduling & Expiry Automate your releases. Schedule flags to turn on exactly on launch day and set them to expire automatically after a limited-time event.
  • Versioning and Instant Rollbacks Every configuration modification is version-controlled. If a metric plunges post-deployment, isolate the issue and perform an instant rollback to a previous version globally.
  • JSON & Schema Validation Beyond booleans, deliver complex configurations as JSON payloads. Every payload is strictly validated against custom JSON-schema rules to prevent catastrophic errors from malformed data reaching production apps.
// Flag Evaluation Lifecycle
function evaluateFlag(flag, user) {
  if (!checkDependencies(flag)) return false;
  if (!checkSchedule(flag)) return false;
  if (evaluateTargeting(flag, user)) return serveVariant;
  if (mathHash(user.id + flag.key) % 100 < flag.rollout) return true;
  return flag.default;
}
Platform Capabilities

Enterprise-Grade Feature Management

Rollout.io is engineered to provide absolute safety in continuous deployments with advanced mathematical rollouts and strict environment isolation.

Deterministic Percentage Rollouts

Execute highly stable Canary releases and A/B tests through pure stateless evaluation. We utilize stable hash functions (SHA-256 / MurmurHash) on a combination of UserID and FlagKey. This guarantees that users seamlessly land in the same percentage buckets (e.g., the first 20%) deterministically without storing any personally identifiable information (PII liability) in the database.

{
  "flagKey": "new_checkout",
  "rolloutPercentage": 20,
  "evaluation": "hash(uId + flagKey) % 100",
  "isStoredInDB": false
}

Multi-Environment Isolation

Treat your configurations professionally. Manage completely isolated states across Development, Staging, and Production environments safely mapped via environment-specific SDK keys preventing cross-deployment accidental leakage.

Real-Time WebSocket Sync

Achieve instant flag state propagation via MongoDB Change Streams bridged through our distributed WebSocket layer. No heavy polling. App instances adjust instantly to live traffic adjustments.

Core: new_ui_enabled
↓
Dependant: layout_config

Directed Acyclic Dependency Graphs

Build complex runtime restrictions by chaining flags together. Create "Dependent Flags" that only activate conditionally when their parent "Core Flags" evaluate to true. Rollout mathematically locks this into a strict DAG (Directed Acyclic Graph) engine, rendering infinite evaluation loops completely impossible and keeping evaluation pipelines infinitely scalable.

Deployment Workflow

Ship faster, with zero anxiety.

From creation to global deployment in milliseconds. Rollout seamlessly integrates into your existing CI/CD pipelines.

01

Create & Target

Define your flag, set targeting rules using custom user attributes, and configure complex evaluation logic directly in the Web Dashboard.

02

Integrate SDK

Initialize the lightweight SDK in your application. The SDK establishes a secure connection and syncs with the distributed memory store instantly.

03

Launch & Monitor

Gradually roll out the feature via percentage dialing. Monitor metrics live and utilize the instant kill switch globally if anomalies are detected.

Scenarios

Powering Modern Development.

Whether you are releasing a risky backend database migration or rolling out a new frontend UI, Rollout provides an exact execution strategy.

🚀

Canary Releases

Test in production safely. Rollout to 1% of internal users, monitor logs, and slowly ramp up to 100%.

⚖️

Targeted A/B Testing

Serve different variants to specific subsets of users deterministically and analyze the winning experience.

🔒

Subscription Tiering

Gate premium features based on user account attributes evaluated on the fly without database queries.

🛑

Instant Kill Switches

Stop catastrophic failures instantly. Disable a broken feature globally in microseconds without a code redeploy.

15ms
Global Edge Latency
100%
Stateless Execution
0
Database Bottlenecks
∞
Scalability Limit
Infrastructure

Built for Enterprise Scale.

Rollout.io is designed from the ground up to securely manage configuration for thousands of globally distributed microservices.

100% GDPR Compliant

Because Rollout utilizes stateless, deterministic evaluation algorithms, your users' Personally Identifiable Information (PII) never touches our servers. No tracking, no user databases, zero liability.

Redis Edge Caching

Flags and configuration states are incredibly heavily cached via Redis Memory Stores. Achieve microseconds internal response times for high-volume gateway polling without risking database degradation.

RBAC & Audit Logging

Enforce strict Role-Based Access Controls across teams. Every single flag modification, target rule append, and kill switch trigger is immutably logged for total transparency.

Developer Experience

Integrate in Minutes.

Rollout.io provides clean, strongly-typed initialization patterns and stateless evaluation calls. Configure your client once and immediately gain granular feature management power.

Simple API Key Auth
Environment Hashed Tokens
Fallback Safe Execution
ClientInit.js
FlagEvaluation.js
LiveStream.js
// 1. Initialize strictly with an API Key and Context
await Rollout.init({
  sdkKey: "sk_prod_a98b...",
  user: {
    id: "user_12345",  // Used globally for math-hash bucket
    attributes: {
      country: "IN",
      plan: "premium"
    }
  },
  options: {
    enableRealtime: true, 
    cacheTTLSeconds: 300
  }
});
Tech Specs

Frequently Asked Questions

Deep dive into the engineering decisions behind Rollout.io

Is Rollout.io suitable for frontend or backend?

Both. The architecture supports lightweight frontend clients via secure REST/WebSockets combinations, and high-performance backend SDKs utilizing server-side hash evaluation directly inside your microservices.

How does the deterministic math hashing work?

We use algorithms like MurmurHash3 or SHA-256 on a concatenated string of `flagKey + userId`. The resulting hash is converted to a large integer and modulo 100 is applied to place the user in a completely stable 1-100 bucketing pool.

What happens if the internal service goes down?

SDKs are designed with aggressive local caching and fallback mechanisms. If the Rollout gateway is completely unreachable, the SDK gracefully serves the predefined default values hardcoded as fallbacks in your application preventing any disruption.

How is user privacy and data security maintained?

Because the bucketing math happens on the application side or via stateless gateway streaming, we never need to store your users' IDs, IPs, or properties in our database. This effectively eliminates PII liabilities and guarantees GDPR compliance automatically.

Academic Project

Built by TechParaglide

Rollout.io is a Final Year (8th Semester) Internship Project developed by the students of Government Engineering College (GEC), Gandhinagar (IT Branch).

PT

Parthsinh Thakor

Group Member

DA

Dharmik Asalaliya

Group Member

MP

Meet Parmar

Group Member

Ready to change the way
you route?

Dive into the Source View Source