My Journey
Academic milestones & startup logs
Contact Me
Get in touch or check socials
My Engineering Portfolio
Explore the system designs, backend pipelines, and performance benchmarks behind my latest software engineering projects.
Project Overview
ReviewRay is an AI-native code review platform that integrates directly with GitHub workflows to provide codebase-aware, automated feedback on pull requests. Built for modern software development teams, it leverages vector semantic search and Large Language Models to analyze pull request diffs, retrieve project context, and publish contextual inline code reviews in seconds.
Key Capabilities
- Codebase-aware reviews using Retrieval-Augmented Generation
- Asynchronous webhook processing with Inngest job queues
- Automated line-by-line pull request comments using Octokit
- Vector semantic search indexing powered by Pinecone
- Secure user authentication via Better Auth with GitHub
- SaaS subscription lifecycle integration with Razorpay
- Scalable multi-model inference routing via OpenRouter
- Premium developer dashboard with responsive layout
Technologies Deployed
System Architecture & Technical Specifications
Next.js App Router -> Server Actions and Route Handlers -> Prisma ORM -> PostgreSQL | Better Auth Session Handling | Inngest Background Jobs | OpenRouter and Pinecone Client -> Model Inference via GitHub Webhooks
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
GitHub Webhooks Trigger
Receives pull request payloads (open, synchronize, reopen) from GitHub repositories in real-time. Signatures are validated using HMAC SHA-256 headers.
Next.js Route Handlers
Validates active subscription statuses using Razorpay metadata and processes session authorization keys with Better Auth cookie verification.
Inngest Queue Worker
Orchestrates background step functions asynchronously. Manages high-throughput PR webhooks with automated retries, failure handling, and concurrency limits.
Pinecone RAG Vector Search
Performs semantic queries against codebase chunks stored as embeddings in Pinecone, retrieving code snippets and repository structures relevant to the PR diff.
OpenRouter LLM Inference
Sends code context to OpenRouter APIs (Claude 3.5 Sonnet / Gemini 1.5 Pro) to analyze diff code logic, then submits precise line comments to the GitHub API via Octokit.
Key Technical Challenges & Solutions
Orchestrating high-performance Retrieval-Augmented Generation (RAG) context matching across codebases containing thousands of files.
Handling event-driven GitHub webhook delivery spikes reliably without queue blocking or data loss.
Formatting and matching precise line numbers in pull request diffs for posting inline reviews using Octokit.
Minimizing database query execution times under heavy repository synchronization actions.
Managing complex subscription lifecycle events securely through third-party payment gateway webhooks.
ExeOS-AI
AI-Powered Executive Operating System
Project Overview
ExeOS-AI is an AI-native executive workspace that unifies email, calendars, tasks, notes, and intelligent automation into a single productivity platform. Built for professionals and modern teams, it leverages state-of-the-art language models to automate routine work, organize information, and provide actionable insights from your daily workflow.
Key Capabilities
- AI-powered email analysis and intelligent summarization
- Smart calendar scheduling and event management
- AI executive assistant with contextual conversations
- Task management with intelligent prioritization
- Background workflow automation using Inngest
- Multi-model AI support via OpenRouter
- Real-time notifications and productivity insights
- Premium responsive dashboard with dark mode
Technologies Deployed
System Architecture & Technical Specifications
Next.js App Router → Server Actions & Route Handlers → Drizzle ORM → PostgreSQL │ Clerk Authentication │ Inngest Background Jobs │ OpenRouter & Vercel AI SDK → OpenAI · Claude · Gemini · Tencent Models
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
Clerk Authentication Gate
Shields server resources by validating Clerk session cookies, ensuring users only access their authorized workspace and tenant organization scopes.
Next.js Server Actions
Routes client actions, manages react state, and streams model completions to the dashboard interface using Vercel's standard AI stream helpers.
Inngest Task Queue
Fires scheduled crons to sync email and calendar events, processes asynchronous database updates, and triggers real-time workspace alerts.
OpenRouter Multi-LLM Orchestrator
Selects and calls the best frontier models (Claude 3.5 Sonnet, GPT-4o, Gemini 1.5 Pro) based on workspace prompts, request latency, and budget requirements.
Drizzle ORM / PostgreSQL DB
Performs low-latency transactional updates and relational queries on PostgreSQL schemas using Drizzle, fetching inbox messages, event schedules, and system logs.
Key Technical Challenges & Solutions
Designing a scalable AI orchestration layer capable of routing requests across multiple language models.
Building asynchronous AI workflows with retries, scheduling, and event-driven processing using Inngest.
Creating a premium, highly responsive SaaS interface while maintaining accessibility and performance.
Optimizing PostgreSQL queries and Drizzle ORM interactions for low-latency data retrieval.
Managing secure authentication, protected routes, and user-specific AI context using Clerk.
Project Overview
Zenith CLI is a modern, AI-powered developer workspace that lives entirely inside your terminal. Powered by Google Gemini, Zenith combines conversational AI, intelligent tool execution, and autonomous project generation into a single CLI experience. Whether you're asking questions, searching the web, executing code, or scaffolding an entire application, Zenith keeps your workflow fast, interactive, and terminal-first.
Key Capabilities
- AI-assisted code generation from terminal
- Project scaffolding with best-practice templates
- Authentication management (OAuth + JWT)
- Workflow automation & background jobs
- Intelligent debugging assistance
- Web dashboard via Next.js for project overview
- Prisma ORM for type-safe DB operations
- Developer productivity optimization tools
Technologies Deployed
System Architecture & Technical Specifications
Commander.js CLI → Express.js API → Prisma → PostgreSQL | Next.js Dashboard | OpenAI API for AI inference | Better Auth for user management
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
Bun CLI / Commander.js Core
Accepts developer commands and arguments inside terminal shells. Bundles module trees using tsup/esbuild for minimal execution latency.
OAuth Device Auth Portal
Coordinates login states between the terminal and browser using the OAuth 2.0 Device Flow (RFC 8628) and Better Auth dashboard controls.
Express.js API Gateway
Processes REST queries, validates user authentication payloads, and fetches details from a PostgreSQL instance using type-safe Prisma schemas.
Google Gemini API Integration
Leverages Gemini API models via the Vercel AI SDK to build folder structures, write template configurations, and stream generated code solutions to the terminal.
Key Technical Challenges & Solutions
Designing an intuitive CLI UX that works cross-platform
Streaming AI responses in real-time within the terminal
Managing secure API key storage in the CLI context
Project Overview
Synapse UI is a modern React UI library built with Next.js, TypeScript, and FumaDocs - helping developers build beautiful, production-ready applications faster. Designed with accessibility, performance, and scalability in mind, it enables teams to ship consistent, maintainable interfaces with confidence.
Key Capabilities
- Copy-paste ready React components
- Shadcn CLI compatible installation
- FumaDocs-powered interactive documentation
- MDX examples with live previews
- Full TypeScript support & type exports
- Accessible & ARIA-compliant components
- Dark mode support out of the box
- Composable TailwindCSS design system
Technologies Deployed
System Architecture & Technical Specifications
Next.js App Router → FumaDocs MDX → Component Registry | TailwindCSS design tokens | Shadcn CLI integration | Vercel deployment
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
FumaDocs Portal
Hosts interactive MDX documentation pages, rendering live playground components where designers can manipulate props and see layouts in real-time.
Component Registry JSON API
Compiles source code paths, Tailwind design tokens, and components catalog layouts into static JSON metadata hosted on Vercel CDN nodes.
npx CLI Installer
Resolves shadcn-compatible CLI requests to fetch component details from the JSON registry and injects them directly into developer file workspaces.
Key Technical Challenges & Solutions
Building a zero-dependency component registry compatible with Shadcn CLI
Rendering live MDX examples with accurate type inference
Maintaining consistency across 30+ components with a single design system
SocketPoll
Real-Time Audience Engagement Platform at Scale
Project Overview
SocketPoll is a real-time audience engagement platform engineered for instant interactive experiences, featuring low-latency WebSocket communication, scalable backend architecture, and a modern React-based interface powered by PostgreSQL for reliable data persistence.
Key Capabilities
- Real-time WebSocket bi-directional communication
- Live poll state synchronization
- Multi-user concurrent session support
- Presenter controls & audience view separation
- PostgreSQL persistent vote storage
- Ultra-low latency response updates
- Responsive UI for mobile & desktop
- Session-based access control
Technologies Deployed
System Architecture & Technical Specifications
React + Vite SPA → WebSocket (ws) → Express.js → Drizzle ORM → PostgreSQL | Real-time event broadcasting | Vercel deployment
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
Presenter & Audience Clients
React + Vite user applications that render active vote sliders, poll charts, and session control panels using responsive Tailwind elements.
ws WebSocket Connection Core
Creates persistent, bi-directional sockets between user views and the backend to broadcast and update live poll stats in milliseconds.
Express HTTP Router
Validates host dashboard credentials, initializes active poll sessions, and exposes REST endpoints for dashboard controls.
Drizzle ORM & PostgreSQL Store
Validates user ip hashes, registers vote transactions, and saves aggregate tallies onto Postgres schemas utilizing Drizzle.
Key Technical Challenges & Solutions
Maintaining consistent state across all connected clients at scale
Handling WebSocket disconnects and graceful re-connection
Designing the database schema for high-throughput vote writes
LinkedUp
AI-Powered LinkedIn Content Generation Platform
Project Overview
LinkedUp is an AI-powered LinkedIn content generation platform built with LangChain, Groq LLMs, and Streamlit, delivering context-aware, high-quality content generation through scalable LLM pipelines and an intuitive user interface.
Key Capabilities
- LangChain scalable prompt pipeline
- Real-time Groq LLM inference
- Context-aware content personalization
- Structured output via Pydantic models
- Interactive Streamlit UI
- Tone & audience targeting controls
- One-click copy for LinkedIn posts
- Multi-topic post generation
Technologies Deployed
System Architecture & Technical Specifications
Streamlit UI → LangChain Prompt Pipeline → Groq LLM Inference → Pydantic Output Parser | Streamlit Cloud deployment
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
Streamlit Dashboard
Renders parameter settings (tone, industry, keywords, topic, length) for generating LinkedIn posts using Streamlit elements.
LangChain Pipeline Orchestration
Loads preconfigured prompt files, compiles user context inputs, and handles call chains to orchestrate instructions to LLMs.
Groq LLM API
Queries Groq's high-speed API endpoints to get structured text responses in milliseconds.
Pydantic Schema Parser
Enforces type structures on generated text output (e.g. hashtags, key hooks, content blocks) before rendering details to users.
Key Technical Challenges & Solutions
Designing prompt templates that reliably produce LinkedIn-optimized content
Managing LLM token costs while keeping response quality high
Building a low-friction UX with zero infrastructure in Streamlit
Mini-TailwindCSS
Lightweight Tailwind-Inspired CSS Utility Engine
Project Overview
A lightweight, runtime CSS utility engine inspired by Tailwind CSS, leveraging vanilla JavaScript and DOM manipulation to deliver dynamic utility class generation, real-time styling, and a fast, build-free development workflow.
Key Capabilities
- Runtime utility class parsing (no build step)
- Dynamic style injection via DOM API
- Extensible class mapping architecture
- Responsive utility class support
- React integration layer included
- Zero-dependency core engine
- NPM package distribution
- Rapid UI prototyping without toolchain setup
Technologies Deployed
System Architecture & Technical Specifications
Vanilla JS Utility Parser → DOM Style Injection → Class Map Registry | React Adapter Layer | Netlify deployment | NPM package distribution
System Pipeline Flow
Visualizing the step-by-step lifecycle of request payloads and data pathways.
HTML / DOM Nodes Scan
Parses DOM layouts at runtime, scanning class lists for active Tailwind CSS style configurations.
JS RegEx Parser Engine
Tokenizes string classes into parts, identifying responsive tags, utility modifiers, values, and selector parameters at runtime.
Class Map Registry
Compares style tokens against lookup configurations to compile standard CSS style sheets dynamically.
Style Tag Injector
Appends generated styling rules into a dedicated runtime stylesheet in the browser document head, painting components instantly.
Key Technical Challenges & Solutions
Designing a performant runtime parser that doesn't block the main thread
Handling class specificity conflicts with existing stylesheets
Making the extensible class map intuitive for third-party consumers