I'm an AI/ML Engineer and Backend Systems Developer who builds things from scratch β not just to ship, but to understand how they work internally.
I didn't just use LLMs β I built a RAG pipeline with LangChain, chaining retrieval, embeddings, and LLM calls into a working Q&A system over custom data. I didn't just use Redis β I rebuilt it in C++, stress-tested it with 10,000 threads, and understood why single-threaded execution is a design choice, not a limitation. That's how I think.
- π€ AI/ML Focus: LangChain Β· RAG Pipelines Β· Custom CNNs Β· Medical Imaging Β· LLMs
- βοΈ Systems Focus: Concurrency Β· Caching Β· Fault Tolerance Β· Performance
- π¬ Research: Published paper on ML model behavior (IJSET, Vol. 13, 2025)
- ποΈ Approach: Understand the internals before touching the scale knob
- π― Goal: AI/ML Engineer or SDE-1 role β building real, production-grade systems
| Area | Technologies |
|---|---|
| Languages | C++, Python, JavaScript (ES6+), TypeScript, SQL |
| AI / ML | TensorFlow, Keras, OpenCV, LangChain, RAG, LLMs, scikit-learn, NumPy, Pandas |
| Backend | Node.js, Express.js, Next.js, REST APIs, JWT Auth, Rate Limiting, Microservices |
| Systems | Multithreading, Mutex, Condition Variables, ProducerβConsumer, Fault Tolerance |
| Databases | MongoDB (Indexing, Aggregation), PostgreSQL, MySQL, Redis |
| Caching | LRU Eviction, TTL, In-memory KV Stores |
| Dev Tools | Git/GitHub, Docker, Linux, AWS (EC2, S3), Vercel, Cloudinary, Postman |
| Certifications | IBM AI & Data Science (2025) Β· Oracle Cloud AI Foundations (2025) |
π€ LangChain RAG Pipeline β Python Β· LangChain Β· LLMs Β· NLP
"Built a full retrieval-augmented generation system β because using ChatGPT is easy, but understanding how to wire your own data into an LLM pipeline is where the real learning is."
What I built:
- Document ingestion pipeline β chunking β embedding model β vector store
- LLM-powered Q&A over custom knowledge bases with context injection
- Prompt engineering for structured, reliable outputs from LLM calls
- Chained LangChain components: loaders β splitters β retrievers β LLM β output parsers
Python Β· LangChain Β· RAG Β· Embeddings Β· Prompt Engineering Β· LLMs
π« Lung Cancer Detection CNN β Python Β· TensorFlow Β· OpenCV Β· Medical AI
"Reduced CT scan manual review from 15β20 minutes to under 5 seconds. This is what applied AI looks like."
What I built:
- Complete ML pipeline: data preprocessing with OpenCV + NumPy, class imbalance handling, augmentation
- Custom CNN architecture: design β training β evaluation β deployment
- Binary classification: malignant vs. benign CT scan images
- Live demo β
Python Β· TensorFlow Β· Keras Β· OpenCV Β· NumPy Β· Medical Imaging Β· CNN
πΈ PassportPro AI β Python Β· CNN Β· OpenCV Β· React Β· Live on Vercel
What I built:
- End-to-end CV app: face detection β background removal β government-spec compliance validation
- Custom CNN classifier checks size, lighting, and face positioning against official standards
- Cuts passport photo prep from 30+ min (studio visit) to under 30 seconds
- Real users, real product β deployed and live
Python Β· OpenCV Β· CNN Β· React Β· Computer Vision Β· Vercel
πΉ Redis-Lite β C++ Β· Concurrent In-Memory Key-Value Store
"Built this to understand why Redis chose single-threaded execution. Turns out it's a deliberate design choice for predictability β not a limitation."
Architecture:
Client Threads (N) Worker Thread (1)
ββββββββββββββββββ βββββββββββββββββ
thread_1 βββ
thread_2 βββΌβββΊ Command Queue βββΊ Serial Executor βββΊ Response
thread_N βββ (mutex-locked) (no data races) (future/promise)
What I built:
- Single-worker command queue β all mutations serialized, zero coarse locking
SET/GET/DELacross N concurrent clients viastd::mutex+std::condition_variable- TTL-based expiration with
std::chrono::steady_clock+ LRU eviction - Stress tested: 10,000 concurrent threads β zero data corruption
C++ Β· Concurrency Β· Thread Safety Β· LRU Β· TTL Β· System Design
πΉ AnnouncePro β Python Β· Fault-Tolerant Scheduling Daemon
Deployed in production at CT University β running across 200+ network-connected endpoints.
What I built:
- Long-running OS-managed background service with persistence across reboots
- Priority-aware, conflict-free job scheduling with Β±1s accuracy across 100+ concurrent jobs
- Structured rotating log pipeline + auto-restart failure recovery + Singleton pattern
Python Β· APScheduler Β· Multithreading Β· Fault Tolerance Β· Structured Logging
πΉ CONNX β Social Platform β Node.js Β· MongoDB Β· JWT Β· Next.js
- 15+ REST API endpoints β JWT auth, social graph, personalised feed
- Compound-indexed MongoDB, rate limiting, pagination, Cloudinary CDN
- Full production deployment β live at connx.vercel.app
Node.js Β· MongoDB Β· JWT Β· Next.js Β· REST APIs
- 300+ problems solved across Easy, Medium, Hard β top 17% globally
- Focus areas: Trees, Graphs, DP, Sliding Window, Concurrency problems
Backend / Systems Intern β CTech Labs, Ludhiana (Dec 2023 β May 2024)
- Sole feature owner from requirement β production deployment in Agile environment
- Deployed Python scheduling service across 200+ endpoints β reduced manual overhead by ~100%
- Engineered failure recovery, rotating logs, auto-restart; Β±1s scheduling accuracy across 100+ jobs
Full Stack Developer Intern β Suven Consultants (Remote) (Jun 2023 β Aug 2023)
- Built React.js + Node.js client applications; improved page load speed by 20%
- Engineered modular REST APIs integrated with MongoDB in Agile team environment
"I prefer understanding how systems work internally β before scaling them externally."
- Build to understand β I've rebuilt Redis in C++ and built my own RAG pipeline from scratch. Using a tool you built teaches you what no docs can.
- AI that actually works β not notebooks, but deployed products with real users (PassportPro, Lung Cancer CNN)
- Correctness before performance β a fast broken system is worse than a slow correct one
Actively looking for AI/ML Engineer or SDE-1 / Backend Engineer roles. If you're building in AI, infrastructure, fintech, or distributed systems β let's talk.