483 debates. 148+ trades. 370k LLM tokens. Under a dollar.

I called it Sudo Trade - kinda like super admin access to the trading with AI and trying to do money maxing. Also thought of naming it vibe-trading or git-rich but both already exist.

sudo-trade is roughly ~7,000 lines of Python. Just a bunch of APIs + asyncio, an event bus, and a lots of LLMs that disagree with each other for a living.

The whole thing started because I wanted to check: If I can utilise my dev skills with most sophisticated AI models to build something that actually trades intelligently? Not a plain simple wrapper that fires market orders when RSI crosses 30. Something with real decision-making. Something that "thinks" before it spends/executes trades.
*think here means recursive API calls to multiple LLMs

How It Was Built

I pair-programmed + vibe coded almost all of it with Claude Code and Codex. Where I was swaping with multiple models like Gemini 3.1 Pro for architecture then Claude Opus 4.6 1M for coding and Codex 5.3 EH for code review. I'd describe what I wanted, we'd argue about the architecture, it would write the code, I'd review with codex, we'd iterate a bunch of times. Finally pulled this in about a week.

But the wild part: Claude Code also runs the trading engine - Master agent. The system ships with an MCP server (Model Context Protocol) - that lets Claude orchestrate everything conversationally. I open my terminal, say "start the engine, screen RELIANCE TCS INFY, debate the top picks, approve the strong buys" - and it does. No complex things. Just navigating to it.

The MCP server is stateless - 8 tools, 7 resources, 4 workflow prompts. It's a thin translation layer between Claude and the engine's HTTP API. The engine doesn't know it's being driven by an AI. Claude doesn't know it's talking to a trading system. They just speak HTTP and MCP in between.

The Debate Mechanism

This is the part I'm most proud of. When the screener picks a stock, it doesn't go straight to execution. Pulls all the news and starts finding the co-relation. (This is where LLMs are good at)

Two separate agents argue the case:

BULL_SYSTEM = "You are a senior buy-side analyst who is BULLISH on the stock.
Build the strongest possible case for BUYING this stock.
Be specific - cite numbers, patterns, and catalysts. No vague optimism."

BEAR_SYSTEM = "You are a senior risk analyst who is BEARISH on the stock.
Build the strongest possible case AGAINST buying this stock.
Be specific - cite numbers, patterns, and warnings. No vague pessimism."

Two rounds. Bull argues, bear tears it apart, bull rebuts, bear rebuts. Then a third agent - a neutral "portfolio manager" - reads both sides and renders a verdict: strong_buy, buy, hold, sell, or strong_sell.

"No vague optimism" is doing the heavy lifting here. Force specificity and the arguments get genuinely good. The bull can't just say "strong fundamentals" - it cites the actual USFDA clearance and 150+ ANDA pipeline. The bear names the FDA warning letters and US pricing erosion at 8-12%.

The debaters also have memory. They remember past debates on the same stock - what they argued, what the verdict was, whether they won. A bull agent that got overruled last time on RELIANCE comes back with sharper evidence the next round. They learn.

I've shown this to people who run trading desks and brokerages. They get it immediately.

₹10 Lakh → ₹23.66 Lakh in 10 Days

I seeded the system with ₹10 lakh and let it run.

First few days were rough. The consensus engine was too conservative - every verdict came back "hold" at 65% confidence. The system debated 15 stocks and bought zero of them. An AI that never trades is an expensive screensaver. I tuned the prompts to bias toward action and added portfolio context so the master actually knew what it was holding before deciding what to do.

Then things got interesting. March 2026 - India-Pakistan tensions escalating, markets swinging 2-3% intraday. The kind of environment where retail traders panic sell at the bottom and FOMO buy at the top. The system ran through 10 days of this. ₹10,00,000 → ₹23,66,000+. 148 trades, mostly in LUPIN, POLYCAB, MPHASIS, and a handful of others the screener kept surfacing.

These are simulated fills - no slippage, no real liquidity - so take the exact numbers with a grain of salt. But the debate mechanism proved its thesis exactly when I hoped it would: during panic selling, the system was forced to argue both sides before committing capital. The bear agent kept catching overreactions the bull was ignoring. During relief rallies, the bull had to convince a skeptical bear before adding positions. Forced deliberation in a panicking market. That's the whole point.

A Typical Day

The system follows NSE market hours and runs a six-phase schedule:

9:00 AM - ResearchAgent wakes up, scans RSS feeds from MoneyControl and Economic Times, points Claude at raw headlines and says "figure out what matters." It extracts affected symbols, whether the impact is bullish or bearish, significance, time horizon.

9:15 AM - ScreenerAgent pulls live quotes for 120+ stocks, sorts by momentum and volume spikes, then asks an LLM to rank the top 5 intraday candidates. Two-stage filter: quantitative first (free), LLM ranking second (costs tokens but catches things numbers miss).

9:15–2:00 PM - Debates run for the top picks. Bull and bear argue simultaneously in round one, rebut each other in round two. Consensus judge scores. If confidence > 60%, the AnalysisAgent runs sentiment analysis. MasterAgent makes the final call with full context: debate verdict, signals, capital, and current positions.

2:00 PM - Closing phase. No new positions. Square off intraday.

3:30 PM - Daily report. Cost per agent, decisions made, P&L summary, saved to Firestore.

The scheduler knows IST. Knows Republic Day, Holi, Eid, Diwali - every NSE holiday hardcoded. Skips weekends. And there's a force_active mode for when you're debugging at 2 AM on a Saturday and can't wait for Monday.

What It Actually Costs

Real numbers from March 19, 2026:

Per-agent budgets auto-gate - if debaters blow their allocation, they stop arguing and the master falls back to heuristics. \(50/day limit, never hit \)2. Different agents run on different models: Claude Opus for debates and final decisions, cheap models for research and screening. Different API keys, different endpoints, different providers per agent. Zero code changes to swap any of them.

The Architecture (Short Version)

Everything is a plugin. Components never import each other - they talk through an async EventBus:

engine.add("broker", GrowwBroker(role=BrokerRole.DATA))
engine.add("executor", PaperExecutor(initial_capital=500_000))

# Screener doesn't know MasterAgent exists
await events.emit("agent:screened", symbols=["POLYCAB", "INFY"])

# Master listens, doesn't know who screened
events.on("agent:screened", self._on_screened)

Swap Groww for Zerodha, Claude for GPT, paper for live - nothing else changes. Brokers have roles: one for market data, another for execution. Agents don't know which broker does what. They ask for data, they ask for execution, routing is automatic. Full architecture in the README if you want to go deeper.

What I Learned

The consensus engine was way too conservative out of the box. Every verdict came back as "hold" at 65% confidence for days. An AI that never trades is an expensive screensaver. I tuned the system prompts to bias toward action and injected portfolio context so it actually knew what it was holding before deciding what to do with it.

LLM temperature matters more than model choice. Debaters at 0.7 produce genuinely different arguments each round. Consensus judge at 0.3 stays analytical. Master at 0.3 doesn't panic. Get the temperatures wrong and you get either boring debates where both agents repeat the same points, or a system that changes its mind every tick. The temperature spread is the personality of the system.

What's Next

Live execution is one place_order() away - the protocol, the broker integration, the approval queue, all built. Kite Connect for real fills. Technical analysis as a second analyzer alongside sentiment. A proper backtest of debate-driven decisions vs simple momentum to prove that arguing actually makes money.

The engine repo is private. The dashboard is public - that's the part you can see. The brain stays behind the curtain.

Open for feedback and I can provide exclusive access if anyone is curious to contribut to the engine which is basiclly the brain of this system.

My devfolio: shravanrevanna.me - checkout more interesting and cool projects here.

I built sudo-trade — a multi-agent system that researches Indian stocks, screens for opportunities, then forces a bull agent and a bear agent to argue the case before a neutral judge renders a verdict. All running autonomously during NSE market hours. Paper trading for now. Real money when I trust it enough.

The whole thing is ~7,000 lines of Python, no frameworks. Just asyncio, an event bus, and a bunch of LLMs that disagree with each other for a living.

Why

I wanted to know if one developer with Python and access to Claude could build something that actually trades intelligently — not just a wrapper around an API that fires market orders when RSI crosses 30.

Most AI trading projects I've seen are either toy demos ("here's a ChatGPT prompt that says buy RELIANCE") or enterprise platforms that cost six figures. There's nothing in between. I wanted the in-between.

The rule was simple: every component has to be swappable, every decision has to be explainable, and AI models have to earn their keep — not just rubber-stamp signals.

The Debate Mechanism

This is the part I'm most proud of. When the screener picks a stock, it doesn't go straight to execution. Instead, two separate agents get spun up:

BULL_SYSTEM = """You are a senior buy-side analyst who is BULLISH on the stock.
Build the strongest possible case for BUYING this stock.
Be specific — cite numbers, patterns, and catalysts. No vague optimism."""

BEAR_SYSTEM = """You are a senior risk analyst who is BEARISH on the stock.
Build the strongest possible case AGAINST buying this stock.
Be specific — cite numbers, patterns, and warnings. No vague pessimism."""

They argue for two rounds. Bull makes the case, bear tears it apart, bull rebuts, bear rebuts. Then a third LLM — a neutral "portfolio manager" — reads both sides and renders a verdict: strong_buy, buy, hold, sell, or strong_sell.

The key insight: the system prompt tells each agent "no vague optimism" and "no vague pessimism." Force specificity and the arguments actually get good. The bull agent can't just say "strong fundamentals" — it has to cite the actual USFDA clearance or the pipeline of ANDAs. The bear has to name the actual warning letters.

On March 19th, the system ran 98 debates across stocks like POLYCAB, TATAELXSI, COLPAL, INFY, and BOSCHLTD. Total LLM cost for the day: $0.87.

Everything Is a Plugin

I didn't want a monolith. Every layer is a plugin that registers with the engine:

engine.add("broker", GrowwBroker(role=BrokerRole.DATA))
engine.add("broker", KiteBroker(role=BrokerRole.EXECUTION))
engine.add("agent", master_agent)
engine.add("executor", PaperExecutor(initial_capital=500_000))

Brokers, data providers, analyzers, LLM clients, strategies, executors, interfaces — all implement a Protocol with name, start(), stop(). The engine doesn't know what they do. It just starts them in order and stops them in reverse.

Components never import each other. They talk through an async EventBus:

# Screener doesn't know MasterAgent exists
await self._events.emit("agent:screened", symbols=["POLYCAB", "INFY", "COLPAL"])

# Master listens, doesn't know who screened
self._events.on("agent:screened", self._on_screened)

This means I can swap Groww for Zerodha for data, swap Claude for GPT for the debaters, swap paper execution for live execution — without touching anything else. I tested this by running the entire pipeline with a $0.001/call model for screening and Claude Opus for debates. Different models, different API keys, different endpoints per agent. Zero code changes.

The Pipeline

Every market day, the system follows NSE hours:

9:00 AM — ResearchAgent scans RSS feeds from MoneyControl and Economic Times. Points Claude at raw headlines and says "figure out what matters." It extracts symbols, impact direction, significance, and time horizon.

9:15 AM — ScreenerAgent fetches live quotes for 120 stocks, sorts by momentum, then asks an LLM to rank the top 5 intraday candidates. Two-stage filter: quantitative first (free), then qualitative LLM ranking (costs tokens).

9:15–12:00 — Debates run. Bull and bear argue. Consensus judge scores them. If confidence > 60%, AnalysisAgent runs sentiment analysis. MasterAgent makes the final call with full context: debate verdict, analysis signals, current portfolio, and available capital.

2:00 PM — Closing phase. No new positions.

3:30 PM — Daily report. Cost breakdown per agent, decisions made, P&L summary.

The scheduler knows IST, knows NSE holidays (Republic Day, Holi, Eid — all hardcoded), and skips weekends. There's a force_active mode for testing outside market hours.

What It Actually Costs

Real numbers from a full trading day (March 19, 2026):

Under a dollar for a full day of autonomous research, screening, 98 debates, and trade decisions across 15+ stocks. I have a \(50/day budget configured and I've never hit even \)2. Per-agent budgets auto-gate — if the debaters blow their budget, they stop arguing and the master falls back to simple heuristics.

The Dashboard

The engine runs headless — just a Python process with an HTTP API. The dashboard is a separate React app that connects via WebSocket and shows everything in real-time: debates unfolding argument by argument, agents changing state, trades executing, P&L ticking.

I kept the engine repo private and made the dashboard public. The engine is the brain; the dashboard is the face.

During the India-Pakistan tension in March 2026, the system ran through 10 days of high-volatility sessions. Starting capital ₹10,00,000, current value ₹23,66,000+. The debate mechanism was especially useful here — forced the system to argue both sides during panic selling instead of blindly following momentum.

What I'd Do Differently

The consensus engine is too conservative. Every verdict came back as "hold" with 65% confidence for the first few days until I tuned the system prompts to bias toward action. An AI that never trades is useless.

I also learned that LLM temperature matters more than the model. Debaters at 0.7 (creative) produce genuinely different arguments round to round. The consensus judge at 0.3 (conservative) stays sober. The master at 0.3 doesn't get spooked. Getting this wrong meant either boring debates or erratic decisions.

What's Next

Live execution via Kite Connect — the protocol is already there, just need to wire up the real place_order(). Technical analysis as a second analyzer alongside sentiment. And a proper backtest of the debate mechanism against a simple momentum strategy to see if arguing actually helps.

The whole thing runs on my MacBook right now. It could run on a ₹500/month VPS. That's the point — this isn't infrastructure-heavy. It's just Python, some API keys, and a few models that argue about stocks for less than a dollar a day.

sudo-trade is open source (dashboard) at github.com/myselfshravan/sudo-trade-dashboard. The engine is private.

Well, my weekend was kind of like that. It all started with my Philips Wiz smart lights. They're fine. You open the wiz connect app, you tap a button, the light changes. But "fine" is boring. I wanted lil more control. I wanted to make them do things the app designer never dreamed of.

So, I got bored and did what any sane developer does: I fired up a network sniffer.

The "Aha!" Moment

After few minutes, I found the holy grail. These Rs.500 smart bulbs... they don't have a complicated, encrypted API.
They just listen for raw JSON commands sent over UDP to port 38899.
All you have to do is pass this JSON:

{"method": "setPilot", "params": {"r": 255, "g": 0, "b": 0}}

That's it. That's the key to access the lights. My weekend was gone. It was time to build. Thanks to Aleksandr Rogozin and his blog for the quick head start: Here is the Link

Level 1: The "Simple" API

First things first. I wrote a simple Python class (wiz_control.py) to discover the lights and send commands. Turn on, turn off, set color. Easy.

Then, I wrapped it in a FastAPI server (api_server.py). Now I had web endpoints. I could control my lights from my browser, from a script, from anywhere. I even threw together a quick index.html for a basic UI.

I'd built my own, better Wiz app. A solid project. I should have stopped there but I did not stop there.

Level 2: The Escalation (My Lights Can Dance)

I was looking at my projector, music playing, and it hit me.

"I have programmatic control of light. I have a microphone. I know what must be done."

I programmed audio_visualizer.py feature.

The idea: capture audio from my mic, run a Fast Fourier Transform (FFT) on it in real-time, and split the audio into frequencies.

• Bass (20-250Hz) → Mapped to the Red channel.

• Mids (250-4000Hz) → Mapped to the Green channel.

• Treble (4000-20000Hz) → Mapped to the Blue channel.

I ran the script, put on some music, and... it was insane.

The lights were reacting to each music beasts. Bass drops made the room flash deep red. Cymbals sent pulses of blue. It was alive.

But then I was like Why just one mode?

• I built a pulse mode: The light stays a warm white, but the brightness pulses with the music's amplitude.

• I built a strobe mode: Aggressive white flashes on every single beat. Perfect for EDM.

• I built a multi mode: If you have multiple lights, one light becomes the bass, one becomes the mids, and one becomes the treble. It's bonkers.

Level 3: The "Next-Level" Insanity (DIY Ambilight)

At this point, it was probably around 11PM. I was running on pure adrenaline and dangerously high levels of "what if..." I was parallely brainstorming with ChatGPT and Claude then I got one more idea.
"Wait... what if the lights reacted to videos?"
Philips and others charges a fortune for this "Ambilight" feature. I was pretty sure I could build it with OpenCV and my video_visualizer.py script.

And I did 😎

I wrote a new analyzer that loads any video file (mp4), reads it frame by frame, and does two things:

1. Analyzes the color: I built a dominant_color mode that uses K-means clustering to find the main color of the entire frame and sends it to the lights.

2. Analyzes the edges: I built a true edge_analysis mode that samples only the pixels on the outer border of the frame, just like a real Ambilight.

I put on a teaser from this upcomming movie called Ramayana. An explosion happened on screen, and my entire room flashed and now are in sync. A scene with arrow turned my walls a deep, pulsing blue.(~93ms latency)

This was, without a doubt, one of the coolest thing I have ever built among ~150 projects.

I even made a hybrid mode that takes the color from the video and the brightness from the video's audio track. It's the ultimate sensory experience.

Level 4: The Final Descent (My Room is a Stock Ticker)

This is the part I can't really explain. This is where the project went from a "cool personal hack" to "a full-blown obsession."
Recently, a post from Pankaj Tanwar (a builder I hugely admire) went viral. He had hooked his lights up to his Zerodha portfolio with RPi4.

I saw that and thought, "That's it. That's the final level."

I had to do it. But I use Groww.

I figured, 'What's the harm in asking?' I found Vamsi on the Groww team, sent him a DM, and showed him my music and video visualizers.

He loved it. And then he did something legendary: he hooked me up with free, exclusive access to the official Groww Trading API.

Pankaj asked me exploit it immidiately. Now I had to build it.

The logic is simple:

1. Fetch my stock's price (let's say GROWW).

2. Fetch the opening price for the day.

3. If current_price > opening_price, my lights turn GREENish.

4. If current_price < opening_price, my lights turn REDish.

5. The brightness of the light is tied to the magnitude of the change. A +2% day is brighter than a +0.5% day.

My room is now a real-time trading floor indicator:

I can just sit here, and if my peripheral vision suddenly turns a deep, angry red, I know I'm losing money. This is either genius or the worst idea I've ever had for my mental health. (btw I don’t trade - Mutual Funds sahi hai)

I even built a stock_replay.py that takes historical data and replays the entire market day at 20x speed, so u can visualized as a frantic green-and-red light show.

The Aftermath

So, yeah. My simple weekend project to build a custom light switch spiraled into a full-sensory data visualization platform that reacts to music, movies, and the Indian stock market.

All because a smart multi colour light bulb had an open UDP port.

It's been a wild ride, and the project is already getting some love and sparking conversations on Twitter and r/developersIndia.

You can find all the code from the simple API to the stock ticker on my GitHub (myselfshravan/wiz-hack).

If you have made it till here then great. Thanks for reading and stay tuned for whats coming next…
It could be a sound box playing music based on the stock value or a simple stock tradebook analyser by AI and some cool browser entensions.

I have used multiple AI tools with best prompts/instructions + CLAUDE.md and I was only able to produce a barely functional prototype but eventually I had to architect everything myself and change/redesign a lots of things in mid-way like from database user doc schema to making better reusable/readable components.
- This project helped me understand basics of how in-app browsers works.
- How firebase reads and writes can be optimised. (I hit rate limit while developing)
- Even something basic like how and where caching should be used.
- Also learnt from the mistakes throughout (vibe coding can reduce productivity if not controlled)

I will be writing one more detailed blog on how I went into the depths of fundamental to optimise this project. It will include how I enhanced click-track to have minimal latency and how DB reads and writes are optimised to handle at large scale. (Database store = where I store logs/track every single interactions throughout this site)

The hidden piece: Interactive Terminal

Yes that terminal that you see is a fully functional piece. To activate it, you have to try closing the terminal [click on red dot once] and then the terminal session starts. Highly recommend desktop view but it works on phone as well.

The centerpiece of the portfolio where you're greeted with on the homepage. It's not just a design element; it's a fully functional interface for navigating the site and some basic commands.

• Real-Time Interaction: You can run commands like help or ?, projects, and skills to get information and jump to different sections. (They gets executed on my old phone that runs terminal emulator)

• Authentic Feel: It mimics a real terminal [mac] with features like command history (using the arrow keys), tab completion for commands, and even a few fun easter eggs (try running sudo!)

• Pinch of AI: Activate it by running command like ai or activate ai and boom. now you are interacting with an custom context LLM that has context of the portfolio. (isn’t it cool? yeah ik)

• Log everything asynchronously: Every command entered is tracked (sneaky but this is just the start), so this keeps the UI snappy and responsive without waiting for the analytics to complete.

• There are lots of fingerprints tracking that is involved which I will talk about later. hint: ?s=hash

Under the Hood: The Engineering That Powers It

This portfolio is more than just a frontend design. It's packed with custom-built features that shows my approach to building and engineering.

1. Custom Analytics Engine

I built an analytics engine from scratch to track user interactions. Goal was to have non-blocking fringerprint tracking system that:

• Queues and batches user interaction data: This ensures that analytics events are sent efficiently without impacting the user experience. Initially it was laggy as the re-action was waiting for the POST or PATCH requests to the firebase database but it was optimised from 200-300ms reaction time to almost unnoticeable latency and it is almost instantaneous.

• Handles online/offline states: If you go offline, the tracker saves your interactions and sends them when you're back online. It is designed to be in such a way where every click and command from the website is captured without any lag.

• Tracking and analytics came a long way:

  • My first attempt, I tracked interactions the brute-force way: a button-click tracker that fired regular patch() calls. It worked… but blocked navigation, adding lag and sometimes dropping data if the user bounced too fast. Button-Track was having having a lots of issue with the clicks. The clicks were laggy and felt the site is buggy. Check code here branch button-track.

  • Next, I tried a click event tracker that was lighter, but still depended on async requests finishing before the page unload still not reliable on fast exits or mobile browsers. Click-Track which optimised to certain level but it was not perfect. Check code here branch click-track.

  • The final evolution Track-External was using navigator.sendBeacon(). By sending a tiny payload in a “fire-and-forget” way, clicks now get logged instantly without slowing the user down (click operation). Add in batching + retries for offline cases, and tracking became smooth, and invisible to the user. If sendBeacon isn’t available or fails, fallback to direct Firebase call. Code here.

  • Maintain an in-page queue (clickTracker) that batches, retries, and syncs periodically and on online events. Limit queue size and requeue on failures to avoid data loss.

  • The current website tracks external link clicks reliably from a static GitHub Pages frontend (https://shravanrevanna.me) and send them to a Vercel serverless function (vercel deployed api /api/track-external) without blocking navigation.

• Result / Impact

  • Reliable, non-blocking external click tracking that works across browsers and in-app browsers.

  • Minimal latency impact on user navigation and robust retry behavior for offline/insecure contexts.

  • Helps me understand how the visitors are driven and what content/projects are most viewed.

Viewing insights (Admin panel for the database)

Yeah, I built my own personal admin panel solely to monitor all the collected data.

Above [which looks like stock market chart] is the view to see the visits to the portfolio over time [last 30d] with [grouped by Daily]. (Developed from scratch)

Visits spike after posting on LinkedIn about - groww portfolio synced smart lights.

I can even track how many visits are from different hashed urls, so if anyone opens a hash url then i can monitor the activity.

While I was building the admin panel, the way I was storing the documents and the way I wanted insights was not compatible and I had to redesign the schema that supports view as well as record efficiently.

The above is the Firebase Console that shows the usage of the documents reads and writes

I hit the rate limit why? I wanted the insights (admin console) in a very specific manner and the AI generated code was initially designed in a way to exactly cater my view. But it totally forgot the scale and each time I reloaded there the code was reading all the documents iteratively and recursively which led to this. Bit eventually the redesigned architecture now has much lesser reads and writes.

2. Real-Time Github Stats API

The GitHub statistics on the site are not just static images. They are fetched in real-time from a self-hosted git-stats-api that I built from scratch. This provides a live look at my coding activity across multiple GitHub accounts. Github Repo here

• Single Endpoint: GET /api/commits/{username} returns comprehensive GitHub statistics

• Detailed Repository Breakdown: Shows owned repos, original repos (non-forks), and private repos

• GitHub GraphQL Integration: Fetches commits year-by-year and detailed repository statistics

• Smart Caching: 24-hour in-memory cache per user to avoid rate limits

• Vercel Ready: Optimized for serverless deployment

Left: (previous version with hard-coded numbers) and Right: (latest version with dynamic values pulled from API)

Left: before (all hard-coded static values/numbers) | Right: current (live dynamic values from gh API)

3. A Single Source of Truth

All the content on the site from my bio and skills to project details and social links everything is managed from a single portfolio-data.json file. This makes updating the site incredibly easy and means I don't have to touch the code to change the content. This was the very first thing initialized even before the project was started with migration. Claude Code was able to figure out the best possible way to pot it out based on the data structure. Any changes to the structure was easily picked up and made the respective corresponding changes to the frontend.

4. Performance and Optimization

The portfolio is built with performance in mind. I used Next.js for Server-Side Rendering (SSR), which ensures fast load times and a great user experience. I also implemented other basic optimizations like image lazy loading and code splitting (modular and type safety) to keep the site fast and responsive. This pagespeed.web.dev is a free tool by Google that analyzes the speed and performance of your web pages on both mobile and desktop devices, then provides optimization scores and actionable suggestions for improvement. I followed it to optimise and here are the before and after results:

The above is the comparison of before (71, 89) → after (96, 99) scores

5. The Tech Stack: A Modern, Robust Combination

This portfolio was built with a modern, robust tech stack that I’m passionate about. The stack was chosen at the outset and followed throughout.

• Framework: Next.js with TypeScript (Interface and type definitions gives better context for LLMs)

• UI: React, styled with Tailwind CSS and shadcn/ui (Easy customization and many pre-built, customizable components)

• Animations: GSAP and Framer Motion for a fluid, engaging feel (Tried to avoid heavy animations but later used it subtly)

• Backend & Data: Firebase for analytics, a self-hosted API for GitHub stats, and a central JSON file for content (Firebase is always my go-to NoSQL db choice)

6. How AI helped with speeding up things

• I majorly used Claude Code (Sonnet 4.5) and Roo Code (Sonnet 4)

• Gemini 2.5 pro for designing the architecture (Thinking)

• Claude for the complex code structure

• I was able to code way faster with the help of an agentic AI.

• The problem with LLM (best model) is that it always tries to “overfit” the idea focusing on quickly making something work (brute force) and does not bother about the long term solution. The outcome is often better if you provide the AI with highly specific constraints and requirements.

• AI could generate/iterate multiple approaches to solve each problem in different ways and as a developer myself had to evaluate/test each of them throughly and decide which one fits the best.

  (For example a feature that sounds simple but becomes tricky when optimizing latency and speed).

• Before implementing anything first thing was to research about the existing process or any readily available piece of code mut in my case I could not find any (used perplexity deep research)

• So instead of looking around I built it myself (3 external APIs that are currently used) and with each case had its own purpose and was fun building things from scratch.

• I did not just keep building it but I tried understand how things work at the fundamental level like how in-app browsers work within multiple platforms etc.

7. Conclusion: An slightly over engineered but summarises and presents my skills and my past work.

This portfolio is more than just a list of my projects; it's a project in itself. It's also a demo of engineering skills, my passion for building great software, and user-friendly experiences. Design was something I put a decent amount of efforts and did not leave till I was satisfied with the outcome. Optimisation is never ending process. I built it so that it can function and not break at any scale.

I encourage you to explore the interactive features and check out the source code to see how it all works.

🎯 Why I Built It

• Exam portal has stupid re-captcha: where you can get the results without actually solving the captcha.

• Zero Friction: No more manual copy-pasting or hunting through confusing menus.

• Instant Gratification: Real-time scraping means you get results the moment they’re live.

• Fun Factor: Because if you’re already sweating over exams, you might as well get a laugh too.

🚀 Core Features

1. Instant Results Lookup

   • Enter your USN (e.g., 1MS21CI049)

   • Click View Results

   • Boom—Name, Semester, SGPA, CGPA appear in a clean, distraction-free layout.

2. AI Roast Mode

   • Feeling cocky? Hit Generate Roast and let the bot fire off lines like,

     “Shravansaurus Rex, ruling Semester 8 on autopilot with that perfect 10.00—too bad your CGPA can’t keep up!”

   • It’s all in good fun (or at least that’s what I tell myself).

   • 

     

3. Minimal UI

   • Simple navigation: CSE (AI & ML), AI Chat Bot, CommuniLink, Other Links, Developer

   • Prominent “Exam Results” card—nothing else to distract you.

🔧 Under the Hood

• Flask Backend

  • A lightweight Flask app handles incoming USN requests.

  • It logs into the college portal, scrapes the SGPA/CGPA, and returns JSON.

• Firebase Logging

  • Every lookup - and every roast—gets written to Firestore.

  • I can monitor usage patterns, spot errors, and see which roasts are crowd favorites.

  • I am even monitoring number of logins and number of roast generated per session etc.

• Next.js Frontend on Vercel

  • The UI is built with Next.js for blazing-fast page loads and seamless client-side interactions.

  • Automatic Vercel deploys mean the site’s always up—even during peak result-release chaos.

🛠 Implementation Highlights

1. Headless Scraping

   • Used Python’s requests + BeautifulSoup to navigate form submissions and parse grade tables.

   • POST request with body where you pass the “osolCatchaTxtInst“ : “0” and USN and you will get the response.

2. Serverless Functions

   • Deployed the Flask scraper as a serverless function on Vercel (via a simple adapter), eliminating the need for dedicated servers.

3. Real-Time Analytics

   • Firebase triggers let me hook into log writes.

   • I can push daily Slack summaries of total lookups and roast-count for a quick laugh at the end of the day.

🙌 How to Try It

1. Head over to https://noterep.vercel.app/exam

2. Type your USN (make sure it’s uppercase!)

3. Click View Results

4. If you’re feeling bold, slam that Generate Roast button

5. Share your results (and your wounds) with friends

🔮 What’s Next

• Compliment Mode: For those who need a pick-me-up more than a roast.

• Prediction vs. Reality: Tie in the SGPA predictor from MiniSIS and compare predicted vs. actual grades.

• Leaderboard (Anonymized): See how your cohort is doing—top CGPAs, most frequent roasters, etc.

🎉 Wrapping Up

NoteRep Exam Results stands at the intersection of utility and hilarity. Whether you’re a perfectionist chasing that 10.00 or someone who needs a friendly jab to keep you humble, this little tool’s got your back. Give it a whirl, and let me know: did you slay the semester, or did the roast slay you?

TLDR: I randomly built a real-time arbitrage detector that called out guaranteed-profit moments with surprising accuracy. I paper-tested it, trusted it, switched to real money, and it didn’t miss even once. But hey, bet smart, this is still betting and you are just taking a calulated risk here.

DISCLAIMER - BETTING IS RISKY AND I AM NOT PROMOTING IT

This blog walks through the math behind betting odds, how bookmakers make money, and how I built this project to track odds and detect arbitrage opportunities in real time.

1. Understanding Betting Odds (With a Simple Example)

Betting odds tell you how much you can win relative to your stake.

For example:

• India: 1.14

• Australia: 5.60

If you bet ₹200:

• On India: 200 × 1.14 = ₹228 → ₹28 profit if they win.

• On Australia: 200 × 5.60 = ₹1120 → ₹920 profit if they win.

The formula is simple:

$$\text{Payout} = \text{Bet Amount} \times \text{Odds}$$

2. Can You Bet on Both Teams and Always Win? (Arbitrage Betting)

This is where arbitrage betting comes in. (may not occur at single instance)

It’s a strategy where you bet on all possible outcomes in such a way that you guarantee profit no matter what happens.

The key condition for a two-outcome event:

For two outcomes with odds ( a ) and ( b ), the key condition is:

$$\frac{1}{a} + \frac{1}{b} < 1$$

Where ( a ) and ( b ) are the odds for both teams.

Example:
India: 1.14
Australia: 15.60

Substituting:

$$\frac{1}{1.14} + \frac{1}{15.60} \approx 0.91 < 1$$

This means you can split your stake to guarantee profit.

• Bet ₹186.38 on India | if India wins then profit of Rs.26.09 | (Total returns: Rs.212.47)

• Bet ₹13.62 on Australia | if Australia wins then profit of Rs. 198.85 | (Total returns: Rs.212.47)

• No matter who wins, you end up with a small risk-free profit.

This doesn’t happen often but when it does, it’s a free money situation.

It will occur at two instances and we just need a live monitor to track and pool the money. Thats what i did and made profits during IPL and T20 matches. [when betting was legal]

I used paper money to test on the few match and each time there was a guaranteed profits before I used realy money for this project.

3. How Do Bookmakers Always Make Money?

Bookmakers aren’t in the business of losing. They bake in a margin (or "overround") by slightly skewing the odds.

The implied probability of each outcome is:

$$\text{Probability} = \frac{1}{\text{Odds}}$$

For our example:

• India: 1 / 1.14 ≈ 87.72%

• Australia: 1 / 5.60 ≈ 17.86%

Total: 87.72 + 17.86 ≈ 105.58%

That extra 5.58%? That’s the bookmaker’s profit margin.

4. The Project: Real-Time Odds Monitoring & Arbitrage Detection

Above is the screenshot of the app that i developed that monitoed and notified when the arbitrage detected

I wanted to monitor live odds, and visualize them in real time.

So I built PariScrapper, which has three main components:

a) Flask API (main.py)

• Uses Selenium to scrape live odds from Parimatch.

• Runs a background thread to continuously update odds for a given event.

• Developed a REST API at /odds?event=<id> to fetch the latest data.

b) Arbitrage Detection (arbitrage.py)

• Initialize a small amount on one side. (determined by AI deep research)

• Periodically queries the API. (websocket response from the betting platform to streamlit app)

• Checks if the arbitrage condition is met.

• Logs alerts when opportunities are found.

• Then we immidiately procede to make a bet based on this scenario.

c) Streamlit Dashboard (streamlit_ui.py)

• Displays real-time odds, implied probabilities, and bookmaker margins.

• Plots historical trends for better insights.

5. Key Features

• Live Odds Monitoring: Continuous updates from the betting platform.

• Arbitrage Detection: Detects when a guaranteed profit opportunity arises.

• Bookmaker Margin Estimation: Shows how much profit bookmakers make.

• Streamlit Dashboard: Interactive visualization for odds & probabilities.

• REST API: Transformed websocket response from the UI to endpoint to quick algo run.

6. What’s Next?

I’m planning to add:

• Advanced notifications (Telegram/email alerts when arbitrage appears).

• Better scaling (switching to async scraping for many events).

Disclaimer

This project is built to fun. Betting involves financial risk, and arbitrage opportunities are rare and time-sensitive. Use this tool responsibly.

Check it out on GitHub: PariScrapper

Another day and another automation script!!
This time its about automating the table reservation @ Naru Noodle - Bangalore : THE MOST FAMOUS RAMEN PLACE OF ALL TIME. Usually the slot window (every Monday @8pm) sellout within the 2-minute itself but my script is able to grab the seats with seconds ofter opening.

Ever felt that rush of anxiety when reservations for your favourite, perpetually booked-out restaurant go live? You're poised, fingers hovering, ready to click, only to find everything gone in a flash. It's a familiar frustration for many foodies, and it's exactly what inspired for me to just go ahead and automate it.

The Challenge: Snagging a Table at High-Demand Restaurants

Let's take a real-world example that many in my circle can relate to: Naru Noodle Bar. If you've ever tried to book a table there (their booking site is https://bookings.airmenus.in/eatnaru/order), you'll know it's an incredibly tough ticket! Reservations typically opens on every Monday at 8 PM and, due to its immense popularity and very limited seating (just 8 counter seats and 3 tables!), slots are often snapped up literally within minutes. Blink, and you've missed your chance for the week. This intense competition was a big inspiration for building an automation tool – to level the playing field and give users a fair shot at securing a coveted spot without the stress of a manual click-race.

Introducing "Clicks Before Chopsticks": My Automation Solution

To tackle this, I developed "Clicks Before Chopsticks," a Python-based automation script that uses Selenium WebDriver to navigate the booking process for you. It’s designed to handle the entire flow, from selecting a date and time to filling out your details, stopping just short of the final confirmation so you can review everything.

How It Works: Step-by-Step

The automation performs a sequence of actions to secure a booking:

1. Browser Initialization: It starts by launching a Chrome browser instance using Selenium WebDriver, configured to maximize the window and navigate to the target booking website.

2. Date Selection: The script patiently waits for the restaurant's booking calendar to load. Once available, it identifies and clicks on your specified target date, even handling scenarios where dates might not be immediately visible.

3. Venue/Seating Selection: It then locates the specific venue or seating section (e.g., "RAMEN BAR SEATING" or a "DINNER" option) and clicks the corresponding "BOOK" button, validating that the selection was successful.

4. Time Slot Selection: After venue selection, it waits for the time slots to appear, identifies all available options, and selects your chosen time (e.g., "07:00 PM").

5. Guest Count Configuration: The script locates the guest counter and adjusts the number of guests (incrementing or decrementing) to your desired party size.

6. Form Filling: Finally, it inputs the necessary customer details: Name, Email, and Mobile Number. It also automatically accepts the terms and conditions, preparing the booking for your final manual review and confirmation.

✨ Results ✨

Key Features

• Automated Calendar Navigation: Intelligently selects dates.

• Precise Time Slot Selection: Finds and clicks your preferred time.

• Dynamic Guest Count: Easily sets the number of diners.

• Automatic Form Filling: Saves you typing time for personal details.

• Configurable Environments: Comes with pre-set URLs for both test (for safe experimentation on a dummy site/restaurant) and production (for the real deal, like Naru Noodle Bar).

• Detailed Logging: Every step, success, or error is logged to a file and the console for transparency.

• Flexible CLI: Use command-line arguments to override default booking parameters like date, time, name, etc.

Under the Hood: Tech Stack & Setup

The project relies on a few key technologies:

• Python (3.8+): The scripting language at its core.

• Selenium WebDriver: For browser automation and web interaction.

• webdriver-manager: Automatically manages the ChromeDriver, so you don't have to worry about version mismatches.

Configuration is Key

All core settings are neatly tucked away in config/config.py. Here you can tweak:

• URLs for different booking sites: Python

• Default booking parameters like target date, time, and guest count: Python

    BOOKING_CONFIG = {
        "target_date": "19 May 2025", # Change as needed!
        "target_time": "07:00 PM",
        "guest_count": 4,
        # ... and venue labels for different environments
    }
  

• Browser settings and even CSS/XPath selectors if the target site's structure changes.

Running the Automation

You can run the script directly from your terminal:

• Basic Usage (uses default settings from config.py, typically targeting the test environment): Bash

• Advanced Usage (override defaults with command-line arguments): Bash

    ./run.py \
        --environment test \
        --date "20 May 2025" \
        --time "08:30 PM" \
        --guests 2 \
        --name "Jane Doe" \
        --email "jane@example.com" \
        --mobile "0987654321"
  

Supported Command-Line Arguments:

• --environment: test or production

• --date: "DD Month YYYY" (e.g., "19 May 2025")

• --time: "HH:MM AM/PM" (e.g., "07:00 PM")

• --guests: Number of guests

• --name: Your name

• --email: Your email

• --mobile: Your mobile number

A Glimpse of the Action (Log Output)

Here's what a successful run looks like in the logs (this example is from the test environment):

2025-05-13 01:51:46,105 - INFO - Browser setup successful
2025-05-13 01:51:48,456 - INFO - Navigated to https://bookings.airmenus.in/CafeAir/CafeAir
2025-05-13 01:51:48,457 - INFO - Waiting for booking calendar to appear...
2025-05-13 01:51:48,469 - INFO - Calendar found!
2025-0_5-13 01:51:48,469 - INFO - Looking for date: 13 May 2025
2025-05-13 01:51:48,739 - INFO - Date found: 13 May 2025
2025-05-13 01:51:48,748 - INFO - Searching for booking option: 'DINNER (Counter Seats)'
2025-05-13 01:51:48,771 - INFO - BOOK button clicked successfully
2025-05-13 01:51:50,771 - INFO - Attempting to select time slot: 08:30 PM
2025-05-13 01:51:52,828 - INFO - Found 2 time slot options
2025-05-13 01:51:52,862 - INFO - Found matching time slot: 08:30 PM
2025-05-13 01:51:52,870 - INFO - Setting guest count to 4
# ... (guest count updates) ...
2025-05-13 01:51:55,500 - INFO - Updated guest count: 4
2025-05-13 01:51:55,500 - INFO - Attempting to click continue button
2025-05-13 01:51:55,519 - INFO - Filling booking form
2025-05-13 01:51:55,850 - INFO - Form filled successfully
2025-05-13 01:51:55,850 - INFO - Booking process completed successfully!
2025-05-13 01:51:55,850 - INFO - Please review the details and confirm the booking manually.

Project Structure Overview

The codebase is organized for clarity and maintainability:

clicks-before-chopsticks/
├── config/
│   └── config.py           # All your configurations
├── src/
│   └── booking_automation/
│       ├── __init__.py
│       ├── main.py             # CLI and main execution flow
│       ├── browser.py          # Selenium browser management
│       └── booking_operations.py # Logic for booking steps
├── logs/                   # Log files are stored here
├── requirements.txt        # Project dependencies
├── run.py                  # Executable script
├── LICENSE
└── README.md

Error Handling & Logging

Comprehensive error handling is built-in to manage issues like elements not found, click failures, or network problems. Each error is logged with details to help with debugging. The script will inform you about the progress and any hitches along the way.

Open Source & Your Contributions

This project is licensed under the MIT License, so you're welcome to fork it, adapt it for other booking sites, or enhance its features. Contributions, suggestions, and feedback are highly encouraged!

Check out the full code and README on GitHub:

https://github.com/myselfshravan/**

https://drive.google.com/file/d/1yEdbqhmbqIkCMkb0k45RvwgXMchGvnqz/view

"Clicks Before Chopsticks" started as a personal project to solve a common annoyance, but I hope it can be useful to others too. Web automation is a powerful tool, and this is just one practical application.

Thanks for reading!

"OK." That's what I thought to myself. IPL is here, Chinnaswamy is buzzing, and yours truly needs to be there to cheer on RCB. But you know the drill, right? Tickets vanish faster than free biryani at a tech company lunch. And if you miss the initial wave, you're either staring at a "Sold Out" screen or facing prices that could fund a small vacation. Enough was enough!

I'm not one to just sit around and complain. So, I decided to put my coding chops to good use. My mission? Automate the heck out of this ticket-booking madness.

The Aha! Moment: Peeking Behind the Curtain

First things first, I headed over to the Royal Challengers website, the official ticket hub. I started clicking around, and then, like any curious techie, I hit that "Inspect" button. Bingo! I wanted to see how the website pulled up those match listings. Turns out, there's this neat little API – a GET request to rcbmpapi.ticketgenie.in/ticket/eventlist/o. This bad boy spits out all the upcoming matches with their ticket info. Simple enough, right?

Whipping Up a Python Potion

Now that I knew where the data lived, it was time to build my little helper. I fired up Python and Flask and cooked up a mini-API. This script would basically mimic the website's request, hitting that ticket API endpoint. The magic ingredient? It would then take that response – all the juicy event details – and stash it safely in a Firebase database. Think of it as my personal IPL event tracker.

So, every few minutes, my script would ping the ticket API, grab the latest events, and update my Firebase store. This way, I had a real-time pulse on what matches were coming up.

The Sweet Sound of Notifications

But just knowing the events were there wasn't enough. I needed to know immediately when new tickets dropped. That's where notifications came in. Whenever my script detected a new event in the API response (compared to what was already in my database), it would send out alerts – a little buzz on my phone, a notification on my laptop. You bet I subscribed to those notifications like my life depended on it!

And guess what? It worked like a charm! The moment tickets went live for the RCB vs. whoever match, BAM! Notification city. I jumped onto the website and snagged the cheapest tickets before the rest of the world even knew they were out. Victory!

Little Hiccups and Big Wins

Now, it wasn't all smooth sailing. I did wrestle a bit with CORS issues when setting up my Flask API. Those cross-origin shenanigans can be a pain. But hey, a little trial and error, some late-night Googling, and I eventually squashed those bugs. That's the fun part of building things, right? The iterative learning, the "aha!" moments when things finally click.

The Cherry on Top: Focusing on the Prize

I even added a little extra smartness to my system. I knew which matches I really wanted to see. So, I tweaked my script to specifically look for and notify me about those particular dates. Missed the initial notification? No worries! My system would keep buzzing me about those specific matches until I told it to chill. Talk about not missing out!

My Two Cents: Know Your Stuff, Then Let the Machines Help

Look, this might not sound like rocket science. But here's the thing: you gotta know the basics. You need to understand how websites and APIs work. Once you have that foundation, tools like LLMs can be super powerful for streamlining and enhancing what you're already doing. It's about leveraging your expertise and then using these cool technologies to make things more efficient.

So, there you have it. My little journey into automating IPL ticket booking. It saved me time, probably saved me some serious cash, and most importantly, got me into the stadium to scream "Ee Sala Cup Namde!"

Maybe this gives you some ideas for how you can automate the things you're passionate about. Go on, get coding!

The NoteRep Vision: More Than Just Notes

Before I explain the working of Chatbot, let me set the context. NoteRep isn't just an average study materials platform. Sure, it's got notes and resources, but I've also add bunch of features (20+) like a calendar for tracking events and exams, community links to all the clubs in our college, a real-time class timetable, shared links for spreading knowledge, and even a countdown feature for upcoming exam and assignment submissions (received mixed feedback for this feature 😅) but you get the point.

I wanted to take things to the next level. Introducing the AI chatbot – the cherry on top of this feature-packed website. A bot that can asked all the question related to the website and also assist students with the relevant notes and links inside the website.

The Need for Speed (and Smarts)

When I decided to add an AI chatbot to NoteRep, I had few requirements:

1. It had to be fast and reliable.

2. It needed to be smart enough to help the students within the set boundaries.

3. And yes, need to track the chat activity and be able to monetize it. (will explain this later).

Enter Groq: The Speed Demon

After exploring various endpoints that enable seamless integration with popular open-source Large Language Models (LLMs) from providers like Anyscale, Together AI, and Clarifai, as well as private LLM companies such as Anthropic (Claude) and Open AI (GPT), then I stumbled upon Groq an AI infrastructure company that promised to deliver mind-blowing inference speeds. And, did they deliver! We're talking about 1000 tokens per second. To put that in perspective, it's like you get the response in a blink of an eye. You might wonder how is it fast so let me explain, so Grok rolled out this thing called an LPU - short for Language Processing Unit. It's a new chip that's all about making AI smarter and faster, especially for chatting or writing like a human. While your computer's brain (CPU) and muscle (GPU) are great at lots of tasks, the LPU is like a specialist who's really good at one job: making AI run smoothly and quickly.

The result? The chatbot can spit out responses in about 0.15 seconds (~50 tok per sec). That's faster than you think or in like a blink of an eye.

Behind the Scenes: Smarts with Firebase Firestore

But speed isn’t the only trick up the chatbot’s sleeve. The chatbot doesn’t just "talk" – it logs every single interaction using a backend I’ve connected to Firebase Firestore.

Here’s how it works:

When a user opens the chat for the first time, a JavaScript function generates a pseudo-random, 18-character string, which serves as a unique user ID. From that point on, every time the user interacts with the AI, their chat history is stored locally in their browser and synced with Firebase Firestore in real time. This allows the chatbot to remember past conversations, helping users pick up right where they left off.

Admin Powers: Monitoring and Control

But there’s more. I’ve built an dedicated admin panel that lets me monitor user activity in real time. This isn’t just for oversight; it’s designed to ensure that the chatbot can evolve and improve based on actual usage. For example, I can inject specific system prompts or user prompts into a conversation, guiding the chatbot to respond in a particular way. This level of control ensures that responses remain within the platform’s boundaries while still being highly relevant and helpful to students.

This monitoring feature is especially useful for refining how the chatbot handles ambiguous questions or integrates with other NoteRep features like the calendar, class timetables, or resource sharing. Essentially, I can nudge the chatbot to be more aligned with student needs based on live interactions.

Seamless Ad Integration: Smarter, Subtle Monetization

One of the latest features I’m particularly proud of is seamless ad integration within the chat conversations themselves. Rather than interrupting users with annoying pop-ups or banners, the chatbot carefully slides context-appropriate ads into the conversation. For example, if a user mentions they're bored, the chatbot might recommend nearby entertainment venues, such as bowling or VR gaming spots, driving traffic to those businesses while keeping the user engaged.

Take this real example:

On Sep 17 at 10:01 AM, a user sent a query saying, "I'm bored." The chatbot responded by recommending "The Grid" – a nearby entertainment hub with activities like bowling, laser tag, and VR games, located near Ramaiah College.

By suggesting relevant local services in a seamless, conversational way, I am trying to create opportunities for businesses to promote their offerings without disrupting the user experience. Similarly, when users mention study-related stress, the chatbot might recommend nearby cafes or food outlets for a refreshing break encouraging real-world engagement while subtly integrating monetization.

Dynamic System Prompts

I can manipulate the system prompt (how the bot behaviour) from the backend. Every chat request uses the configured system prompts and Ad injected inside the context that user is not aware of.

Final Thoughts: A Powerful Combo of Speed, Smarts, and Strategy

With NoteRep’s AI chatbot, I wanted to push the boundaries of what a learning platform could offer. By combining blazing-fast Groq AI inference, smart interaction logging via Firebase Firestore, and admin-level control over the chatbot’s behaviour, I’ve created a tool that’s not just responsive but also highly adaptive to the needs of students. The seamless ad integration ensures that the platform remains free while delivering value to users.

And this is just the beginning – I’m continuously refining and expanding its capabilities. Like I will further want to integrate RAG on all the study materials.

Final Thoughts: Just the Beginning

In a nutshell, the AI chatbot on NoteRep is fast, smart, and designed to make your life easier without getting in the way. Whether it's answering your questions, keeping you on top of your schedule, or subtly pointing you towards something fun, it’s here to help. And with more features on the way, like RAG integration, I’m just getting started. Stay tuned things are about to get even more interesting!

In today's fast-paced world, where technology has become an integral part of our lives, it is no surprise that education is also evolving. The traditional approach to learning has been transformed by the advent of artificial intelligence (AI) and natural language processing (NLP) technologies. One such innovative creation is Syllabus GPT, a powerful tool designed to provide students with instant and relevant answers to their subject and unit inquiries. In this blog, I will explain the capabilities of Syllabus GPT and how it can revolutionize the way we learn.

The Essence of Syllabus GPT:

Syllabus GPT is an instant response generation AI tool built to cater to the specific needs of students. Its primary function is to provide comprehensive responses based on the input of subjects and units. By leveraging the power of AI and NLP, Syllabus GPT can understand and analyze the user's query, enabling it to generate precise and relevant answers.

The Role of Anthropics Claude API:

To achieve this impressive level of AI assistance, Syllabus GPT utilizes the Anthropics Claude API. Claude is a next-generation AI assistant developed by Anthropic, a pioneer in the field of training helpful AI systems. More about it is here.

How Syllabus GPT Works:

Using Syllabus GPT is incredibly straightforward. Users input their desired subject and unit, enabling the tool to generate context-specific responses. Whether it's a complex question or a simple inquiry, Syllabus GPT leverages the power of AI to provide accurate and detailed information, helping students enhance their understanding of the chosen topic.

Enhancing Learning Experiences:

The potential applications of Syllabus GPT are vast. Students can benefit from this tool by obtaining instant clarification on challenging topics, accessing additional resources for further study, or even receiving guidance on specific assignments or projects. Syllabus GPT acts as a personalized assistant, offering tailored responses to individual needs, thus transforming the learning process into a dynamic and interactive experience.

The Future of Education:

Syllabus GPT is a testament to the transformative power of AI in education. As technology continues to advance, tools like Syllabus GPT will play an increasingly important role in facilitating personalized and efficient learning experiences. By harnessing the capabilities of AI, students can now explore subjects with greater depth and confidence, empowering them to excel academically.

Conclusion:

Syllabus GPT represents a remarkable breakthrough in educational technology. By leveraging AI and NLP technologies, this tool revolutionizes the way students engage with their syllabus. Its ability to provide instant and relevant responses based on subject and unit inquiries is a game-changer. As we embrace the potential of AI in education, Syllabus GPT stands as a shining example of how technology can enhance learning experiences and empower students to unlock their full potential.

Note: This blog is written by a human, not by Claude AI. Does this blog sound AI-generated? Yeah, it is written by Claude AI – just kidding!

Link to the app 🚀

Hi everyone! Welcome to my blog, where I share my journey as a developer and a student. Today I want to tell you about a project that I'm proud of and excited about. It's called NoteRep, and it's a website that I created to solve a problem that I faced in my college. It was a pain to find and download all the class materials, like notes and PPTs, from the class WhatsApp groups. It was hard to navigate.

I noticed this problem. And like most developers, I thought of solving it by myself instead of complaining. I was frustrated with my college's learning management system, and so were my friends. So, I thought I could design a website that would bring together all class notes, PPTs, PYQs, and everything you need in one place to make it easy for everyone to stay organized and access it from anywhere.

So, I thought I could design a website that would bring together all class notes, PPTs, PYQs, and everything you need in one place to make it easy for everyone to stay organized and access it from anywhere. I wanted to create a platform that would help students learn better and faster.

That's how NoteRep was born. Here, anyone can simply upload or download class materials without any effort. NoteRep is more than just a website. It's a community of learners who want to help each other; It's a place where you can find all the resources you need to ace your exams and assignments 😎.

Finding Motivation

I've been working on NoteRep ever since I joined this college, and I'm happy to say that it's doing great and that many people are already using it daily. Some of the juniors have even approached me around campus to share stories of how much easier NoteRep made their studying and exam prep. Hearing their stories of newfound confidence and reduced stress in classes that have historically been challenging has made all the effort that went into creating NoteRep worth it. Their grateful feedback tells me that this resource will benefit students for years to come, and there is still so much potential for improvement to help even more students succeed. The fact that just a single tool can make such an impact gives me hope for how technology may transform education. That just motivated me to add more and more useful features to it.

Features:

1. Notes, Study Materials, and Previous Year Papers.

   

2. AI Chat Bot: Ask anything related to NoteRep and get the fastest response

3. 

   Shared Links: Where anyone can share useful links here that will help others

4. 

   CommuniLink: Access all College Communities and clubs in one place

5. 

   Class Timetable: Highlights the current day and current class that is ongoing

6. 

   Calendar: Countdown for Upcoming Tests, Quizzes and Exams

As I continue refining and enhancing NoteRep, the growth in user engagement is becoming more evident. Let’s take a look at some key metrics:

• Visitors and Page Views: According to Vercel’s Web Analytics, in the last 30 days, the site has had 2,319 visitors (up 137%) and 5,839 page views (up 110%). This shows significant growth, especially with a spike of 267 visitors on July 23 alone. Clearly, students are finding NoteRep useful, and the AI chatbot and other features are driving interaction.

• Search Console Insights: Since launching in March 2023, NoteRep has reached an impressive 61.2K total views. Over the past 28 days, we’ve had 6,131 views (up 65%) with an average engagement time of 1 minute 8 seconds, showing that users are not only visiting but actively engaging with the content.

• Short-Term Growth: In the most recent 7-day period, NoteRep saw 122 visitors (up 61%) and 353 page views (up 48%). This steady increase in visits is a great indicator that the platform’s momentum is building, and users are returning to utilize features like the AI chatbot, study materials, and event calendars.

Conclusion:

I hope you'll try NoteRep and see how it can improve your learning experience. I'm always looking for ways to make it better and more beneficial for everyone, so please don't hesitate to contact me if you have any suggestions or questions. Thank you for reading this blog post. Happy studying!

How it Works:

1. Enter your USN and DOB.

2. Your CIE and Attendance will be displayed.

3. Switch to the Grades-Score tab, Here you can see the minimum marks to score in SEE to get respective grades.

4. Note down the expected grades for each subject based on the table and proceed to the next tab, which is Credit-CGPA.

5. Now Select the Grades and click on Calculate to get your final SGPA.

Priority Score

The priority score is calculated based on a weighted average of multiple factors, including past CIE scores, the credit value of that subject, and the student's score relative to the class average. We have a formula that enables us to determine the degree of difficulty for each subject based on these factors. This allows us to calculate the priority score and sort subjects accordingly.

Riddles

I love solving riddles and puzzles. So I thought why not add this to our tool to make it more engaging and interactive. We hope that it will not only provide some entertainment but also help users feel more connected to the site and its purpose.

Unlockable information

Users who solve the riddle will be rewarded with access to information. They can use the answer to the riddle as a key to unlock.

Visitor Counter

This shows us how many students are using our tool.

Performance Analysis

This will help us know which department is using our tool and how many requests are quired.

Attention to details

I believe even the smallest details can make a big difference in creating an enjoyable user experience. That's why we put a lot of effort into giving the minutest detailing to this tool. You can see a different welcome message based on the search. It will show your Name with a weaving hand if you are normally using this tool by entering the date of birth.

But if you are checking other person's details then it will show this message.

Funny messages

We also added a humorous touch to Calculla by including funny messages throughout the site. For example, You can find one if you try to crack the creator's DOB. Our USNs are blacklisted and you can't use our own tool on us 🫢. 1MS21CI049 and 1MS21IS017 these are our USNs.

Logs and Stats

This allows us to keep track of how many requests are being sent to the website and how users are interacting with the site. By monitoring these metrics, we can handle the tokens and helps us keep the visitor counter updated.

Admin Access

From the portal, we can create new tokens or delete existing ones to control the number of requests being made to the website. It also allows us to regulate the number of tokens and see the logs and stats.

Conclusion

Overall this was so much fun building this and I am so overwhelmed with the response we received from everyone.

Credits: Amith

At the beginning of our college days, we were made to sit in an auditorium surrounded by unfamiliar faces, listening to boring speeches and all. That night, I had a dream that somehow I got access to the college database and discovered everyone's names, profile pictures, dates of birth, phone numbers, etc. It was a funny thought, and I couldn't help but wonder if it was possible in real life.

Well, well fast-forward to today, I actually got all the student's data from the college portal. Before I explain how I got it, let me tell you First, I don't have any intention of misusing any data. It is their personal information and I completely respect it.

So our college has a student/parent portal that any student can access using their Unique Student Number (USN) and date of birth as a password, which allows us to track test grades and attendance records to exam results, the portal has it all.

Now if a person knows anyone's USN and DOB he can quickly check all his details using this portal. All you need is date of birth to access the information, so you have to crack the DOB by the simple Brute force method.

Brute force attacks are a method of trying multiple combinations of login credentials until the correct one is found. In this case, I wrote a python program that will try all the combinations of dates till it unlocks the portal. Here is a demo of continuous automated inputs on the website.

How it works:

1. The USN is stored, and The first step is to enter it. This will serve as the starting point of our brute force attack.

2. Year of birth calculation: From the year in USN, the program calculates the most probable birth year by subtracting 18 from it. If USN is 1MS21CS001 it takes 21 and 21 - 18 is 3, so the birth year is likely to be 2003 if not it checks subsequent to it like 2004 then 2002 then 2001.

3. Brute-forcing the DOB: Next, the program begins to input, trying every possible combination of month and date within the year of birth until the correct DOB is found.

4. Success message: Once the correct DOB is found, the program displays the Name and DOB of the student. Then finally save it to the CSV file.

5. As mentioned earlier, if you have the DOB you get access to all the information.

Now I have 4000+ students data like DOB, email, number, face picture and I was just wondering if I can make a model that can identify/recognise the person in realtime. Just imagine that you will click someones pic and then it will match with my data and find the name and other details. That would be crazy.

It's important to remember that using this method to access confidential information is illegal and unethical. For the same reason, if College finds out doing this, they can take strict action against the student like suspending from the college. The purpose of this blog is just to demonstrate the power of programming using Python. On the other hand, I am trying to prove how easy it is to do this. I am also writing a letter to the college to fix this as soon as possible.

And there you have it! With just one program, you now have the power to get all the information about your classmates from the college portal. But, please remember to use this knowledge responsibly and for educational purposes only.

Disclaimer: Before you start envisioning yourself as a detective hot on the trail of your friends or crush, I remind you that this tool is only accessible on demand. And just in case you were wondering, stalking is never cool, no matter how much that little voice in your head says otherwise. 😁

A very special shoutout goes to Amith, who played a crucial role in the development of this tool. Amith's expertise and knowledge made the program run smoother and more efficiently. Thanks to Amith (The Optimiser OP), I was able to create this tool that is both effective and fast. (parallel multithreaded attack)

Thank you for reading this blog.

Here is the website Link: https://dob-finder-sis.streamlit.app [deprecate]

Contributors: Amith M & Shravan