Rollout.io

Rollout.io Architecture

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.

Java 17 Spring Boot React 18 Redis MongoDB License

Status: Completed and Deployed

LIVE PROJECT
PROJECT REPORT
CLIENT SDKS
MIT LICENSE
APACHE LICENSE
EMAIL SUPPORT

Overview

Rollout.io Remote Config is an enterprise-grade feature management platform that enables engineering teams to decouple deployment from release. By centralizing feature flags and configurations, applications can dynamically control features at runtime without initiating a redeployment sequence. It supports safe and targeted rollouts, instantaneous rollbacks, and synchronized configuration state across distributed systems, dramatically improving reliability in high-availability production environments.

Live Production Demo

The complete Rollout.io ecosystem has been deployed and is accessible at rollout.paraglide.in.

Through the integrated Nginx edge proxy configuration, all microservices, management interfaces, and demonstration components are accessible under the primary domain:


Rollout.io Ecosystem Boot Sequence


Distributed System Architecture

The core of Rollout.io is built on a highly scalable, fault-tolerant microservices architecture pattern, orchestrated via Docker and Spring Cloud.

Rollout.io System Design

The ecosystem comprises the following internal microservices and infrastructure components:


Rollout.io System Design and Flow


Zero-Trust Context Isolation Pattern

Rollout.io implements a Zero-Trust System Design where the Jwt token serves as an immutable context boundary directly in the service layer. Rather than treating the token merely as an edge-validation mechanism at the Gateway, identity is directly extracted and enforced inside downstream microservices and repositories (e.g., findByIdAndCreatedByUid).

For a deeper dive into the theoretical foundation and trade-offs of this design pattern, read the complete engineering article: Zero-Trust System Design: How We Used JWT as an Immutable Context Boundary in Spring Boot.

Rollout.io Zero-Trust Identity Context Propagation Flow

Event-Driven Cascading Deletion

Rollout.io implements an asynchronous, event-driven cascade deletion pipeline using RabbitMQ to guarantee database integrity. When a developer deletes their account, the downstream deletion executes in a non-blocking sequence:

  1. User Deletion Event: The Auth Service deletes the user record and publishes a UserDeletedEvent to RabbitMQ.
  2. Project Cleanup: The Control Plane Service consumes this event, queries all projects owned by the user, publishes a ProjectDeletedEvent for each, and deletes the projects.
  3. Environment Cleanup: The service consumes the project events, identifies nested environments, publishes an EnvironmentDeletedEvent for each, and deletes the environments.
  4. Flag and Audit Log Purge: The service consumes the environment events, executing the terminal deletion of all associated flags, rules, and audit logs.
Rollout.io Event-Driven Cascading Deletion Flow

Security Email Notifications

Rollout.io implements a fully asynchronous security email notification system using Resend SMTP:

Centralized Configuration Server

All microservices in the Rollout.io ecosystem decouple their environment properties and secrets using Spring Cloud Config Server. At boot time:

Rollout.io Centralized Configuration Server Lifecycle

Consistent Hashing & Percentage Rollout Resolution

To deliver deterministic user-level percentage rollouts (e.g., serving a beta feature to 25% of users) without storing state on the server or sync bottlenecks, Rollout.io uses a math-based distribution model.

Rollout.io Consistent Hashing and Percentage Rollout Algorithm

Runtime Contextual Targeting Rules

To enable precise segmentation (such as releasing features only to internal QA emails, users in India, or mobile devices) without network latency, Rollout.io resolves rules dynamically on the client side:

Rollout.io Runtime Targeting Rule Resolution Flow

Dynamic Flag Dependency Resolution

Rollout.io implements a strict graph-based prerequisite validation pipeline governed by structural system constraints:

Rollout.io Dynamic Flag Dependency Tree (DAG)

Repository Structure

├── ASSETS/         # Core system architecture and screenshot assets
├── DEPLOY/         # Docker Compose orchestration configurations
├── REPORT/         # Project documentation and engineering report
├── SDK/            # Client integration SDKs (Java and JavaScript)
├── SERVER/         # Spring Boot & Spring Cloud microservices
├── TEST/           # Demo integration applications (e.g., Zomato Clone)
└── UI/             # Admin Control Plane Dashboard (React/Vite frontend)

Core Capabilities

Feature Comparison Matrix

Capability Rollout.io LaunchDarkly Unleash Firebase
System Architecture Distributed microservices orchestrated via Docker Compose Monolithic hosted SaaS with optional Relay Proxy Single-server or managed SaaS Fully managed serverless backend
Identity and Access Control Zero-Trust JWT enforced at every service layer; repositories bind identity directly (findByIdAndCreatedByUid) API key-based project scoping with optional SSO API token auth with role-based access control Firebase Auth with Google Identity Platform
Flag Value Types Boolean, String, Integer, Double, JSON Boolean, String, Number, JSON Boolean, String with strategy variants String, Boolean, Number, JSON
Targeting Rules Attribute-based rules with 7 operators: EQUALS, NOT_EQUALS, CONTAINS, GT, GTE, LT, LTE Attribute-based targeting with custom rules Strategy-based targeting with custom constraints Conditions-based targeting by user property
Percentage Rollout MurmurHash3 deterministic bucketing for consistent user-level percentage rollouts Consistent hashing for percentage rollouts Gradual rollout via activation strategies Percentage rollouts by user property
Flag Dependency Graph Recursive AND/OR dependency tree (RuleNode) with parent-child prerequisite evaluation Sequential prerequisite dependency chains No native flag dependency support No native flag dependency support
Real-Time Dashboard Updates MongoDB Change Streams piped through authenticated WebSocket connections Webhook notifications and SSE streaming SSE streaming with webhook support No real-time dashboard sync
Cache and Evaluation Latency Redis-backed cache with 30s background sync and MongoDB fallback Edge-cached via Relay Proxy with SDK-side caching In-memory SDK-side caching with polling Client-side SDK caching with fetch intervals
Event-Driven Data Lifecycle 4-stage async cascade deletion via RabbitMQ Topic Exchange Manual deletion; no automated cascade Manual deletion via API Manual deletion via Console
Service Discovery Netflix Eureka with auto-registration and dynamic gateway routing Not applicable; single SaaS endpoint Not applicable; single-server model Not applicable; Google-managed
Configuration Management Spring Cloud Config Server with Git-backed properties and RabbitMQ Cloud Bus propagation SaaS dashboard settings Environment variables and database config Firebase Console parameters
Gateway and Rate Limiting Spring Cloud Gateway + Nginx edge proxy with Redis per-user rate limiting Built-in SaaS rate limiting by tier No built-in rate limiting Google Cloud infrastructure-level
Observability Stack Prometheus + Grafana scraping Actuator metrics from all services Proprietary analytics dashboard Prometheus-compatible metrics endpoint Firebase Analytics and Cloud Monitoring
Client SDKs Java (JitPack) and JavaScript (npm) with async telemetry and polling 25+ language SDKs with streaming and offline mode 15+ language SDKs with polling Android, iOS, Web, Unity SDKs
Deployment Model Self-hosted Docker Compose with 14 containers and health checks SaaS-only with optional Relay Proxy Self-hosted or managed SaaS SaaS-only
Licensing Completely free and open-source under dual MIT and Apache 2.0; no paid tiers, no vendor lock-in Proprietary; enterprise pricing at scale Open-source core with paid enterprise tier Free tier with usage-based pricing at scale

Technical Foundation

The platform leverages a modern, highly scalable distributed technology stack:

Tech Stack Icons Row 1
Tech Stack Icons Row 2

Application & Dashboard Demos

Here is a visual overview of the Rollout.io Admin Dashboard and the Zomato clone test application:


Rollout.io Control Plane Dashboard
The main workspace dashboard where developers can view, create, and manage multiple remote config projects.
Project Management Window
Creating and managing multiple distinct operational configurations for feature isolation.

Core Flag Management Window
Interactive environment-specific feature toggle and remote configuration console.
Integrated JSON Editor in Dashboard
A fully interactive JSON editor allowing developers to update complex configuration objects safely at runtime.

Dependent Flags Management
Configuring parent-child dependencies where a feature flag only evaluates to true if its parent flag is enabled first.
Light Mode Test Application
Displaying the default white theme when the zomato-dark-mode feature flag is disabled.

Test Application Dark Mode View
Testing features such as full-page dark mode using the zomato-dark-mode flag instantly.
Zomato Offer Banner Live Testing
Real-time dynamic checkout logic and exclusive member discount banners evaluated from backend rules.

API Gateway & Documentation

For comprehensive API documentation and interactive testing, the centralized API Gateway includes built-in Swagger/OpenAPI documentation.

Additionally, a pre-configured Postman collection file is available to easily test API calls directly:

To view the interface and test endpoints directly:

API Gateway Documentation Interface

Service Registry & Discovery with Netflix Eureka

To support dynamic scaling, load balancing, and zero-downtime routing, all microservices in the Rollout.io ecosystem register themselves with the centralized Netflix Eureka Service Registry (operating on port 5000 / /registry/ path).

Netflix Eureka Service Registry Dashboard

Telemetry & Metrics Monitoring with Grafana

Rollout.io includes a pre-configured Prometheus and Grafana telemetry stack for real-time microservices performance and health monitoring.

To configure and view the dashboard:

  1. Navigate to the monitoring interface (by default on port 5001 or as configured).
  2. Head over to the Service Monitoring section in the sidebar.
  3. Connect your Prometheus instance as the target data source to fetch real-time telemetry.
  4. Import the Spring APM Dashboard to visualize CPU, memory, and API request performance.
  5. Create and configure the datasource variable to ensure dynamic mapping of Spring Boot metrics across the microservices ecosystem.
Grafana Telemetry Monitoring

Quick Start Guide

Prerequisites

Make sure your system meets the minimum requirements and has the necessary dependencies installed:

1. Initialize the Ecosystem via Docker Compose

The complete Rollout.io ecosystem—including microservices, front-end portals, support databases, and monitoring telemetry—is containerized and orchestrated using Docker Compose.

To boot the entire architecture:

cd DEPLOY
docker-compose up -d

Note: Due to the sequential startup dependencies inside the microservices topology, the orchestration uses delayed container initialization to ensure RabbitMQ and the Eureka Service Registry are fully operational before dependent services boot. The initial startup sequence may require 2 to 3 minutes to complete.

To monitor the startup state and verify active containers:

docker ps

Once the stack is operational, the integrated Nginx edge proxy serves all components on port 80, replicating the production environment structure locally:

Local Development Options

If you wish to run individual front-end components in development mode (e.g., for making live code changes) instead of using the pre-built containerized versions, you can shut down the respective containers in Docker and run the local development servers using the steps below.

2. Configure and Execute the Admin Control Plane (UI)

The Admin Dashboard requires Firebase Authentication for secure identity management.

Authentication Setup: Navigate to UI/src/firebase.js and inject your Firebase project configuration parameters:

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_PROJECT.firebaseapp.com",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_PROJECT.firebasestorage.app",
  messagingSenderId: "YOUR_SENDER_ID",
  appId: "YOUR_APP_ID",
  measurementId: "YOUR_MEASUREMENT_ID"
};

Bootstrapping the UI Server:

cd UI
npm install
npm run dev

3. Execute the Integration Test Environment (Zomato Clone)

To validate the Rollout.io SDK integration and observe real-time feature flagging, boot the pre-configured sample test application.

cd TEST/zomato-clone
npm install
npm start

Supported Client SDKs

JavaScript SDK (@rollout.io/sdk-js) Professional-grade, high-performance SDK designed for web-based rendering environments (Browser & Node.js).

Install the SDK via npm:

npm install "@rollout.io/sdk-js@latest"

Usage Example:

import sdk from '@rollout.io/sdk-js';

// Initialize the SDK
await sdk.init({
  sdkKey: "YOUR_SDK_KEY",
  userId: "user-unique-id",
  baseUrl: "http://rollout.paraglide.in/gateway" // Live Production Gateway (or "http://localhost:80/gateway" for local)
});

// Evaluate flag value instantly (Fallback value is false)
const isFeatureEnabled = sdk.getFlag("zomato-dark-mode", false);

if (isFeatureEnabled) {
  // Execute feature specific logic
  console.log("Dark mode feature is active.");
}

Detailed implementation schematics available at: SDK/javascript/README.md

Java SDK (com.github.TechParaglide.Rollout.io:sdk-java) Enterprise-grade SDK built utilizing native HttpClient for server-side Java and Spring Boot runtimes.

Since the Java SDK is distributed via JitPack, you must include the repository in your pom.xml:

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

Then, add the dependency:

<dependency>
    <groupId>com.github.TechParaglide</groupId>
    <artifactId>Rollout.io</artifactId>
    <version>5.0.5</version>
</dependency>

Usage Example:

import com.rollout.io.sdk.RolloutClient;
import com.rollout.io.sdk.RolloutConfig;

// Initialize the SDK
RolloutClient client = new RolloutClient();
RolloutConfig config = new RolloutConfig(
    "YOUR_SDK_KEY",
    "user-unique-id",
    "http://rollout.paraglide.in/gateway" // Live Production Gateway (or "http://localhost:80/gateway" for local)
);

client.init(config);

// Evaluate flag value instantly (Fallback value is false)
boolean isNewCheckoutEnabled = client.getFlag("new-checkout", false);

if (isNewCheckoutEnabled) {
    // Execute feature specific logic
    System.out.println("Checkout feature is active.");
}

Detailed implementation schematics available at: SDK/java/README.md

Architectural Decision Records (ADRs)

To document the technical direction and engineering trade-offs made during development, the following architectural decisions were established:

ADR-001: Document-Oriented Storage (MongoDB) for Dynamic Rule Trees

ADR-002: Zero-Trust Identity Context Propagation

ADR-003: Double-Buffered Low-Latency Cache (Redis + MongoDB)

ADR-004: Asynchronous Deletion Cascades via RabbitMQ

Future Scope / Roadmap

While the core ecosystem is complete and fully functional, future enhancements could include:

Academic Context & Project Documentation

This system was architected and developed as a Final Year Project by scholars of the Information Technology Department at Government Engineering College, Gandhinagar.

Core Engineering Team:

Name Enrollment No Worked on Modules LinkedIn Profile
Parthsinh R. Thakor 220130116064 Backend, Docker, Launch website, SDK, Test app LinkedIn
Dharmik S. Aslaliya 220130116002 Dashboard Module LinkedIn
Meet N. Parmar 220130116036 Dashboard Module LinkedIn

Acknowledgments

We would like to express our deepest gratitude to the individuals and organizations who supported this project:

Document / Resource File Path Description
Academic Project Report REPORT/Rollout.io - Project Report.pdf Complete engineering capstone report containing microservice designs, sequence diagrams, and architecture analysis.
Java Integration SDK SDK/java/README.md Integration guide, dependency setup, and usage examples for the Java SDK.
JavaScript Integration SDK SDK/javascript/README.md Integration guide, package details, and usage examples for the JavaScript SDK.
Production Docker Compose DEPLOY/docker-compose.yml Configuration for spinning up the production-ready microservices stack including Redis, RabbitMQ, and monitoring.
Development Docker Compose SERVER/docker-compose.yml Configuration for running microservices in development mode.
Postman API Collection DEPLOY/Rollout.io - Rest - v5.0.1.postman_collection.json Centralized Postman collection covering microservices authentication, flag evaluations, and management endpoints.
Contributing Guide CONTRIBUTING.md Guidelines for reporting issues, contributing code, and setting up local development environment.
Security Policy SECURITY.md Procedures and contact details for reporting security vulnerabilities privately.
Support Guide SUPPORT.md Available support channels and troubleshooting instructions for the platform.
Code of Conduct CODE_OF_CONDUCT.md Community guidelines and collaboration standards for students and developers.
License Information (MIT) LICENSE-MIT Terms and permissions under the MIT open-source license.
License Information (Apache) LICENSE-APACHE Terms and permissions under the Apache 2.0 open-source license.
Citation File CITATION.cff Metadata citation file for referencing this academic project.

License

This project is dual-licensed under the MIT License and the Apache License 2.0. Reference the LICENSE-MIT and LICENSE-APACHE files for full terms and conditions.

This site is open source. Improve this page.