Systems & the playbook.
Deep-dives on the ML systems I've built, an 8-part series on how an AI trading desk works inside, and a free 16-part interview playbook for ML, AI and software engineers.
Inside āagman
The architecture of an AI trading desk, one layer per post: a typed strategy language, agents that can't reach the broker, a deterministic backtester, the data platform, and the gates in front of every order. Real trade-offs, written for engineers.
- 8parts
- 5worker agents
- 4risk gates
- 90%+LLM calls avoided
- 10×screener throughput
The interview playbook
Written to help you through your own search: how to get interviews, how to prepare, what each round is like, what rejections teach, and how to choose between offers. Process and preparation, not interview questions. Each part is 9 to 12 minutes and stands on its own. Free, and it stays free.
- 35companies
- 50+interview rounds
- 8offers
- 4rejections
- 500+Claude prep sessions
Systems deep-dives
Entity resolution at 900M scale
How I built canonicalization pipelines across a 900M-node person graph: precision-first blocking, tiered scoring, and why 74% discard rates are a feature.
N=1 personalization: Replacing 25 cohorts with user-level ranking
From cohort-based defaults to true user-level personalization at Cars24 UAE: +150% Click Recall@50, +16% buyer conversion, and solving cold-start for 35% of the user base.
Building a neuro-symbolic trading platform under SEBI compliance
How I architected a 5-layer system where LLMs plan and deterministic policy engines execute, with zero hallucination-induced regulatory breach, by design.
Inside āagman: the system map
The whole of āagman, an AI trading desk for Indian markets, on one page: the constraints that shaped it, the services, the data stores, and the path of one request from a sentence to a broker order.
A strategy language the model can’t escape
The JSON DSL at the center of āagman: why the LLM’s only output is a typed strategy document, what the grammar covers, how the compiler turns it into an execution plan, and where the design stops protecting you.
The agent desk: routing, worker agents and memory
How āagman turns a sentence into a typed strategy: an intent classifier, one orchestrator with a supervisor tool, five stateless worker agents, a staged workflow with a clarifying loop, two layers of memory, and the distilled router and semantic cache that avoid most expensive calls.
A backtester you can put a golden test on
How āagman’s backtesting engine works: a pinned VectorBT core in a sandbox, next-bar fills, intrabar stop rules, golden tests on frozen data, and an honest list of what the first version leaves out.
Market data and a 500-symbol screener
The data platform under āagman: Yahoo Finance and Alpha Vantage ingestion with Prefect, ClickHouse and Postgres storage, a Parquet export for the sandboxed backtester, and a batched, vectorized screener that scans 500+ instruments.
Cheap first: the NSE announcements pipeline
The announcements pipeline behind āagman’s research agent: ingest, extract text, extract fields with rules first and a capped LLM fallback, and classify into 13 categories, with idempotent stages, a dead-letter queue and a windowed backfill.
Four gates before the broker
The pre-trade controls for āagman: a kill switch, a daily loss cap, circuit breakers and a margin check, decided by a policy engine from inputs the model can’t touch, plus the readiness gate, the plan-bound approval and the failure matrix.
Execution from the user’s own machine
The last mile of āagman: a Manifest V3 Chrome extension that drives the user’s own logged-in broker session, how signed execution requests reach it, the order types and brokers it supports, and how fills are reconciled.
35 companies, 50+ interviews, 8 offers
A data scientist’s seven-month job search across 35 companies, ending in eight offers and a Google SWE III role in AI/ML. The funnel, the timeline and the system that held it together.
From “can’t start” to a plan: baselining for a Google loop
How I turned a self-assessment with zeros in dynamic programming and statistics into a ranked prep plan for a Google ML loop, and what happened when the dates kept moving.
The 10 habits that cost me interview signal
Across 50+ interview rounds I tracked ten verbal and structural habits that hid what I knew. Four died, two improved, and four were still there in August. The debrief loop, the drills, and what worked.
Running 17 interview processes in one month
In April 2026 I had live interview processes with 17 companies, 24 rounds and three take-homes in flight in the same week. The operating model that kept it from collapsing, and what I would cap next time.
Running my interview prep on Claude
Over five months I ran more than 500 conversations with Claude to prepare for a Google ML loop and the rest of a 35-company search. The documents, rules and session protocols that made it work, and where the AI coach was wrong.
Rebuilding a resume that scored 3.5 out of 10
A hostile review scored my ML engineer resume 3.5 out of 10 on how much a hiring manager would discount. Five versions later it was under 2. The teardown loop, the claims that survive a committee, and defending every line in interviews.
Eighteen days, 102 questions: a DSA sprint
Twelve open data structure and algorithm patterns, 18 days to Google’s onsite coding rounds, and a bank of 102 questions mapped to dates. The sprint design, the daily miss logs, and why process gaps mattered more than algorithms.
The rejections, and the round I thought I had failed
Four companies rejected me in a 35-company search, at four different stages. One round I was sure I had failed became an offer. What each rejection taught, and why post-round self-assessment is close to useless.
Preparing for the Google ML domain round
How I prepared for Google’s ML and AI domain round at L4: a topic universe built from the recruiter’s scope, from-scratch implementations, debugging scenarios, resume defense and a week of clean-room mocks. It came back Strong Hire.
Getting interviews: recruiters, outreach and applications
How 35 companies ended up in conversation with me in 2026: applications with a human note, recruiter replies, cold outreach to hiring-side people, warm reconnects, and a portfolio site built in two hours. What worked in each channel.
Preparing for Googleyness and Leadership
How I prepared for Google’s Googleyness and Leadership round: eight stories in a conclusion-first structure, the correction that reversed my “we versus I” rule, metric drills, rapid-fire hypotheticals and adversarial mocks. It came back Strong Hire.
Four take-home assignments, one workflow
Four take-homes in about five weeks: a classification system, a multi-agent research system, an API service and a schema mapper, all built with a two-track Claude and Cursor workflow. Two led to offers. The designs, the evaluation, and defending AI-assisted code.
Learning agentic AI for an interview in a week
After clearing Google’s main loop, I got a team-specific round on agentic AI with about a week to prepare, despite never having used the popular agent frameworks in production. How I mapped my own systems onto their vocabulary, rebuilt sessions that did not stick, and what the mocks exposed.
The Google loop, round by round
Every round of my Google Software Engineer III loop in AI/ML, from the first recruiter call to the signed offer: format, result, what decided each one, and the coding round I passed with a wrong algorithm. No interview questions.
Choosing between eight offers
Eight offers arrived between April and August 2026, at different times, in different shapes, with different risks. How I read each one, the contract clauses I nearly missed, the rule I used to decide, and how I declined six of them.
Negotiating with Google without a competing offer
By the time Google’s offer call came, every other offer I had was declined or lapsed. How I prepared in an hour, which parts of a Google L4 package actually move, how I framed an ask with no competing offer, and where it landed.
No posts match that.