I build systems that keep working when individual components fail.

My work sits in backend engineering, distributed systems, cloud infrastructure, AI systems and system design — microservices, event-driven architectures, caching layers, distributed messaging and AI orchestration. I care more about how something behaves under scale, failure and change than about how many features it ships with.

Most of my recent work is production-grade rather than prototype-level: cloud-native microservice architectures, event buses, RAG pipelines and AI applications capable of autonomous decision-making.

Currently a third-year Electronics & Communication Engineering student at MNNIT Allahabad, and Tech Facilitator (Executive) at Google Developer Groups, MNNIT Allahabad.

Turning physical locations into intelligent, context-aware digital experiences — powered by agentic workflows, real-time orchestration and procedural content generation over a scalable backend.

Making the physical world programmable.

The AI and software agency behind intelligent businesses — the agents, automations and products that let ambitious companies operate beyond their headcount. I lead technical vision, architecture and engineering.

A production-grade SaaS platform that lets businesses create, deploy and manage AI voice agents without writing code — visual agent builder, integrated CRM, multilingual support, live call monitoring, analytics and provider-agnostic AI infrastructure in a single dashboard. Teams launch AI receptionists, sales representatives, appointment schedulers and support agents in minutes, with low-latency conversations and calling from $0.045 per minute. Engineered for enterprise reliability with intelligent call orchestration, automatic provider failover and real-time monitoring.

Visual Agent Builder Call Orchestration Provider Failover Live Monitoring CRM Integration Multilingual Analytics

I enjoy building systems where scalability, resilience and maintainability matter more than feature count.

Production Microservices        API Gateways
Event-Driven Systems            Distributed Messaging
AI Infrastructure               RAG Pipelines
Real-Time Systems               Cloud-Native Deployment
Backend Architecture            Developer Tooling

Languages     C++   Python   JavaScript   TypeScript

Frontend      React.js   Next.js   React Native 
              HTML   Tailwind CSS   Redux

Backend       Node.js   Express.js   FastAPI
              MongoDB   PostgreSQL   Redis

AI / ML       LangChain   LangGraph
              OpenCV   Pandas   NumPy

DevOps        Docker   RabbitMQ   Nginx
              Git   GitHub Actions   Postman

Cloud         AWS   Oracle Cloud (OCI)
              Cloudflare   Vercel

Lets organizations design, validate and secure IT architectures through rule-based analysis and live attack simulation — removing weeks of configuration and costly cloud setups. A drag-and-drop architecture builder feeds a Rule-Based Security Engine mapped to MITRE and OWASP, backed by an eBPF process monitor for kernel-level network visibility and an integrated historical breach database. LangGraph agents handle AI-assisted architecture validation, and the whole simulation environment runs containerized with zero infrastructure to provision.

Next.js TypeScript FastAPI Python eBPF Docker LangGraph

Generates context-aware, interactive experiences over physical environments. Rather than shipping isolated experiences, the platform dynamically composes them at request time — a geospatial computing engine resolves location context, multi-agent orchestration drives adaptive user interactions, and procedural generation builds content on demand. Real-time synchronization keeps distributed clients consistent across a scalable, service-oriented backend.

Distributed Systems Agent Orchestration Procedural Generation Real-Time Sync Geospatial

Cloud-native platform built on a production-grade microservices architecture, combining AI-assisted learning, real-time collaboration and intelligent planning into a fault-tolerant distributed system. Services follow API Gateway and Database-per-Service patterns with independent scaling, communicate asynchronously over a RabbitMQ event bus, and back AI features with a RAG pipeline on Qdrant vector search. Real-time collaboration runs on WebSockets + Redis, background work is distributed through BullMQ, and the entire stack is Dockerized for cloud deployment.

Node.js RabbitMQ Redis Qdrant BullMQ MongoDB WebSockets JWT Docker

End-to-end platform connecting couples with wedding vendors — discovery, proposal management, real-time communication and booking. The backend is a distributed system of 13 independently deployable Node.js microservices (11 fully implemented) following Domain-Driven Design, each owning its own database and communicating over synchronous REST and asynchronous RabbitMQ events.

Engineering Highlights

• API Gateway (Express + NGINX) handling auth, routing, rate limiting and centralized request management
• Event-driven communication across RFP, vendor, notification and chat services
• Horizontally scalable real-time messaging with Socket.IO + Redis Adapter across multiple instances
• AI-powered RFP personalization engine generating tailored vendor requests from event details
• Scalable media pipeline — Amazon S3, pre-signed URLs, Multer, Sharp
• Hardened auth — JWT, bcrypt, Helmet, Joi validation, CORS, transactional email workflows
• CI pipelines with GitHub Actions + Newman for automated API regression testing
• Architecture audit mapping production bottlenecks, service ownership boundaries and a roadmap to enterprise-grade reliability

Node.js Express MongoDB Atlas RabbitMQ Redis Socket.IO Next.js Docker OCI S3 Cloudflare GitHub Actions

Detects common web security issues — security headers validation, SSL/TLS configuration checks, vulnerable endpoint detection, parameter fuzzing for SQL Injection, XSS and Path Traversal, plus information disclosure detection. Ships as both a CLI and an SDK.

npx vuln-scanner https://example.com

Node.js CLI SDK Security MIT

Kubernetes Service Meshes gRPC Distributed Databases Observability Multi-Agent AI Systems