Hi, I'm Vedant
Backend developer who likes building fast, fault-tolerant distributed systems.
VS

About

Engineering the right way.

I'm a backend developer and a third-year student at BIT Mesra.

I like building resilient, real-time distributed systems—message queues, sandboxed runtimes, multi-agent pipelines, and keeping things correct when upstream APIs fail.

Recently, I've been:

  • Shipping production Node.js infrastructure at Neo Labs (Apr–Jun 2026)—circuit breakers, DLQs, and async export pipelines.
  • Hitting ~9.2k RPS with zero double-bookings under 40k concurrent holds in Stampede.
  • Cutting sandbox cold starts by 99% (down to 8ms) in my distributed code execution engine.
  • Building a LangGraph PowerShell agent that screens natural-language CLI commands before they run.
  • Orchestrating a multi-agent trip planner (weather → travel → hotels → itinerary → budget → critic).

I'm looking for a backend / infrastructure internship this placement season where I can own systems that have to stay up under load.

Work Experience

Neo Labs
Neo Labs
Backend Developer Intern
Apr 2026 - Jun 2026
  • Architected a real-time OpenAI financial circuit breaker across API and worker nodes using Redis atomic evaluation (MULTI/LUA), enforcing per-user and global daily hard caps that mitigated runaway embedding loops and protected production budgets from uncapped LLM costs.
  • Resolved a silent-failure gap across 7 production workers where jobs exhausting retries vanished without a trace, implementing a standardized dead-letter-queue handler with audit logging that restored failure visibility platform-wide.
  • Built an asynchronous data-export pipeline generating user data as JSON/PDF, uploading to Azure Blob via SAS-signed URLs, and triggering push/in-app notifications on completion via a shared FCM/APNs dispatcher.
  • Devised a two-step direct-to-blob audio upload flow (client-side SAS PUT, server-side confirm) with size-spoofing protection and mime validation, wiring successful uploads into the transcription pipeline.

Education

Birla Institute of Technology, Mesra
Birla Institute of Technology, Mesra
B.Tech in Electrical and Electronics Engineering · CGPA 8.78/10
Aug 2024 - May 2028
  • G.P. Birla Scholarship (2x) — Awarded twice for outstanding academic performance.
  • Branch Topper — Ranked 1st in Electrical & Electronics Engineering in Semester 1.

Skills

Languages
Go
TypeScript
JavaScript
C++
Backend
Node.js
Express.js
gRPC
RabbitMQRabbitMQ
BQBullMQ
WebSockets
Databases
PostgreSQL
Redis
Frontend
React
React Query
HTML5 / CSS3
DevOps
Docker
AWS (EC2)
Nginx
GitHub Actions
Linux
My Projects

Check out my latest work

A timeline of things I've built — from side projects to production apps.

Live systems

checking…

High-concurrency seat reservation under flash-sale stampedes.

Live
GitHubGitHub

Built a hybrid Redis + PostgreSQL seat-booking engine that survives flash-sale stampedes with zero double-bookings, scaled behind Nginx across 3 Go API nodes.


Stampede
Stampede — screenshot 2
  • Engineered a hybrid lock shield with Redis SETNX (3m TTL) and PostgreSQL UNIQUE(event_id, seat_id), rejecting ~97% of conflicting holds at the Redis fast path so Postgres never absorbs the stampede—zero double-bookings under load.
  • Horizontally scaled 3 Go Chi API nodes behind Nginx least_conn to sustain ~9,200 RPS across 40,000 concurrent hold requests (1× 201, 39,999× 409, 0 errors) with P99 under 50ms.
  • Replaced seat-map polling with Redis Pub/Sub fan-out into per-node WebSocket hubs, pushing hold/book/release state to clients in under 5ms.
  • Tuned Nginx worker_connections/keepalive, Redis client pools, and loadtest HTTP transports to eliminate backlog timeouts and kernel TIME_WAIT exhaustion under continuous high-concurrency runs.

Go
Chi
Redis
PostgreSQL
Nginx
WebSockets
React
Docker
Prometheus

Architecture

Stampede


Client
React seat map · WS
Nginx
least_conn · keepalive
API
Go · Chi
API
Go · Chi
API
Go · Chi

stateless 3-node cluster

Redis
SETNX · Pub/Sub

~97% DB shield · 3m hold TTL

PostgreSQL
UNIQUE(event_id, seat_id) · ACID

Supporting services

WebSocket hub
per-node fan-out
Docker Compose
nginx · api1–3 · redis · postgres
Prometheus
/metrics · hold counters
Loadtest runner
cmd/loadtest

Distributed, sandboxed code-execution platform.

Live
GitHubGitHub

Built a distributed sandboxed execution platform with a pre-warmed container pool, real-time log streaming and self-healing job recovery.


Code Execution Engine
Code Execution Engine — screenshot 2
  • Designed a distributed, sandboxed execution platform with a pre-warmed container pool, cutting sandbox startup time by 99% (8ms vs. 2s cold start) and reducing runtime latency to <230ms.
  • Implemented a fault-tolerant job lifecycle using BullMQ and Redis to enforce a deterministic state machine, with self-healing DLQ routing and exponential backoffs for recovery across worker crashes.
  • Developed a real-time observability pipeline using Redis Pub/Sub and WebSockets to stream stdout/stderr logs and execution traces live to the client.
  • Orchestrated a 4-service architecture with Docker Compose and deployed on AWS EC2 behind an Nginx reverse proxy with CI/CD via GitHub Actions.

Node.js
TypeScript
Express
PostgreSQL
Redis
BullMQ
WebSockets
Docker
AWS EC2
Nginx

Architecture

Code Execution Engine


Client
web UI
Nginx
reverse proxy · TLS
API
Express · TypeScript
BullMQ
Redis queue

deterministic state machine · exponential backoff

Worker
sandbox
Worker
sandbox
Worker
sandbox

pre-warmed container pool · 8ms cold start

Supporting services

Redis Pub/Sub → WebSocket
live stdout/stderr stream
PostgreSQL
job + run history
Dead-letter queue
self-healing recovery

Real-time traffic simulation & fleet-dispatch engine.

Live
GitHubGitHub

Built a real-time traffic simulation over a 294-junction road graph that computes optimized fleet dispatch and barricade plans, with deterministic fallbacks for third-party outages.


Niyantran
Niyantran — screenshot 2
  • Engineered a real-time traffic simulation on a 294-junction road graph using weighted BFS with time-of-day cascade multipliers to dynamically compute optimized fleet dispatch and barricade plans per event.
  • Assembled an async Node.js backend with WebSockets, Redis Pub/Sub and BullMQ to broadcast 30-second simulation ticks and live spatial telemetry with sub-second delivery.
  • Integrated Groq LLMs, Mappls API and Twilio (WhatsApp) for routing and alerts, with a multi-layer deterministic fallback — rule-based plans on Groq failure, haversine routing on Mappls outage.
  • Containerized a 5-service stack with Docker Compose, deployed to AWS EC2 with Nginx reverse proxy for WebSocket upgrading, and configured GitHub Actions CI/CD gating on all service builds.

Node.js
TypeScript
Express
PostgreSQL
Redis
BullMQ
WebSockets
Docker
AWS EC2
Nginx
Groq
Mappls API

Architecture

Niyantran


Client
ops dashboard
Nginx
WebSocket upgrade
API
Express · TypeScript
Sim engine
weighted BFS

294-junction graph · 30s cascade ticks

BullMQ · Redis Pub/Sub
telemetry fan-out

sub-second spatial broadcast

Supporting services

Groq LLM
routing · rule-based fallback
Mappls API
routing · haversine fallback
Twilio
WhatsApp alerts

Natural Language to Windows CLI Agent.

GitHubGitHub

Built an intelligent terminal assistant using LangGraph and Groq LLMs.


  • Developed a natural language to CLI agent using LangGraph and Groq LLMs to translate plain English requests into PowerShell/Bash commands.
  • Implemented a deterministic state machine with built-in safety screening to evaluate and block destructive commands before execution.
  • Containerized the agent using Docker for isolated execution with interactive and single-shot execution modes.

Python
LangGraph
LangChain
Groq
Docker
PowerShell

Architecture

PowerShell Agent


User Prompt
Interactive / CLI args
generate_command
Groq LLM processing
screen_command
Safety checks

Automatically blocks destructive commands

execute_command
Safe command execution
blocked
Return safety reason

Requires user confirmation or --auto flag

Supporting services

Docker Container
Isolated execution environment
PowerShell / Bash
Shell engine
Achievements

Wins & recognitions

Hackathon wins, competitions, awards and certifications I've picked up along the way.

Flipkart GRiD 2.0 — Round 2 Qualifier

Flipkart GRiD 2.0 — Round 2 Qualifier

Qualified for Round 2 out of 4,500+ competing teams in Flipkart's national-level AI traffic management challenge.

400+ DSA Problems Solved

Solved 400+ data-structures & algorithms problems across LeetCode and TUF+.

Contact

Get in Touch

Want to chat? Just shoot me a message on LinkedIn and I'll respond whenever I can.

GitHub
LeetCode
LinkedIn
takeUforward