🎓 B.Tech student passionate about Software Engineering & Artificial Intelligence

🤖 Building with LLMs, Transformers, RAG & AI Agents

⚙️ Developing backend systems and APIs with Python & FastAPI

🧠 Solved 300+ DSA problems across multiple coding platforms

🌎 Exploring and contributing to Open Source

🚀 Learning primarily by building real systems

Python · Java · C · JavaScript · TypeScript

HTML · CSS · SQL

FastAPI · REST APIs · WebSockets

PostgreSQL · SQLAlchemy · SQL

Redis · Firebase · Supabase

JWT · OAuth · Authentication · Authorization

Docker · OpenAPI · Swagger

Transformers · Large Language Models

Tokenization · Embeddings

Hugging Face · Hugging Face Models

Model Inference

Fine-Tuning · Transfer Learning

Model Adaptation · Pre-trained Models

RAG · Agentic RAG

Vector Search · Hybrid Search

Embeddings · PGVector

Retrieval Pipelines

AI Agents · Agentic Systems

Tool Calling · Agent Memory

LangChain · LangGraph

Multi-Agent Systems

Vision Models · Multimodal LLMs

Image Understanding

TensorFlow · LightGBM

Scikit-learn · Pandas · NumPy

Feature Engineering

Classification · Fraud Detection

React · JavaScript · TypeScript

Tailwind CSS · HTML · CSS

Git · GitHub · VS Code

Docker · Kubernetes

Netlify · Storybook

A hybrid AI + deterministic financial decision system that determines whether a requested expense can be safely afforded.

• 🧠 AI-based financial information interpretation
• 👁️ Multimodal amount extraction
• 🏦 Financial state reconstruction
• 📈 90-day cash-flow forecasting
• 💳 Payment strategy generation
• 🧮 Deterministic financial simulation
• 🛡️ Financial safety validation
• 📊 Payment-plan evaluation
• ⚡ Deterministic candidate ranking
• ✅ Final decision validation

Financial Evidence
        │
        ▼
┌───────────────────┐
│   AI Perception   │
└─────────┬─────────┘
          ▼
   Structured Data
          │
          ▼
 Financial State
 Reconstruction
          │
          ▼
  90-Day Simulation
          │
          ▼
 Payment Strategies
          │
          ▼
 Safety Validation
          │
          ▼
 Deterministic Ranking
          │
          ▼
  Validated Decision

Stack

Python · LLMs · Gemini · OpenRouter

Multimodal AI · Financial Simulation

🔗 View Repository →

A machine-learning system focused on detecting suspicious and coordinated fraudulent behavior from financial transaction data.

• 📊 Feature engineering
• ⚖️ Imbalanced classification
• 🌳 Gradient boosting
• 🔬 Model experimentation
• 📈 ROC-AUC evaluation
• 🎯 PR-AUC evaluation
• 🔍 Fraud pattern analysis
• 🧪 Model comparison

Stack

Python · LightGBM · Scikit-learn

Pandas · NumPy · Machine Learning

🔗 View Repository →

A backend system designed around financial transactions, concurrency, consistency, security, and reliable state management.

• PostgreSQL row-level locking with SELECT ... FOR UPDATE
• Handles concurrent fund transfers safely
• Prevents race conditions and double-spending
• Locks sender/receiver account rows during transfers

• Atomic multi-step fund transfers
• Explicit transaction boundaries
• Commit / rollback handling
• Maintains consistency across account, transaction, and ledger updates

• Records debit and credit operations
• Links ledger entries to transactions and accounts
• Maintains an auditable financial history
• Rolls back together with the transaction when failures occur

• Redis-backed idempotency keys
• Prevents duplicate financial operations
• Stores completed transaction responses with TTL
• Retry requests return the previously processed result

• Redis-based request tracking
• Sliding-window rate limiting
• Uses WATCH / MULTI / EXEC for atomic updates
• Protects sensitive transaction endpoints

• JWT authentication
• Access + refresh tokens
• Redis-backed sessions
• Protected endpoints
• Token validation and expiration

• Explicit rollback on failed operations
• Handles expected application errors separately
• Prevents partial financial state
• Safe failure responses for unexpected errors

• Records important financial actions
• Associates actions with users and transactions
• Stores action descriptions and context
• Provides traceability for financial operations

• Relational data modeling
• Foreign-key relationships
• Unique constraints
• SQLAlchemy ORM
• Database-level consistency

• Alembic migrations
• Version-controlled database schema
• Reproducible database changes

             API / Controllers
                     │
                     ▼
                  Services
                     │
                     ▼
                Repositories
                     │
                     ▼
                 PostgreSQL

• Controllers handle HTTP concerns
• Services contain business logic
• Repositories handle database operations
• Transaction boundaries controlled by the service layer

• Transaction history APIs
• Pagination
• Structured response schemas
• Repository-based querying

Redis
 ├── Idempotency
 ├── Sessions
 ├── Rate Limiting
 └── Cached Responses

• OpenAPI specification
• Swagger UI
• ReDoc
• Pydantic request / response validation

• GitHub Actions
• Automated testing workflows
• Automated deployment workflows

Stack

Python · FastAPI · PostgreSQL

SQLAlchemy · Redis · Alembic

JWT · Docker · GitHub Actions

🔗 View Repository →

I've solved 300+ DSA problems across multiple coding platforms, focusing on pattern recognition, optimization, complexity analysis, and problem solving.

Arrays
Strings
Hashing
Two Pointers
Sliding Window
Binary Search
Sorting
Stacks
Monotonic Stack
Linked Lists
Trees
Graphs
BFS
DFS
Heaps
Greedy
Dynamic Programming

Understand the Problem
        ↓
Identify the Pattern
        ↓
Design the Approach
        ↓
Analyze Complexity
        ↓
Implement
        ↓
Optimize
        ↓
Test Edge Cases

🔗 View My LeetCode →

I enjoy working with real-world codebases, understanding existing systems, fixing problems, and contributing improvements back to the community.

🔍 Find a Problem
       ↓
🐛 Reproduce It
       ↓
🧠 Understand the Codebase
       ↓
🛠️ Implement a Solution
       ↓
🧪 Test
       ↓
📦 Open Pull Request
       ↓
🌎 Contribute Back

AI/ML · LLMs · Developer Tools

Python · Backend · Open Source AI

🔗 Explore My GitHub Contributions →

                 Python
                    │
                    ▼
            Backend Engineering
                    │
                    ▼
          Machine Learning Basics
                    │
                    ▼
        Transformers & Hugging Face
                    │
                    ▼
                  LLMs
                    │
                    ▼
                   RAG
                    │
                    ▼
              AI Agents
                    │
                    ▼
             Agentic RAG
                    │
                    ▼
           Multi-Agent Systems
                    │
                    ▼
          Production AI Systems

• 🧠 Transformer architectures
• 🤗 Hugging Face ecosystem
• 🎯 Fine-tuning language models
• 🔎 Advanced RAG
• 🤖 AI Agents
• 🛠️ Tool-using agents
• 🧠 Agent memory
• 🔗 LangGraph
• 🧩 Multi-agent architectures
• 📊 LLM evaluation
• 🔬 AI observability
• 💻 SWE Agents

I like understanding what's happening underneath the frameworks and libraries I use.

Learn
  ↓
Build
  ↓
Break
  ↓
Debug
  ↓
Understand
  ↓
Improve

For systems where correctness matters, I prefer separating:

             LLM
              │
              ▼
       Interpretation
              │
              ▼
       Structured Data
              │
              ▼
     Deterministic Logic
              │
              ▼
          Validation

AI handles understanding.

Code handles correctness.

┌──────────────────────────────────────┐
│                                      │
│  🧩 Data Structures & Algorithms    │
│                                      │
│  ⚙️ Backend Engineering             │
│                                      │
│  🏗️ LLD & System Design             │
│                                      │
│  🤖 AI Agents                       │
│                                      │
│  🧠 Transformers & LLMs             │
│                                      │
│  🔎 RAG & Retrieval                 │
│                                      │
│  🤗 Hugging Face & Fine-Tuning      │
│                                      │
│  🌎 Open Source                     │
│                                      │
└──────────────────────────────────────┘

Don't just learn the tool. Understand the system behind the tool.

Algorithms
    ↓
Data Structures
    ↓
Software Design
    ↓
Backend Systems
    ↓
Databases
    ↓
Distributed Systems
    ↓
Machine Learning
    ↓
Transformers
    ↓
LLMs
    ↓
RAG
    ↓
Agents
    ↓
Production AI

⭐ If you find something interesting, consider giving the repository a star!