All Projects

Things I've built

A full breakdown of projects across work and open source — covering architecture decisions, approach, and what I learned building each one.

Customer Support Platform

A full-featured support desk built for modern teams.

GitHub Demo

Problem

Support teams were stitching together disparate tools — email clients, chat apps, and ticketing sheets — leading to missed messages, slow response times, and no single source of truth.

Approach

Built a unified platform that consolidates email, WhatsApp, and web widget into one interface. Designed around a ticket state machine with webhook-based integrations for third-party systems.

Architecture

5 layers

HTTP API (Go/Gin)01

WebSocket server for real-time updates02

RabbitMQ for async job dispatch03

Workers for email, WhatsApp, notifications04

PostgreSQL with Redis caching layer05

Results

Reduced average ticket response time by 40%.
Handled 10K+ concurrent webhook events without degradation.
Integrated 3 messaging channels behind a single API.

Lesson Learned

“Designing around state machines early prevented a class of edge-case bugs that would have been expensive to fix post-launch.”

GoGinReactPostgreSQLRedisRabbitMQDocker

MLM + Ecommerce Platform

Company core product — customized, extended, and maintained across dozens of client deployments.

Problem

A mature, large-scale MLM and ecommerce application serving multiple clients globally. Each client deployment brings unique plan structures, regional payment methods, compliance requirements, and feature requests on top of the same shared codebase.

Approach

Working within a legacy Django codebase, I implement per-client customizations, build new integrations, optimize slow queries, and add features without destabilizing existing deployments. The work requires a strong understanding of the existing architecture to make changes that are safe, scoped, and backward-compatible.

Architecture

6 layers

Django REST API & Django Web Framework — core platform01

Celery + RabbitMQ — async jobs02

Go Cron — async fast background processing03

PostgreSQL — data storage04

Redis — caching, rate limiting, session, in-memory storage05

Per-client server deployment06

Results

Delivered client-specific features and integrations across 10+ deployments.
Integrated regional payment gateways with zero disruption to existing clients.
Optimized high-volume commission calculation jobs, cutting processing time significantly.
Resolved critical production bugs in billing and wallet logic under tight deadlines.

Lesson Learned

“Working in a legacy codebase with real business consequences taught me to read systems deeply before touching them — every change needs to account for what it might break downstream.”

PythonDjangoDRFCeleryGoPostgreSQLRedisRabbitMQAWS

Ecommerce Platform

A full-stack ecommerce platform built as a personal project, from product catalog to checkout.

Problem

Most ecommerce tutorials stop at the cart. I wanted to build something production-complete — with real payment processing, order lifecycle management, and the infrastructure to actually run it.

Approach

Built the backend as a Django REST API with clean separation between the product, order, and payment domains. The Next.js frontend handles SSR for product pages (SEO-critical) and client-side rendering for the cart and checkout flow. Three payment providers are integrated behind a unified abstraction so switching or adding providers doesn't touch order logic.

Architecture

6 layers

Django REST API — products, orders, users, payments01

Next.js frontend — SSR for catalog, CSR for cart/checkout02

Stripe, Razorpay, PayPal — unified payment abstraction03

PostgreSQL — primary datastore04

Redis — session, cart state, response caching05

Docker — containerized local and production environment06

Results

End-to-end checkout flow working across Stripe, Razorpay, and PayPal.
SSR product pages with sub-200ms response times via Redis caching.
Webhook handlers for all three payment providers with idempotent order updates.

Lesson Learned

“Abstracting payment providers early was the right call — each provider has wildly different webhook shapes and error codes, and a clean interface kept the order service completely unaware of those details.”

PythonDjangoDRFNext.jsReactPostgreSQLRedisStripeRazorpayPayPalDocker

Webhook Monitoring Platform

A request inspector and debugging tool for webhook integrations.

GitHub

Problem

Developers integrating webhooks had no visibility into payloads, no way to replay failed deliveries, and debugging required production log access.

Approach

Built a hosted inspection endpoint that captures, stores, and displays all inbound HTTP requests. Added replay functionality and structured filtering by headers, status, and payload shape.

Architecture

4 layers

Go HTTP server — capture and store requests01

PostgreSQL — request log with TTL cleanup02

Server-Sent Events — live feed to UI03

React dashboard — filter, inspect, replay04

Results

Reduced webhook integration debug time from hours to minutes.
Supported 500+ simultaneous inspection sessions.
Live feed latency under 100ms.

Lesson Learned

“Server-Sent Events were a much better fit than WebSockets here — simpler, stateless, and exactly sufficient for one-directional live updates.”

GoReactPostgreSQLSSEDocker

BLUEM

A zero-downtime blue-green deployment CLI for any Dockerized application.

GitHub

Problem

Deploying new versions of Dockerized apps without downtime typically requires Kubernetes or complex CI/CD pipelines. For teams running Docker Compose in production, there was no simple, standalone tool to handle blue-green switching, health checks, and safe rollback without heavy infrastructure.

Approach

Built a Go CLI binary that orchestrates the full blue-green deployment lifecycle on top of Docker Compose. The tool manages BLUE/GREEN container states, waits for health checks to pass, switches traffic via a pluggable proxy layer (Traefik or Nginx), drains the old container, and auto-rolls back if the new version fails its health window.

Architecture

5 layers

Go CLI — deployment lifecycle orchestrator01

Docker Compose — BLUE/GREEN container management02

Traefik / Nginx — pluggable proxy for traffic switching03

YAML config (bluem.yml) — project + service configuration04

Prebuilt binaries — macOS, Linux, Windows05

Results

Zero-downtime deployments without Kubernetes or external CI/CD.
Auto rollback triggered by health check failures within a configurable failover window.
Supports any Dockerized application — framework and language agnostic.

Lesson Learned

“Modeling the deployment as a state machine (up → healthy → switched → drained → done) early on made the entire codebase easier to reason about — each command maps cleanly to a state transition.”

GoDockerDocker ComposeTraefikNginx

Cafe Manager

A multi-store desktop POS with native USB thermal printer support.

GitHub

Problem

Cafe chains managing multiple locations needed a standalone desktop POS that handles real-time table orders, role-based staff access, and prints kitchen tickets and invoices directly to thermal printers — without cloud dependency or external print servers.

Approach

Built as a native desktop application using Tauri, combining a React + TypeScript frontend with a Go backend for the API layer. The printer integration was implemented as a Rust module using the rusb library, enabling direct USB communication with thermal printers over ESC/POS — no OS print drivers required.

Architecture

5 layers

React + TypeScript — table layout, order and menu UI01

Go / Express — REST API (stores, orders, menus, users)02

PostgreSQL — primary data store03

Tauri (Rust) — native desktop shell + command bridge04

Rust (rusb) — USB thermal printer driver (ESC/POS)05

Results

Full multi-store POS running as a native desktop app on macOS, Linux, and Windows.
Direct USB thermal printing without platform print drivers or cloud relay.
Role-based access for 4 user types: Super Admin, Business Owner, Admin, and Staff.

Lesson Learned

“Rust was the right tool for the printer layer — USB communication from JavaScript would have been fragile, and Tauri's command bridge made the Go↔Rust↔frontend boundary explicit and easy to reason about.”

TypeScriptReactGoRustTauriPostgreSQLDocker

Offline Billing App

A fully offline Android billing app with thermal printer support via Bluetooth and USB.

Problem

Small retail businesses needed a billing solution that works without internet connectivity, prints receipts directly to thermal printers, and doesn't rely on cloud infrastructure or monthly SaaS fees.

Approach

Built a native Android app in Flutter with SQLite as the local database for all billing, product, and customer data. Implemented dual printer connectivity — Bluetooth for wireless thermal printers and USB for wired ones — using ESC/POS command encoding to generate and send receipts directly from the device.

Architecture

5 layers

Flutter — cross-platform UI and application logic01

SQLite (sqflite) — local offline data storage for bills, products, customers02

Bluetooth (flutter_bluetooth_serial) — wireless thermal printer communication03

USB (usb_serial) — wired thermal printer communication04

ESC/POS encoding — receipt formatting and printer command generation05

Results

Fully offline operation — no internet required at any point.
Dual printer support: Bluetooth and USB thermal printers from the same app.
Fast receipt generation with ESC/POS formatting for itemized bills.

Lesson Learned

“Handling two completely different printer transports (Bluetooth and USB) behind a single print interface kept the billing logic clean — the rest of the app never needs to know how the receipt actually gets to the printer.”

FlutterDartSQLiteBluetoothUSBESC/POS

AI-Integrated ERP Billing Software

A full-featured ERP and billing platform with embedded AI for business automation.

Problem

Businesses managing invoicing, inventory, accounts, and reporting were stitching together disconnected tools — leading to data inconsistencies, manual reconciliation, and no intelligent layer to surface insights or automate routine decisions.

Approach

Built a comprehensive ERP platform with modules for billing, inventory, accounts payable/receivable, and reporting. Integrated AI capabilities for invoice data extraction, anomaly detection in transactions, and natural-language querying of business data. The Go backend exposes a clean REST API consumed by a React + Next.js frontend, with PostgreSQL as the primary store and Docker for consistent deployment across environments.

Architecture

5 layers

Go REST API — core business logic: billing, inventory, accounts, reporting01

AI layer — invoice extraction, transaction anomaly detection, NL query interface02

React + Next.js — server-rendered dashboards and client-side module UIs03

PostgreSQL — primary datastore for all ERP entities04

Docker / Docker Compose — containerized services for local and production parity05

Results

End-to-end ERP covering billing, inventory, and accounts in a single unified platform.
AI-powered invoice parsing reduced manual data entry significantly.
Natural-language query interface let non-technical staff extract business reports without SQL.

Lesson Learned

“Embedding AI at the data layer rather than the UI layer made it far more useful — parsing and structuring incoming documents before they hit the database meant the rest of the platform could treat AI-processed data identically to manually entered records.”

GoReactNext.jsPostgreSQLDockerOpenAI

AI Social Media Content Platform

Multi-model AI platform for generating infographic posts, carousels, and captions from a topic.

Problem

Content creators and marketing teams spend hours drafting social media posts, designing carousel slides, and writing captions — repetitive creative work that blocks them from focusing on strategy and distribution.

Approach

Built a platform that takes a topic as input and routes generation tasks across OpenAI, Gemini, and Claude depending on the content type. Infographic layouts and carousel slide structures are generated as structured data, rendered into visual-ready formats on the frontend, while captions are tuned per platform (Instagram, LinkedIn, Twitter). Generated assets are stored in S3 (production) and MinIO (dev) for a consistent object storage interface across environments.

Architecture

7 layers

Go REST API — generation orchestration and asset management01

Multi-model router — selects OpenAI, Gemini, or Claude based on task type and availability02

Structured output prompting — carousel slides and infographic blocks as typed JSON03

Caption generator — platform-aware tone and length tuning04

React + Vite — frontend renderer for visual post previews05

PostgreSQL — stores generation history, user data, and asset metadata06

S3 (prod) / MinIO (dev) — object storage for generated assets07

Results

Generated infographic posts, multi-slide carousels, and captions from a single topic input.
Integrated three AI providers behind a unified generation interface.
Platform-specific caption output tailored for Instagram, LinkedIn, and Twitter.

Lesson Learned

“Structured output prompting — forcing the model to return typed JSON instead of prose — was the key unlock for reliable carousel and infographic generation. Free-form text responses made downstream rendering brittle.”

GoReactViteTypeScriptPostgreSQLS3MinIOOpenAIGeminiClaude

Learning Platform

A structured tutorial platform covering programming, computer science, and DSA.

Problem

Most programming learning resources are either too shallow (blog posts) or too scattered (YouTube playlists) to build real understanding. Learners had no single place with structured, progressively ordered content covering everything from computer basics to advanced algorithms.

Approach

Built a full-stack learning platform with course-based content organized into topics and lessons. Each course has a defined curriculum, difficulty level, and estimated completion time. The platform supports multiple tracks: Computer Basics, Python, JavaScript, Go, and Data Structures & Algorithms — each structured to take a learner from first principles to practical application.

Architecture

6 layers

Next.js (App Router) — SSR course listing and static generation for lesson pages01

React — interactive lesson UI and course navigation02

TypeScript — typed course and lesson data models03

Structured content model — courses → topics → lessons hierarchy04

PostgreSQL — user progress tracking and course metadata05

Docker — containerized deployment06

Results

5 complete courses covering Computer Basics, Python, JavaScript, Go, and DSA.
80+ structured lessons organized into progressively ordered topics.
Course pages statically generated at build time for fast, SEO-friendly delivery.

Lesson Learned

“Designing the content model before writing any UI forced clarity on the hierarchy — courses, topics, and lessons are distinct concepts with different rendering needs, and conflating them early would have made the UI much harder to build correctly.”

Next.jsReactTypeScriptPostgreSQLDocker