Work

23 things I built. Most of them have a small live model you can play with.

Chat backend built for 10 million connections

Backend & systems. Stateless gateways, Kafka fan-out and end-to-end encryption.

A production-style messaging backend designed to hold up to 10 million concurrent users. Messaging looks simple until you ask it to serve millions of people at once. Connections have to stay open, messages must never be lost when someone is offline, group chats multiply every message, and the content has to stay private.

How it works

  • Stateless WebSocket gateways hold the persistent connections, so any gateway can be added or removed without losing state.
  • Services split by job: chat, groups, users, presence, receipts, offline sync, crypto keys and media.
  • Each kind of data lives where it fits: Redis for ephemeral state, Cassandra for messages, PostgreSQL for users and S3 for media.
  • Kafka fans group messages out asynchronously so one busy group cannot stall everyone else.
  • End-to-end encryption uses Signal Protocol style key management; media goes through pre-signed S3 URLs.

What I learned: Choosing the right store for each kind of data matters more than choosing one great database.

Built with Distributed systems, Kafka, Redis, Cassandra, WebSockets, E2E encryption. Code on GitHub

The Traffic Jam: an observability lab

Backend & systems. Nginx, Prometheus, Grafana and k6 in one Docker Compose command.

A small, complete stack that shows how a service behaves under load, and how to see it happening. It is easy to read about load balancers and dashboards. It is harder to feel what happens when CPU-heavy requests pile up. This project makes that visible.

How it works

  • A Node.js service with a health route, a heavy route that pushes CPU work into worker threads, and a metrics route.
  • Nginx sits in front as a reverse proxy and load balancer using least-connections, and keeps the metrics route private.
  • Prometheus scrapes custom metrics (including a gauge of active workers) and Grafana turns them into dashboards.
  • k6 generates 50 virtual users of load for 30 seconds so the graphs have something to show.
  • Everything starts with one Docker Compose command.

What I learned: You only trust a system you can watch. Metrics first, then tuning.

Built with Observability, Docker, Nginx, Prometheus, Grafana, k6. Code on GitHub

Job Hunter: a search agent without an LLM

Automation & tools. Ranks open roles at 40+ companies by skill match. No LLM.

Finds open roles at 40+ product companies in real time and builds an interactive report, with no AI model in the loop. Job searching means checking dozens of career pages and job boards by hand, then losing track of what matched.

How it works

  • Searches several sources and ranks each listing by how many of your skills match it.
  • Organises 40+ target companies into categories such as Big Tech, Security/IAM and Indian unicorns, so one flag searches one group.
  • Builds a single HTML report with search, filters, company ratings and interview prep notes for each company.
  • Adds polite delays between searches to avoid being blocked.

What I learned: A plain ranking rule is easy to explain and often enough.

Built with Python, Automation, Scraping, Reports. Code on GitHub

AutoConnect: LinkedIn outreach automation

Automation & tools. Automates the repetitive part of connecting on LinkedIn.

A small tool that automates connecting with recruiters and other people on LinkedIn. Sending the same connection request again and again is exactly the kind of task that should be automated.

How it works

  • Automates the repetitive connect flow and can be customised to scrape or automate other LinkedIn tasks.

What I learned: If it happens twice, script it. Then check the platform's rules before running it.

Built with Python, Automation. Code on GitHub

Custom Data Visualisation

Data & dashboards. Upload a dataset, check its quality and plot custom graphs.

A web app where anyone can upload a dataset, explore it, check its quality and plot custom graphs. Looking at a new dataset usually means writing the same exploration code each time.

How it works

  • Login and sign-up with a small database behind them.
  • Upload a dataset and get instant basic visualisations.
  • Build custom graphs of your own choosing.
  • A data quality view highlights problems before analysis starts.

What I learned: Good defaults get people to the interesting question faster.

Built with Python, Streamlit, Data science, Visualisation. Code on GitHub

A Hacker News clone on GraphQL

Web apps. Links, voting, pagination and live updates over GraphQL subscriptions.

A small Hacker News-style site built to learn GraphQL end to end. People sign up, post links, vote on them and page through the list, and new activity shows up without a refresh.

How it works

  • A React front end talks to an Apollo server through GraphQL.
  • Prisma sits between the server and the database.
  • Sign-up and authentication come first, then creating and voting on links.
  • Pagination keeps long lists fast.
  • GraphQL subscriptions push new links and votes to everyone in real time.

What I learned: With subscriptions the server tells clients what changed, instead of clients asking again and again.

Built with React, GraphQL, Apollo, Prisma. Code on GitHub

Superstore sales dashboard

Data & dashboards. An interactive Power BI dashboard to analyse and forecast sales.

An interactive dashboard built in Power BI to understand sales performance and look ahead.

How it works

  • Sales data is modelled in Power BI.
  • Interactive visuals filter each other, for example by category.
  • A forecast extends the trend into the coming months.

What I learned: A dashboard is useful when a person can change the question without changing the report.

Built with Power BI, Dashboards, Forecasting. Code on GitHub

A React news app

Web apps. A simple API-based news web app that shows the stories you ask for.

A simple web app that pulls news from an API and shows the stories and their contents.

How it works

  • A React front end renders the articles.
  • Axios fetches data from a news API.
  • Postman was used to try the API calls before writing code.
  • Bootstrap handles the layout.

What I learned: Test the API in a tool first. Once you know what comes back, the front end is simple.

Built with React, Axios, News API, Bootstrap. Code on GitHub

Image processing basics

Machine learning. A TensorFlow practice project that turns images into arrays.

A practice notebook for turning pictures into numbers, the first step before any model can look at an image.

How it works

  • Read the image from a link or by file name.
  • Make sure it is a NumPy array, and display it to check.
  • Resize it with Pillow and save the result.
  • Convert RGB to greyscale with OpenCV.

What I learned: Colour is not always needed. Greyscale needs far less processing when you only care about shapes.

Built with Python, OpenCV, Pillow, NumPy. Code on GitHub

YouTube channel analysis

Data & dashboards. A small data analysis of YouTube channels using the YouTube API.

A notebook that pulls public statistics for a few channels and finds patterns in them.

How it works

  • List the channel IDs to study.
  • Call the YouTube API for each channel's statistics.
  • Turn the response into a pandas DataFrame and convert strings to numbers.
  • Plot subscribers and views per channel.
  • Fetch video details, sort the top 10 and count videos per month.
  • Save everything to a CSV file.

What I learned: Most of the work is cleaning: strings become numbers before any chart is honest.

Built with Python, pandas, YouTube API. Code on GitHub

News summariser with sentiment

Machine learning. A first step into NLP: summarise an article and read its mood.

A small desktop app that takes a link to a news article and returns a summary, details and the sentiment of the text.

How it works

  • A tkinter window has several fields that stay disabled until a URL is pasted.
  • The article package downloads the page and runs its language processing.
  • The title, author, publisher and summary are placed in their fields.
  • TextBlob turns the text into a blob and reports its polarity.

What I learned: A library can do the heavy lifting, but you still need to know what a number like polarity means.

Built with Python, tkinter, NLTK, TextBlob. Code on GitHub

Credit card fraud detection

Machine learning. A logistic regression model that spots fraudulent transactions.

A model that predicts whether a card transaction is fraud, trained on a dataset of almost 3 lakh transactions.

How it works

  • Load the dataset and check for missing values.
  • Count the labels: legitimate transactions outnumber fraud by about 99 to 1.
  • Compare the two groups and build a balanced sample with a similar distribution.
  • Split the data 80/20, keeping the label ratio the same in both halves.
  • Train a logistic regression model and check training and test accuracy: 92% and 90%.

What I learned: On unbalanced data, accuracy can lie. Always compare training and test scores to catch overfitting.

Built with Python, scikit-learn, pandas. Code on GitHub

Loan status prediction

Machine learning. A support vector machine that predicts whether a loan is sanctioned.

A model that learns from past applications to predict whether a new loan will be sanctioned.

How it works

  • Load the data and drop rows with missing values.
  • Label-encode the answer: 1 for yes, 0 for no.
  • Replace the odd "3+" dependents value with 4.
  • Plot education, marriage and property area against the loan status.
  • Turn text columns into numbers and split into train and test.
  • Train a linear SVM and compare the accuracy on both halves.

What I learned: Cleaning and encoding take more steps than the model itself.

Built with Python, scikit-learn, seaborn. Code on GitHub

Customer segments with K-means

Machine learning. Unsupervised clustering of a company's customers.

An unsupervised model that groups customers by annual income and spending score so a business can see who to target.

How it works

  • Take the customer dataset and check for missing data.
  • Slice the income and spending columns.
  • Compute WCSS for every cluster count and look for the sharp drop.
  • Train K-means with five clusters.
  • Plot each cluster in its own colour with its centroid.

What I learned: Clusters become useful once each colour gets a plain-language meaning, for example "low income, low spend".

Built with Python, scikit-learn, Matplotlib. Code on GitHub

Fake news detection

Machine learning. A logistic regression model that flags fake news.

A text classifier that learns what fake and real articles look like and labels new ones.

How it works

  • Download English stop words with NLTK.
  • Fill missing values and merge the author and title.
  • Stem every word to its root, remove non-letters, lowercase and drop stop words.
  • Vectorise the text, turning words into numbers.
  • Split into train and test and fit a logistic regression.
  • Check accuracy on both halves and predict a new article.

What I learned: Models read numbers, not sentences. Most of the craft is how the text becomes numbers.

Built with Python, NLTK, scikit-learn. Code on GitHub

University site in neumorphism

Web apps. A university website designed with soft, extruded UI.

A university website built to explore neumorphism, a style where elements look softly pressed out of the page.

How it works

  • One background colour for page and components.
  • A light shadow on one side and a dark shadow on the other create the raised look.
  • An inset version of the same shadows makes pressed states.

What I learned: Neumorphism is all in the shadows. It looks lovely and needs care with contrast.

Built with HTML, CSS, Neumorphism. Code on GitHub

Job application management system

Web apps. A DBMS mini-project for applying to jobs and managing the applications.

A job application system with one side for applicants and one for admins, built as a database mini-project.

How it works

  • Applicants fill in a form with consistent input handling and upload a photo.
  • They can check their application status, edit it after submission and send feedback.
  • Admins log in securely with sessions.
  • Admins see every record, filter by date or position, search, edit and delete.
  • Charts show the data in real time, and an ER diagram and schema back the relational design.

What I learned: Designing the tables first makes every screen on top of them simpler.

Built with PHP, MySQL, Bootstrap, XAMPP. Code on GitHub

Fun activities and tools

Web apps. A React site to play and explore small things in one place.

A small React app with text utilities, games and silly extras, all in one place.

How it works

  • Text utilities such as upper and lower case, reading time and BMI.
  • Games: Snake Water Gun, Guess the number and Rock Paper Scissors.
  • Fun extras: random jokes, a bored-solver and captcha generation.

What I learned: Small toys are a fast way to practise state and events.

Built with React, JavaScript. Code on GitHub

Marketplace

Web apps. A Django site to place and manage items for sale.

A marketplace where people list items, search and filter them, and chat with sellers.

How it works

  • Authentication for buyers and sellers.
  • An items gallery with search and filters.
  • Chat between customer and seller.
  • Related items are suggested on each item page.
  • Admin and interactive dashboards, with automatic light and dark modes.

What I learned: Related-item suggestions only need a good definition of "related".

Built with Python, Django, Tailwind CSS, SQLite. Code on GitHub

learnBro, a community app

Web apps. A Django app to join topic communities and share thoughts.

A discussion app where people host rooms around a topic and talk to others who joined for the same reason.

How it works

  • Authentication and safe authorisation, plus user profiles.
  • Hosting a room for a topic and messaging in other people's rooms.
  • Search over posts and topics.
  • Full create, read, update and delete.
  • A Django REST API with cross-origin headers for other clients.

What I learned: A room is just a topic with messages. Keep that model simple and the features follow.

Built with Python, Django, Django REST, SQLite. Code on GitHub

Basic bank operations in Go

Backend & systems. Deposit, withdraw and statement, first as a CLI then on the web.

A small project in Go that implements the basic operations of a bank: deposit, withdraw and statement. It started in the terminal and was later moved to the web.

How it works

  • Deposit adds money to the balance.
  • Withdraw takes money out, refusing if funds are short.
  • Statement lists every transaction.

What I learned: Writing the same small logic for a CLI and then for the web shows which parts are really the business rules.

Built with Go. Code on GitHub

T20 World Cup analysis

Data & dashboards. A Power BI dashboard to find insights in T20 World Cup 2022 data.

A dashboard built from scraped tournament data that shows batting, bowling and all-round performance.

How it works

  • Scrape raw data from ESPN Cricinfo with Bright Data.
  • Load it into Power BI.
  • Build pages for batting, bowling and all-rounders.
  • Add a page to pick your own XI.

What I learned: Scraping gets you the data, but the story only appears once it is shaped into the right views.

Built with Power BI, Web scraping. Code on GitHub

GDP analysis and prediction

Machine learning. Predict the GDP of 227 countries and suggest how to grow it.

A machine-learning project that analyses GDP per capita for countries around the world and for India, predicts future values and gives recommendations.

How it works

  • Sign-in, then an interactive page where the user changes parameters.
  • Prediction of GDP for 227 countries, with India in detail.
  • Analysis of GDP per capita for the world and India.
  • A recommendation for what it takes to reach a growth target the user chooses.

What I learned: Letting people change the inputs turns a prediction into something they can reason with.

Built with Python, Streamlit, SQLite, Plotly. Code on GitHub