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

PROJECT IS LIVE

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:

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:

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.

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

Technical Foundation

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

Tech Stack Icons

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

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 you have the following installed on your machine before starting:

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

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:

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.