OPEN SOURCE

Sentinel — Adaptive Distributed Load Control Microservice

Open-source adaptive HTTP reverse proxy in TypeScript/Bun, sustaining ~6,800 req/s at p99 41ms baseline. Protects distributed backends from traffic spikes and cascading failures via hybrid rate limiting, distributed circuit breaking, and real-time pressure-based throttling.

View Live Source Code

Sentinel — Adaptive Distributed Load Control Microservice

Client

Open Source (Personal)

Timeline

2026

My Role

Sole Developer

Project Overview

Sentinel is an open-source HTTP reverse proxy and adaptive load control layer that sits in front of any backend service, protecting it from overload and cascading failure — without requiring any code changes to the services it protects. It implements a hybrid local + Redis rate limiter (in-memory token bucket for sub-5ms fast-path approvals backed by Redis sliding window via atomic Lua scripts), a distributed circuit breaker with Redis Pub/Sub synchronization, and a weighted adaptive pressure model (CPU, memory, event loop lag, error rate, downstream latency) aggregated globally via Redis. Validated across 5 autocannon benchmark scenarios totaling 75+ seconds of continuous load with 145,000+ total requests processed on a single local Docker node.

Key Features

Feature Groups

Features

1 / 0

Key Capabilities

Hybrid rate limiter — in-memory token bucket fast-path + Redis sliding window via atomic Lua scripts

#01

Distributed circuit breaker with Redis Pub/Sub — any pod detecting failure syncs state to all peers instantly

#02

Weighted adaptive pressure model (CPU, memory, event loop, error rate, downstream latency) aggregated via Redis every 500ms

#03

Priority scheduler with tenant-tier differentiation (vital vs. economy)

#04

Sliding window algorithm eliminates boundary-burst attacks

#05

Full observability: Prometheus RED metrics, SLO violation counters, OpenTelemetry traces (OTLP → Jaeger), structured Pino logging

#06

Kubernetes deployment (stateless pods, HPA autoscaling, rolling updates)

#07

Docker Compose stack for local development

#08

5 autocannon benchmark scenarios with 145,000+ total requests validated

#09

Case Study

Problem & Approach

The Challenge

Problem Statement

Distributed systems suffer from traffic spikes, cascading downstream failures, and static rate limiting that ignores real-time system pressure and treats all tenants equally. Most rate limiters use fixed windows (vulnerable to boundary bursts), circuit breakers are per-instance (no cluster awareness), and there's no adaptive pressure model that considers multiple signals simultaneously.

The Solution

Our Approach

Built a hybrid rate limiter with in-memory token buckets for sub-5ms fast-path approvals, backed by Redis sliding window via atomic Lua scripts for cluster-wide enforcement. Redis is not hit on every request, removing it as a bottleneck. A distributed circuit breaker uses Redis Pub/Sub so any pod detecting a failure threshold triggers a state-change event propagated to all peers instantly. A weighted adaptive pressure model aggregates CPU, memory, event loop lag, error rate, and downstream latency globally via Redis every 500ms, computing effective_limit = base × plan_multiplier × (1 − pressure_score). Full Prometheus RED metrics, OpenTelemetry traces, and Pino logging provide end-to-end observability.

Details

Project Information

Client

Open Source (Personal)

Timeline

2026

Role

Sole Developer

Technologies

12 Technologies

Tech Stack

12 Technologies

Bun

TypeScript

Fastify

Redis

ioredis

Docker

Kubernetes

Prometheus

OpenTelemetry

Jaeger

Pino

autocannon

Outcomes

Results & Impact

#01

Sustains ~6,800 req/s at p99 41ms baseline (100 concurrent connections, single local process)

#02

Correctly rate-limited 99.5% of requests under 200-connection burst overload (13,749 of 13,820 requests blocked)

#03

Circuit breaker correctly blocked 99.6% of requests once tripped (17,500 of 17,571 returned 503)

#04

Adaptive pressure model stable at 0.28 under 1,500 req/s sustained load — zero false throttling events

#05

Validated across 5 benchmark scenarios with 145,000+ total requests on a single Docker node

#06

Cloud-ready with Kubernetes manifests, HPA autoscaling, and zero code changes to protected services

More Projects

OTHERS

ObservabilityOS — AI-Native DevOps Intelligence & Observability Platform

AI-native log analytics and incident response platform with real-time streaming, statistical anomaly detection, and multi-provider LLM diagnostics.

WEB APPLICATION

Drishti Marketing OS — Enterprise WhatsApp AI Agent Platform

Enterprise WhatsApp Business inbox replacing third-party BSPs with a custom Meta Cloud API integration, multi-provider AI agent (Claude/GPT-4o/Gemini), RAG knowledge base, and real-time Zoho CRM data — achieving 89.7% AI self-service rate and 96% reduction in lead response time.

OPEN SOURCE

create-saas-app · Modern SaaS Monorepo Boilerplate

Open-source interactive CLI (npx create-saas-app-cli) that scaffolds a fully-configured Turborepo monorepo in seconds — with database, auth, queues, payments, observability, and CI/CD selected interactively at prompt time.