RAHULX LABS · INDEPENDENT ENGINEERING STUDIO

We build backend systems behind serious products.

Backend engineering, distributed systems and AI infrastructure for startups and growing companies.

Production work spanning 15K+ purchase orders/month, 2K+ concurrent users, 100ms API latency gains, and 10K concurrent jobs under load.

15K+

purchase orders processed monthly

2K+

concurrent users supported

100ms

production API latency improvement

10K

concurrent jobs load-tested

Led by Rahul Gupta · Currently building at CognoVerse

PRODUCTION BACKENDSDISTRIBUTED SYSTEMSREAL-TIME APPLICATIONSAI / RAGEVENT-DRIVEN ARCHITECTURE

Case Studies

Systems that prove the engineering

Real production work and systems projects — problem, architecture, decisions, and results.

PRODUCTION / WORKFLOWSFeatured

Olive — Deliverable Tracking Platform

A full-stack deliverable-tracking and workflow-orchestration platform built for production at CognoVerse — event-driven workers, dual-cloud storage, and dual auth models.

Problem
Deliverable tracking across external stakeholders and internal teams needs reliable orchestration — folder provisioning, notifications, deadline escalation, and file detection — without coupling every workflow to a single request path or a single cloud vendor.
Result
Shipped from first commit to production in under 2 weeks; still owned as the sole engineer in production, with an event-driven pipeline across 4 decoupled workers.
FastifyBunTypeScriptPostgreSQLRedis StreamsReact
Read full case study →

Architecture

Fastify APIBun + TypeScript
Redis StreamsEvent bus
4 WorkersDecoupled jobs
Drive / OneDriveUnified interface
PostgreSQLAudit + state

Key engineering

Event-driven worker pipeline

Four decoupled workers handle cloud-folder provisioning, email notifications, automated deadline escalation, and file-submission detection so each concern can fail and retry independently.

Dual-cloud storage abstraction

Live Google Drive and Microsoft OneDrive (Graph API) backends sit behind one interface so the product is not locked to a single storage vendor.

Two coexisting auth models

Tokenless magic-link workflows for external stakeholders alongside JWT-based role/department access for internal users.

DISTRIBUTED SYSTEMS

Distributed Fault-Tolerant Task Queue

Stress-tested at 10,000 concurrent jobs with ~15,800 tasks/sec ingestion and 0% task loss under crash-recovery scenarios.

Node.jsTypeScriptRedisLua+5
Case study →
DISTRIBUTED SYSTEMS

Distributed Tiered Rate Limiter

Atomic Redis Lua enforcement across tiers — anonymous k6 runs hit 99.47% 429s with 12.37ms p95 latency; pro-tier allowance tracks theoretical refill.

Node.jsExpressRedisLua+7
Case study →
EVENT-DRIVEN / MEDIA

StreamHub — Distributed Video Pipeline

Ingest and transcoding scale independently — clients PUT directly to object storage while a separate BullMQ transcoder builds an HLS ladder without blocking the API.

FastifyReactTypeScriptBullMQ+7
Case study →
REAL-TIME SYSTEMS

LogStream

High-throughput log ingestion with Redis Streams consumer groups, SHA-256 deduplication, batch PostgreSQL writes, and live WebSocket metrics.

FastAPIPythonRedis StreamsPostgreSQL+3
Case study →
AI / SEARCH

Research Paper RAG System

3-stage CPU reranker (BM25 → RRF → Cross-Encoder) funnels retrieval 30 → 10 → 5 with ~400ms added latency — no GPU required.

FastAPIPythonQdrantPostgreSQL+6
Case study →
AI / RAG

AI Medical Report Summarizer

Grounded medical-report summaries via LangChain RAG over Qdrant — answers stay tied to uploaded content rather than free-form generation.

PythonFastAPILangChainQdrant+2
Case study →
REAL-TIME / COLLAB

DrawApp — Collaborative Whiteboard

Live collaboration scaled across Socket.IO instances via Redis Pub/Sub, with async PostgreSQL flush and email jobs off the draw path.

Next.jsSocket.IORedisPostgreSQL+3
Case study →
REAL-TIME / BACKEND

Real-Time Chess App

Sub-second multiplayer state via dedicated WebSockets, Redis for live games, and PostgreSQL for durable history with reconnection support.

Node.jsTypeScriptPostgreSQLRedis+5
Case study →

Engineering

Engineering depth

Systems work that shows how queues, rate limits, media pipelines and retrieval are designed — not just which frameworks were used.

DISTRIBUTED SYSTEMS

Distributed Fault-Tolerant Task Queue

Stress-tested at 10,000 concurrent jobs with ~15,800 tasks/sec ingestion and 0% task loss under crash-recovery scenarios.

Challenge

Background job processing needs guarantees beyond list-popping. Workers crash, networks partition, and poison messages can block the queue forever. The system needed at-least-once delivery, automated recovery from worker failures, poison-pill isolation, and real-time visibility into queue health.

Decision

Lua scripts for atomic acquisitionCustom Redis Lua combines RPOP + ZADD into one atomic transaction, closing the microsecond gap where a crash could lose a task between pop and claim.

~15,800 tasks/sec

Ingestion

10,000 jobs / 631ms

Burst load

0%

Task loss

Node.jsTypeScriptRedisLuaPM2
Full write-up →
DISTRIBUTED SYSTEMS

Distributed Tiered Rate Limiter

Atomic Redis Lua enforcement across tiers — anonymous k6 runs hit 99.47% 429s with 12.37ms p95 latency; pro-tier allowance tracks theoretical refill.

Challenge

Naive in-process rate limiters break across multiple servers. Real SaaS products need shared Redis state, atomic enforcement under concurrency, and different limits per customer tier — without duplicating the enforcement logic.

Decision

Three algorithms, one Redis Lua coreSliding Window Counter (anonymous), Sliding Window Log (free), and Token Bucket (pro) share the same middleware path — tiers swap algorithms, not code paths.

99.47% 429s

Anon enforcement

~349 / 300+refill

Pro allowed ≈ theory

12.37ms

Anon p95 latency

Node.jsExpressRedisLuaReact
Full write-up →
EVENT-DRIVEN / MEDIA

StreamHub — Distributed Video Pipeline

Ingest and transcoding scale independently — clients PUT directly to object storage while a separate BullMQ transcoder builds an HLS ladder without blocking the API.

Challenge

Most upload demos stream video through the API and call ffmpeg inline — concurrent uploads pin the CPU the HTTP server needs. Production systems need direct-to-storage ingest, async retryable transcoding, and ownership-safe streaming without exposing raw bucket URLs.

Decision

Presigned uploads bypass the APIThe client gets a presigned S3/MinIO URL and PUTs the file straight to object storage — the upload service never buffers video bytes.

FastifyReactTypeScriptBullMQRedis
Full write-up →
AI / SEARCH

Research Paper RAG System

3-stage CPU reranker (BM25 → RRF → Cross-Encoder) funnels retrieval 30 → 10 → 5 with ~400ms added latency — no GPU required.

Challenge

Closest-in-vector-space is not best-answer. Research papers need exact term matching for acronyms and notation, multi-user sharing without duplicate embeddings, safe deletion that does not break other users, and conversational follow-ups that still retrieve the right chunks.

Decision

3-stage CPU reranker (BM25 → RRF → Cross-Encoder)Wide recall (top-30) then precision funnel to top-5 keeps the LLM focused and avoids lost-in-the-middle — without requiring a GPU.

~400ms

Rerank latency (CPU)

30 → 10 → 5

Retrieval funnel

MiniLM-L-2

Cross-encoder

FastAPIPythonQdrantPostgreSQLFastEmbed
Full write-up →
REAL-TIME SYSTEMS

LogStream

High-throughput log ingestion with Redis Streams consumer groups, SHA-256 deduplication, batch PostgreSQL writes, and live WebSocket metrics.

Challenge

Centralized log ingestion at scale requires decoupling producers from consumers, handling burst traffic, deduplicating entries, and providing real-time visibility into ingestion health — all without losing data under load spikes.

Decision

Redis Streams over Pub/SubRedis Streams provide persistence, consumer groups, and acknowledgment — unlike Pub/Sub which drops messages if no consumer is listening.

FastAPIPythonRedis StreamsPostgreSQLWebSockets
Full write-up →

Experience

Production experience

Roles and systems already shipped — the foundation behind RahulX Labs.

CognoVerse

Back End Developer

May 2026 – Present

  • —Reworked the pagination layer on a core Node.js REST API, cutting average response latency by 100ms in production for the live mobile app.
  • —Owned end-to-end delivery of Common Carrier Phase 2 — built both the Node.js backend and the React web frontend solo, shipping a production-ready module across the full stack.
  • —Built a one-click ClickUp ↔ Excel sync automation for an Indian client, removing 3–6 hours of daily manual spreadsheet reconciliation.
  • —Architected and solo-built Olive, a full-stack deliverable-tracking and workflow-orchestration platform (Fastify on Bun, TypeScript, PostgreSQL, Redis Streams) — first commit to production in under 2 weeks, still the sole engineer owning it in production.
  • —Designed an event-driven pipeline across 4 decoupled workers for cloud-folder provisioning, email notifications, automated deadline escalation, and file-submission detection.
  • —Built a dual-cloud storage abstraction with live Google Drive and Microsoft OneDrive (Graph API) backends behind a single interface.
  • —Designed tokenless magic-link workflows for external stakeholders alongside JWT-based role/department access for internal users — two coexisting auth models.
  • —Shipped a hand-built, zoomable Gantt-chart visualization in React and an immutable audit-log system tracking 30+ distinct action types.

CognoVerse

SDE Intern

May 2025 – May 2026

  • —Developed an AI agent to automate sales workflows with a multi-agent LLM pipeline (LangGraph, FastAPI), Gmail/HubSpot integrations, Qdrant, OAuth token refresh, and real-time SSE streaming.
  • —Built a document-intelligence pipeline that ingests invoices from email (PDF, any structure, multipage), extracts metadata, and matches customer IDs and product codes from master data — processing 15,000+ purchase orders monthly.
  • —Worked with Panasonic on invoice ingestion requiring heavy preprocessing before structured storage.
  • —Built a medical-firm order ingestion system from master email across .txt, .docx, .pdf, and .xlsx, storing structured rows in DB and Excel with embedding-based master-data lookup for customer IDs.
  • —Built asynchronous fault-tolerant workflows using Celery, Redis, and PostgreSQL.

Beamstacks

Associate Application Developer Intern

September 2024 – March 2025

  • —Built an internal employee tracking app for weekly working hours, deployed on Azure with Azure Blob Storage for attachments.
  • —Delivered a Proof of Concept for Panasonic on RAG + AI that converted into a full project; also built a POC extracting structured text and images from PDFs into HTML.
  • —Developed the backend of a full-stack sports application with real-time score updates, clock synchronization, multi-game support, and end-to-end authentication — achieving sub-100ms state sync for 2,000+ concurrent users.
  • —Scaled the sports app with Redis queues/schedulers and Redis Pub/Sub so WebSockets fan out across multiple instances under load; deployed to Azure Ubuntu and AWS EC2.
  • —Built FastAPI conversational AI services using Qdrant, Redis caching, and LLM APIs.

Sales Assist

SDE Intern

April 2024 – June 2024

  • —Integrated Phantom on the backend and designed systems to reduce latency with well-optimized APIs.
  • —Created backend schedulers that run without impacting API performance.
  • —Helped automate LinkedIn activity workflows and processed large CSV datasets with pandas.

Sales Assist

React Developer

January 2024 – April 2024

  • —Built the application frontend with React Table and integrated dozens of APIs against Figma designs in Tailwind CSS.
  • —Implemented canvas-based infographic generation (text/hashtag separation) — a core VCMO feature — with social sharing and an emoji-safe caption parser.

Who we work with

Built for teams with hard backend problems

Target engagements — not a client roster. If your problem looks like one of these, we should talk.

Startups

When the product needs a backend that can grow with the company.

  • MVP backend architecture
  • Production APIs
  • AI features
  • Scaling existing systems

Growing businesses

When internal workflows and document flows are still held together by spreadsheets.

  • Internal tools
  • Workflow automation
  • Document processing
  • Integrations

Product teams

When you need senior backend help without standing up a large agency engagement.

  • Backend implementation
  • Performance optimization
  • Distributed systems
  • Infrastructure

Process

How engagements run

A simple engineering process — understand, architect, build, ship, improve.

  1. 01

    Understand

    Understand the product, constraints and existing architecture.

  2. 02

    Architect

    Choose the right data model, APIs, infrastructure and system boundaries.

  3. 03

    Build

    Implement incrementally with testing and observability.

  4. 04

    Deploy

    Ship to production with monitoring and operational visibility.

  5. 05

    Improve

    Measure, optimize and iterate.

Stack

Technical stack

Tools used when they fit the problem — not the other way around.

Languages

TypeScriptJavaScriptPythonSQLLua

Backend

Node.jsExpressFastifyBunFastAPIRESTWebSocketsSocket.IOCeleryBullMQ

Data

PostgreSQLMongoDBRedisQdrantPrismaMinIO / S3

AI

LangChainLangGraphLlamaIndexRAGFastEmbedEmbeddings

Infrastructure

DockerAWSAzureGitHub ActionsNginxPM2PrometheusLinux

Testing

VitestPyTestk6

About

Rahul Gupta

Software Engineer & Founder of RahulX Labs

Independent engineer behind RahulX Labs. Focused on backend engineering, distributed systems, AI/RAG pipelines, and production software — from architecture through deployment and observability.

At CognoVerse I own production backends for marketplace and deliverable-tracking platforms (Olive, Common Carrier), including a 100ms production API latency improvement. Before that: real-time sports backends at Beamstacks supporting 2K+ concurrent users, document-intelligence pipelines processing 15K+ purchase orders monthly, and earlier full-stack work at Sales Assist.

BCA at DAV College, Panjab University (CGPA 8.4, 2nd in program). The systems shipped are the credential that matters here.

More about Rahul →

Class Rank #2

BCA program, DAV College, Panjab University

State Rank 10

Class X — HP Board, Nahan

300+

LeetCode DSA problems

Hackathon Runner-up

Chronicles Hackathon 2024

Have a backend problem worth solving?

Tell us what you're building, what's currently broken, or where your engineering team is stuck.

Contact

Start a conversation

Email is fastest. Include what you're building and where you're stuck.