Hey! 👋 I'm Yash's AI assistant. I can talk about his projects & skills, give career advice for data and AI engineering, running coaching, or tips on balancing a demanding job with your goals. What's on your mind?
Loading saved chats…
👤 About Yash🧠 AI Engineering🛠️ Data Engineering🏃 Running Coaching⚖️ Work-Life Balance
Tap to start talking
You
AI
🔊 Hands-free · uses your selected model · AI-generated voice
Loading analytics…
🏃 Running Agent · MCP tools
Loading agent activity...
🤖 Agent Recommendations
STRATEGY
Yash Hooda
AI Engineer & Software/Data Engineer | Aviation Enthusiast | Production LLM & Data Systems | Runner
⚠️ Due to high operating costs, HoodaAgents is currently available by request only.
--
Miles / Week
0
Years Climate Data
⚡ About Me
I'm a 24-year-old AI & Software/Data Engineer who builds production systems — the kind with rate limiters, kill switches, retries and real traffic, not the kind that lives in a notebook. I hold a BS in Computer Science from UT Dallas and certifications in IBM AI Engineering, IBM Data Science, and the Databricks Certified Data Engineer Associate.
My work spans both halves of the stack: designing and optimizing end-to-end data pipelines across Microsoft Fabric, Databricks, PySpark and SQL, and shipping full-stack AI systems — multi-model LLM gateways, hybrid RAG with reranking, agentic loops, and offline eval harnesses. This site is one of them. It runs a hybrid retrieval pipeline, a gateway across five model providers, and a seven-layer security stack that has taken sustained real attack traffic and held.
Most of my side projects live where messy public data meets automation. ClimatePulse is a 57-year NOAA pipeline across 13 global stations with a Bronze→Silver→Gold architecture, refreshed daily by GitHub Actions — incremental per-station caching cut each run from 741 API calls to 13. The live flight tracker on this page is real-time geospatial ingestion. mcp-garmin came from reverse-engineering Garmin's undocumented workout schema into a typed spec an LLM can drive.
Outside the terminal I'm a hobby jogger runner chasing a lifelong goal of sub-3:00 marathon, and I fly small planes on weekends purely as a hobby. Both hobbies keep turning into engineering problems: the METAR streaming pipeline (Kafka → Spark Structured Streaming → Delta Lake), the live flight tracker, and the Infinite Flight tooling on this page are real-time data work that started with aviation data, and the Strava and pace tools came from running. Weather systems, astronomy, and sport pull at me for the same reason. I value time with family and friends, and I'm happiest building whatever comes next. My flight log →
Hiring for a Data or AI Engineer? Paste the role below. A deterministic keyword scan runs instantly in your browser; the AI report scores the fit, names the proof behind each strength, and lists the honest gaps — it is told which skills I don't have so it can't bluff. Nothing you paste is stored beyond a 24-hour cache key.
Keyword scan is free & instant · AI report requires a free login
🎯 Your fit report will appear here. Score · strengths with proof · honest gaps · a tailored 4-sentence pitch · questions to ask me.
Model: Claude Haiku 4.5 · deterministic keyword coverage blended at 25% · results cached 24h · rate-limited & kill-switch protected like every HoodaAgents endpoint.
Full-stack AI application — Node.js, Vercel, Upstash. Not a portfolio site;
an AI application that happens to have my resume in it. Hybrid RAG chatbot
(dense + sparse retrieval, RRF fusion, CRAG grading, cross-encoder reranking)
over vector search in Upstash, FAISS, and Chroma. Multi-model gateway routes
across Claude, GPT, Grok, Gemini, and Llama. Agentic ReAct loops, QLoRA
fine-tuning tracked in MLflow, and an eval harness on the retrieval layer.
Backed by a 7-layer security gateway that held through a sustained real-world
attack campaign.
A pre-ingestion scanner for documents headed to an LLM. It catches malicious PDFs (auto-run JavaScript,
Launch actions, embedded executables, #hex-obfuscated names, decompression bombs), disguised
and polyglot files, and indirect prompt injection a human can't see: white text, invisible
render-mode-3 layers, microscopic fonts, metadata, Unicode tag "ASCII smuggling", zero-width splits,
homoglyphs and base64. It also flags leaked credentials and PII before they reach a model or a vector index.
Zero dependencies and no model in the decision: a hand-written PDF parser and content-stream interpreter
(ToUnicode CMaps, graphics-state tracking), every finding mapped to OWASP LLM Top 10, MITRE ATT&CK and ATLAS,
SARIF output for code scanning, a STRIDE threat model, and an eval in CI. On a 39-document labeled corpus it
catches 26/26 attacks vs 2/26 for the site's previous upload filter, with one documented
false positive.
Continuous ingestion of surface weather observations from ~1,100 North
American airport stations — Kafka into a Spark Structured Streaming job
writing a Bronze→Silver→Gold Delta medallion, with a low-visibility and
high-gust alert stream. Watermarking, event-time deduplication, per-sink
checkpointing and offset-throttled backpressure. Measured over 25.6 hours:
240,997 raw messages ingested, 10,018 observations retained after dedupe,
zero duplicate keys.
The interesting part is what broke. The upstream API silently truncates
every query at 400 results — the only clue was that the number was too
round. Partitioning silver by station_id produced 2,364
Parquet files for 38 MB of data; repartitioning by date cut it to 6.
Two Spark jobs sharing a checkpoint directory corrupted the offset log,
and recovery meant rebuilding downstream layers from the replayable
bronze source. A 181-second broker outage was survived with zero
duplicate keys.
Forced broker restart. Silver catches up in +1 / +5 / +16 / +27 steps after Redpanda comes back — duplicate keys stayed at 0 throughout.
Two hypotheses were measured and discarded. High p95 ingest lag looked
like watermark drops, but direct measurement showed 2 records lost out of
4,179 — 0.0%; ingest lag and event-time lateness are different quantities,
and the config was left alone. And the coverage wasn't US-only: grouping
station IDs by ICAO prefix showed 996 US, 90 Canadian, 18 Mexican. The
bounding boxes were drawn against API result limits, not borders.
🏃 Running Coach SFT — What a Fine-Tune Didn't Learn
AI / LLM EngineeringLoRA / PEFTTRL SFTTrainerQwen2.5-3B-InstructSynthetic Data GenerationEval Harness DesignInstruction TuningHugging Face HubPandas & NumPyOLS with Fixed EffectsHeterogeneous Text ParsingHF Jobs (A10G)Daniels/Gilbert VDOTStrava Bulk Export
A 1,527-example instruction-tuning corpus for distance-running coaching,
where every pace, split and race equivalent is computed from a
Daniels/Gilbert VDOT implementation rather than written into a template.
That design decision is the whole project: a corpus with hand-typed paces
teaches a model to interpolate them, and an interpolated training pace is
wrong by enough to put someone at threshold when the plan said easy.
Because the numbers are generated, the corpus scores 0.0%
off-zone against its own arithmetic — a verified floor to measure
drift against. Qwen2.5-3B-Instruct scored 47.3% before training.
The fine-tune learned the format almost perfectly and the
arithmetic barely at all. Pace density went from 349 emitted paces
to 1,242 against a ground truth of 1,066 — on one task it matched the
reference exactly, 60 for 60. But off-zone rate only moved to 39.3%, and
three of five tasks got worse. Two in five prescribed paces are
still more than 8 s/mi from any real training zone for that athlete.
The model became more confident without becoming much more correct. Final
training loss was 0.07 at 96.7% token accuracy, so "undertrained" doesn't
explain it — validation loss looked excellent the entire way, and would
have read as success without an eval measuring the arithmetic directly.
Six years of my own Strava history (1,648 runs, 2017–2023) replaced the
generator's invented constants with measured ones. The heat rule didn't
survive: regressing pace on dew point while controlling for heart rate,
distance and year-level fitness (n=462) gives 0.235 s/mi per
°F — about 5 s/mi across a full seasonal swing, roughly a
quarter of the 15–20 s/mi coaching rule of thumb. The year fixed
effects are load-bearing; without them the fitness trend across six
seasons swamps the weather signal and the coefficient comes out near zero
with the wrong sign.
One row of the results table is my metric being wrong, not the model.
Race-prediction outputs are race times, not per-mile paces; the
tuned model correctly stopped emitting paces there (63 → 3) and
the eval scored that as a regression. It's documented rather than quietly
dropped.
The negative result is the useful one. It's the empirical case for exposing
the calculation as a tool instead of compressing it into weights — and the
same VDOT module that generated the corpus serves as that tool.
AI / LLM EngineeringAgentic / ReAct LoopsOllamaPython (Pandas · NumPy · PySpark)CI Test Suites (pytest)Content GuardrailsGitHub Actions
A fully offline ReAct agent running on a local small language model — no API key,
no network calls, no framework. The reasoning loop is hand-written rather than
pulled from LangChain, so every step of thought → action → observation is
inspectable. Six sandboxed tools, a stdlib-only SSE server, and a test suite
that runs green without a model loaded, which means CI validates the agent's
control flow independently of model output.
AI / LLM EngineeringQLoRA Fine-TuningEval Harnesses & Golden SetsMLflowHuggingFace PEFTPython (Pandas · NumPy · PySpark)Delta LakeData Quality & Reconciliation
End-to-end fine-tuning pipeline for a PySpark coding assistant, built on a free
Colab T4. Public code corpora turned out to be unusable — filtering 122k rows
yielded 58 examples, mostly Spark 1.x RDD-era API — so the training set is
synthetic, distilled from 15 hand-written production seeds and expanded to 191
validated examples. Every example passes AST parse, required-symbol, and
deprecated-API checks before entering the corpus.
Trained in 11 minutes at 6.3 GB peak VRAM: validation loss 0.757, perplexity
1.69, mean token accuracy 0.833. On held-out prompts it scored 1 of 3 — it learned
idiomatic form but not operator semantics, confusing left_anti with
left_semi. Published with that result documented rather than omitted,
because the binding constraint is corpus size, not architecture. Adapter and
dataset are both on HuggingFace Hub.
A real-time flight tracker for the Infinite Flight simulator. Live map of every aircraft on a server (coloured by flight phase), origin→destination cards with live ETAs, arrival weather + 5-day forecast, switchable satellite & day/night layers, ATC frequencies, and pilot logbooks. A FastAPI backend proxies and caches the Live API so the keys never touch the browser.
Python (Pandas · NumPy · PySpark)Delta LakeETL/ELTMedallion ArchitectureData ModelingREST API IngestionIncremental Processing & Control TablesData Quality & ReconciliationScikit-LearnNOAA APIGitHub Actions
End-to-end Bronze → Silver → Gold pipeline analyzing 57 years (1970–2026)
of NOAA daily station data across 24 global cities — Houston (home station), New York City, Austin, Newark, Dallas,
Denver, London, Helsinki, Amsterdam, Brussels, Paris, Rome, Chicago, Los Angeles, San Francisco, Seattle, Boston, Miami, Atlanta, Washington DC, Orlando, Anchorage, Toronto, and Delhi. Features automated daily refresh via GitHub Actions,
Celsius→Fahrenheit conversion for international stations, an interactive
dashboard with city toggle comparisons, and a Houston-vs-New York City layer — the two largest U.S. cities — contrasting winter freezes and humidity (dew point, afternoon RH).
Denver included for Boulderthon marathon race planning context.
⌚🍎 Apple Workouts MCP Server — Training Plans Straight to Apple Watch
PythonMCP ServersPydanticWorkoutKitSwift / App IntentsCloudKitiCalendar FeedOAuth 2.1 + PKCESign in with AppleMulti-User AccountsDockerRailwaypytestGitHub Actions
Model Context Protocol server that lets Claude, ChatGPT or any MCP client
build structured runs, strength sessions and multi-week training plans and
put them on an Apple Watch — the Apple counterpart to mcp-garmin, with the
same workout spec so prompts and plans port unchanged.
Apple has no cloud API that writes to a Watch; structured workouts only get
there through WorkoutKit, which runs on the iPhone. So the work is split:
the server compiles each workout into JSON that maps 1:1 onto WorkoutKit
(warmup, interval blocks, cooldown, heart-rate-zone and pace-range alerts),
and the HoodaRun iPhone app reads that feed, schedules it to the Watch, and
reports back what actually landed — so the server can tell a published
workout from one that's really on the wrist.
Plan generators cover the mile, 5K, 10K, half and marathon for any goal
time, sized from current mileage, with a base tier for runners under 18
miles a week. Completed workouts flow back from Health, so a weekly review
lines planned sessions up against what was run and the plan can ease back
after time off, scale volume or shift paces in place. Workouts can be moved,
swapped or shifted without duplicating calendar events. It also serves an
Apple Calendar feed, acts as its own OAuth 2.1 authorization server for
Claude and ChatGPT connectors, and gives each invited runner a separate
account, feed and calendar link. A saved runner profile — run days,
hard days, long-run day, usual workout times — shapes every generated week.
My own Apple Watch workout app: a Garmin Connect–style calendar and builder
for easy runs, tempos, intervals, mile repeats, fartleks and long runs. It
schedules each one into the Watch's Workout app through WorkoutKit, with
step-by-step pace and heart-rate alerts on the wrist.
Workouts reach it three ways. Build one in the app. Build one in the web
builder on this site — sign in with your Apple ID and it's saved to your own
private iCloud, where the app picks it up. Or have Claude or ChatGPT write a
whole training plan through mcp-apple-workouts, which uses the exact same
workout format.
The app is the half of that system Apple requires to run on the phone: it
reads the server's feed, schedules to the Watch, mirrors the plan into Apple
Calendar, and reports back which workouts actually landed. With permission it
also shares completed workouts from Apple Health, which is what lets a plan
be reviewed against what was really run and adjusted. Finished runs reach
Strava through Strava's own Apple Health sync.
Model Context Protocol server that reads Garmin activities and writes
structured workouts, strength sessions and whole training blocks straight
to the Garmin calendar. Reverse-engineered Garmin's workout-service schema
into a typed, LLM-friendly spec — garth SSO auth, a bearer-secured HTTP
transport, an offline test suite, and CI, packaged for one-command
Docker/Railway deploy.
Plans aren't templates. It reads the last eight weeks of logged running,
derives weekly mileage, longest run, frequency and best effort, and
compares that to what the goal demands. If the goal doesn't fit the
runway it says so and builds toward the one that does — a 5:12 miler
asking for sub-4:30 is told that's a two-or-three-season project, not a
16-week one. Marathon blocks ramp 8%/week on a 3-up-1-down cycle from
wherever the athlete actually is; high-school track blocks target the
sub-2:00 800, sub-4:30 1600, sub-10:00 3200 and sub-15:00 5K with weekly
mileage ceilings by training age. Every plan carries two strength sessions
a week on quality days, per-session fuelling and recovery notes in the
workout description, and a weekly nutrition brief.
118 sessions, written over the API. Two weeks of a generated sub-3 block on the Garmin Connect calendar — easy runs, quality, both strength days, Sunday long run.Strength A on the watch. Garmin renders the targeted muscle groups from the exercise codes the server wrote — the strength path needed garminconnect 0.3.7+.
The interesting part is what broke. Between garminconnect 0.3.6 and 0.3.15,
get_scheduled_workouts() went month-scoped and dict-returning;
two shipped tools still called it the old way and raised TypeError
against the version the project's own dependency floor allowed. The offline
suite never caught it because every test mocked the calendar away — it
surfaced on the first live run. Reading the generated output caught two more:
the gap analysis told a sub-3:30 athlete the block had to reach 20 miles twice
before the taper while the generator capped long runs at 30% of weekly volume,
which tops out at 16 miles on a 53 mi/wk peak — the plan contradicted its own
report. And down weeks were counted per phase while the mileage ramp cut on the
absolute week, so cutback weeks ran full quality and climbing weeks got the
reduced load. All three are now covered by tests that assert the plan against
what the assessment claims, rather than just that it builds.
🗺️ HoodaRoutes — Route Generation Scored Against Your Goal Race
Full-StackNode.js ServerlessREST API IngestionLive APIClaude APIStructured LLM Output + ValidationDeterministic FallbacksOAuth 2.0Signed Session Cookies (HS256)Rate LimitingWebhook SubscriptionsBinary Protocol EncodingCI Test Suites (node:test)VercelRailwayUpstash RedisGitHub ActionsOpenRouteServiceOpenStreetMapStrava APICopernicus DEMGarmin FIT ProtocolConnect IQ / Monkey CLeaflet
Drop a pin anywhere on earth and get a real running loop — snapped to
OpenStreetMap via round-trip routing, surface classified from OSM tags as
road/trail/track/mixed, sized to your own Strava training history, and
scored for how specific it is to the race you're actually training for.
Three deploy targets in one repo: a Vercel web app with serverless
functions and Strava OAuth, a Railway push service, and a Connect IQ watch
app.
The scoring was wrong in a way that only showed up in the city I
live in. The fit score originally hard-coded one rolling mountain
marathon, so it rewarded climbing — exactly backwards for a flat goal race.
Rebuilding it around a per-athlete race profile exposed the real problem
underneath: an 8.5 mi loop through downtown Houston measured
1,157 ft of gain, 136 ft/mi, against a true
figure under ~150 ft. One sample read below sea level.
OpenRouteService returns SRTM elevation and sums every micro-delta, so
noise becomes phantom climb. Re-sampling against Copernicus DEM cut it to
427 ft — better, and still wrong, because Copernicus is a
surface model: it reports building rooftops. Across that route,
8% of samples read above 90 ft against a true ground level of
49 ft, and a city block is a sustained plateau rather than a
spike, so a narrow median filter can't reject it. Widening the filter to a
window measured in metres of route rather than sample count
brought the same loop to 14 ft/mi. The trade-off is stated in the
code: real terrain features under ~250 m get flattened too, and a test
pins that a 2 km, 100 m climb still survives intact.
The terrain term was also mine to fix. An absolute-difference Gaussian
scored zero for anything past ~40 ft/mi, so a flat-race route with
ordinary DEM error was indistinguishable from a mountain route. Scoring on
the log ratio of measured to target ft/mi makes it scale-free —
3× the target costs the same whether the target is 13 or 130 — and a noise
floor keeps a flat race from dividing by near-zero.
Sending a route to a watch has no free multi-user path, so I wrote
one. Garmin's Courses API does exactly what's needed over OAuth,
but only after Developer Program approval, and the unofficial route means
collecting other people's Garmin passwords and MFA codes — a non-starter.
Instead: a FIT course encoder written from the protocol spec
(file_id → course → lap → events → records, semicircle coordinates, both
CRCs), served to the Connect IQ app, which downloads it with
HTTP_RESPONSE_CONTENT_TYPE_FIT. The system files it straight
into the device's course list and the app hands off to native turn-by-turn
navigation. No account linkage, no partner approval. Validated by an
independent parser and by Garmin Connect's own importer accepting the file.
The AI layer is bounded on purpose. Natural language ("hilly 12-mile trail
loop") becomes route parameters and a segment-by-segment coached plan, but
every field is clamped and whitelisted before it reaches the route engine,
and every LLM path falls back to a deterministic heuristic — no key, rate
limit, timeout or malformed JSON can break route generation. The same
principle covers infrastructure: without Redis configured the app degrades
to an in-process store rather than failing, and a broken rate limiter fails
open. One honest caveat left in place — the residual 26 ft/mi downtown
may be partly real, since freeway overpasses are exactly the >250 m
structure the filter can't reject.
A running coach that answers “am I overtraining?” from my real Garmin and Strava
history — training load, injury risk, race predictions, and an adaptive 5K plan — with no API
keys and no cloud inference. Everything runs on a local model; the health data never leaves
the machine.
The decision that makes it trustworthy: the LLM is the interface, not the reasoning
engine. VDOT, Banister TRIMP, exponentially-weighted acute:chronic workload ratio,
and periodisation are deterministic, unit-tested functions — the model only picks tools, reads
structured output, and explains it. Every recommendation traces to a named threshold instead
of a black box, the same history always yields the same findings, and a 7B model on a laptop
is enough. The analysis command runs with no model at all.
Two MCP servers — Garmin (7 tools, including structured-workout writes) and Strava (6 read
and analysis tools) — so any MCP host can drive it, not just this agent. 289 tests,
mypy --strict, and CI across Linux/macOS/Windows including a smoke job that proves
the offline claim by running the whole pipeline with no model, no credentials, and no network.
Responsible AI is an engineering requirement—not a blanket ban and not a box-checking exercise.
Featured solution · Human-accountable AI
Put AI to work. Keep humans in control.
The Hooda AI Governance Studio classifies a use case across six real-world risk signals,
assigns a proportional oversight tier, and generates the controls a team needs before deployment.
It turns governance principles into an actionable engineering brief.
01 · CLASSIFYAssess autonomy, impact, data, scale, reviewability, and reversibility.
02 · CONTROLApply human review, least privilege, monitoring, appeals, and kill switches.
03 · DOCUMENTExport a reusable governance brief with owners, purpose, and approval fields.
04 · ACCOUNTKeep a named human responsible for every consequential outcome.
🛡️ DocShield — Security Gate for AI Document Pipelines
Any app that feeds documents to an LLM (resume screeners, invoice and policy extractors, RAG indexes)
can be attacked through the files themselves: malicious PDFs, disguised executables, and
indirect prompt injection hidden in white text, invisible text layers, metadata or Unicode tricks,
which the model reads and a human reviewer never sees. DocShield scans a file before ingestion and returns
ALLOW / REVIEW / BLOCK, with evidence and OWASP LLM Top 10, MITRE ATT&CK and ATLAS mappings for every finding.
It's a deterministic, zero-dependency engine with no model in the decision, so it can't be prompt-injected itself.
Scan a document
📄
Drop a PDF or text file or click to choose
PDF, TXT, MD, CSV, HTML, images · up to 2 MB
Nothing is stored. Files are scanned in memory and discarded.
Or try a built-in sample (all payloads are inert):
Report
🛡️ Upload a file or pick a sample to see the verdict, evidence and framework mappings.
Benchmark: same corpus, two gates
Loading eval results…
The "previous upload filter" is this site's own fileGuard, which regex-scans the first 10 KB of raw bytes.
It can't see inside compressed PDF streams, file magic or Unicode tricks, and the gap is structural, not a tuning problem.
I wrote the corpus alongside the detector, so treat DocShield's recall as a regression suite, not a real-world rate.
The one false alarm is kept on purpose: a blog post about prompt injection gets REVIEW, because phrase
matching can't tell use from mention. CI fails the build if recall drops below 95% or false alarms rise above 15%.
How it works
Trust bytes, not labels. Magic-byte sniffing against the declared type and extension; double extensions, RTL-override filenames, executables and polyglots (a ZIP after %%EOF, a PDF header that isn't at byte 0).
Take the PDF apart. Inflates streams under hard budgets (bombs are reported, not expanded), unpacks object streams, decodes #hex-obfuscated names, and flags JavaScript, auto-run, Launch, embedded executables, XFA and incremental updates.
Read it like the model does. A content-stream interpreter decodes CID fonts through ToUnicode CMaps and tracks the graphics state, so it can split visible text from text in render mode 3, white fill, sub-1pt size, off-page placement or metadata.
Find the instructions. Ten phrase families (override, role spoofing, AI-addressed text, exfiltration via markdown images, secrecy, decision tampering, tool coercion), checked after undoing Unicode tags, zero-width splits, homoglyphs and base64. Hidden plus instruction is critical.
Stop the leaks. Cloud and API keys, private keys, connection strings, JWTs, SSNs and Luhn-valid cards, with evidence redacted. Exports a JSON report or SARIF for GitHub code scanning.
Flying is a hobby. Here's my logbook, my live simulator stats, and the data engineering it gives me an excuse to build.
Aviation is a hobby, not a career track — my career is AI and data engineering.
I fly part-time for fun and I'm working toward a Private Pilot certificate (personal, non-commercial
flying) at my own pace. What the hobby gives my engineering is a steady supply of real-world data:
the METAR streaming pipeline (Kafka → Spark Structured Streaming → Delta Lake),
the live ADS-B flight tracker, and the Infinite Flight panel below
(a serverless API proxy with edge caching and last-known-good fallback) all started here.
Logbook — real aircraft
8.0
Total Hours
8.0
Dual Received
7
Flights
C172
Type Flown
KSGR
Home Airport
Weekend flying, logged for fun. Home airport: KSGR (Sugar Land Regional).
Infinite Flight — simulator
--
Grade
--
Flight Time
--
Flights
--
Landings
--
XP
--
ATC Ops
Live from the Infinite Flight Live API v2.
Logbook entries
Transcribed from my LogTen logbook. All time is dual instruction in single-engine land aircraft; times in hours.
Aircraft flown
From the lessons
Current Flight
Checking…
Route
—
Callsign
—
Aircraft
—
Elapsed
—
Altitude
—
Ground speed
—
Remaining
—
ETA—
✈️ Live Flight Tracker
Real-time flights across the world from ADS-B transponder data (OpenSky Network, with adsb.lol as a fallback). Includes airline, origin, and destination where available. Refreshes every 5–15 minutes from a shared cache.
LIVE FLIGHTS
--
Flights Shown
--
Total Flights
--
Last Updated
Loading live flights...
🌪️ METAR Stream — Live US Airspace
A snapshot from my real-time streaming pipeline: Kafka → Spark Structured
Streaming → Delta Lake, ingesting surface observations from every reporting
US airport weather station. Flight categories below are the FAA standard —
the same four a pilot checks before departing.
The same observations, turned into a decision. A deterministic rules engine checks
every METAR and TAF group against the pilot's minimums and flags exactly what fails.
Airports without a TAF borrow the nearest one within 40 nm. A model then writes the
brief in pilot shorthand but cannot change the verdict. The multi-step tool-calling
version lives in the METAR Stream repo.
Try:
✈️ Enter a route and hit Brief me. Not an official briefing — practice and portfolio use only.
Streaming pipeline metrics
These come from the Kafka → Spark Structured Streaming → Delta Lake
pipeline, which runs on demand rather than continuously. The live
conditions above refresh hourly from a separate batch job.
dbt models over Silver
The streaming job writes Silver; dbt owns everything after it — the
transformations, the tests, and the lineage. It runs alongside the Spark
Gold job rather than replacing it, which means the two can be diffed
against each other. That diff is the last number below.
Where the numbers above come from.publish.sh writes one JSON after every build — model row counts, 32/33 tests, parity split into count mismatches vs. rows missing in dbt, and the ceiling parser's agreement with NOAA.dbt run + test. staging → intermediate → gold, with custom assertions. The single amber WARN 1 is assert_ceiling_parse_not_conflicting — the two NOAA disagreements described above, kept visible rather than silenced.Idempotent start.sh. Brings up Redpanda, waits for healthy, and leaves an already-running Spark job and producer alone — the process guard enforces exactly one of each.Docker under the hood. Redpanda v24.2.7 and its console run as Compose services — health-checked on bring-up, ports 9092 / 8080 / 8081 / 9644 mapped, and 44 hours of uptime on this run before the Spark job and producer attach in tmux.
⚡ ERCOT Grid — Texas Power, Live
Texas grid demand, generation mix and prices from ERCOT, joined to METAR weather from six Texas airports. Houston is the home view: Houston's load-zone price (LZ_HOUSTON) and KIAH weather, contrasted with Austin. Same Kafka → Spark → Delta pipeline as METAR Stream.
Waiting for the first hourly refresh
The ERCOT pipeline publishes a snapshot every hour. Nothing on this panel is estimated, so it stays empty until real data arrives.
—Demand now (MW)
—Capacity margin
—Wind + solar share
—Net load (MW)
—Houston load zone ($/MWh)
—Houston now (KIAH)
🌤️ Your Current Weather
Live weather for wherever you're accessing this site from.
Requesting your location...
🌡️ ClimatePulse — Live Dashboard
57 years (1970–2026) of NOAA daily station data · 24 cities · Houston home station · Bronze → Silver → Gold pipeline
Reading this honestly: these coefficients show association, not attribution.
Year-to-year Atlantic activity is strongly steered by ENSO and the Atlantic Multidecadal Oscillation.
A positive correlation is consistent with the physics — warmer water carries more energy — but isolating the
human-caused share requires counterfactual potential-intensity modeling, not a scatter plot.
🌊 Rising Seas — Coastal Risk & the Ice That Holds the Water
Satellite sea-level rise, U.S. coastal risk hot-spots, and how far seas would climb if the ice sheets melted
ExtremeVery HighHighModerate–High· circle size = local rise rate
Loading signal...
Sea-level equivalent if fully melted (meters)
Loading signal...
Loading signal...
Loading signal...
Reading this honestly: the ice-melt bars show each reservoir's ultimate ceiling — how far seas would climb over centuries to millennia if it fully melted — not a 2100 forecast. This century's projected rise is roughly 0.3–1 m (up to ~2 m for the U.S. coast on high-emission, rapid-ice-loss pathways). Local rates differ from the global average mainly because of land subsidence, which is why the Gulf Coast tops the map.
🖥️ Data Centers — The AI Boom & Its Footprint
How fast data-center power demand is growing, where the U.S. clusters are, and what it costs in water and energy
Circle size = market power capacity (MW). Tap a hub for details.
Loading signal...
Freshwater to produce one unit (litres, log scale)
Loading signal...
Energy per query (Wh, log scale) — ranges where contested
Loading signal...
Reading this honestly: per-query water and energy numbers are genuinely contested and span orders of magnitude, so they're shown as ranges. At the individual level an AI prompt is tiny next to everyday items — a single burger is ~1,650 L of water. What actually strains systems is the aggregate and its geographic concentration: a handful of clusters (Northern Virginia alone ≈ a quarter of the state's electricity) pull enormous, localized loads on grids and watersheds — and efficiency gains keep being outrun by sheer growth.
🗳️ US Elections 2016–2026 — Nationwide, Statewide & County Drill-Down
Six elections, 3,100+ counties, one pipeline. Raw precinct and county returns (MIT Election Lab, OpenElections, state canvasses)
land in a bronze layer, get normalized to county FIPS with fusion-party lines credited to the right candidate and
duplicate vote-mode rows removed (silver), then roll up into compact gold JSON this page draws.
A CI gate checks the gold totals against 24 certified statewide and national results before anything ships.
Pick an election, click a state to drill into its counties, click a county for its full history.
The dashboard loads when you scroll here.
Margin, 2016–2026
● president ○ midterm (the race differs by state). Margin = (D − R) ÷ all votes.
Results
Click a column to sort, a row to drill in. This table carries every value on the map.
Potential factors
Spotlight: Texas, 2016 → 2026
Texas statewide margin, every election
Method, caveats & sources
Midterm race rule: per state, the US Senate race (regular before special), else governor, else every US House race summed. A race counts only if a Democrat and a Republican each won 15%+ statewide, so VT/ME 2018 (independent senators) and CA 2018 (D vs D) fall through to governor.
Cleaning: undervotes/overvotes and "ballots cast" rows are dropped; a candidate's TOTAL row is dropped when the same precinct also reports early/election-day/mail; fusion lines (NY Conservative, Working Families…) go to the candidate's major party; Indiana 2018 comes from OpenElections because the MIT file is missing it; a few mislabelled parties are corrected by hand and listed in build.py.
Geography: Alaska reports by state-house district and Connecticut 2024 by planning region, so their county maps show the statewide result. Indiana 2022 county data is partial; its statewide total comes from the state canvass.
2026 is unofficial. Texas statewide results are loaded (Senate as of Nov 8, governor as of Nov 6); county files are added as states certify.
Factors use ACS 2012–2016 county estimates and show association, not cause.
Local AI on Apple Silicon, cloud-scale habits: benchmarks measured on my own MacBook Pro, an Apple Health running pipeline, a Siri career agent, HoodaRun and its Apple Workouts MCP server, and two more SwiftUI apps
One fixed prompt suite run against three local inference engines on the same machine.
Records generation speed, prompt-processing speed, time to first token, memory and
optional power draw, then prices the same tokens on a cloud API. Each repetition
defeats the prompt cache so repeat runs are not flattered.
Data EngineeringMedallion ArchitectureStreaming XMLData Quality & DedupPython
Streams a multi-gigabyte Apple Health export through Bronze → Silver → Gold at a flat
memory footprint. Removes runs recorded twice by the watch and a synced app, rejects
GPS glitches, and publishes weekly mileage, training load, pace by temperature and
marathon readiness. Raw health data stays on the Mac; heart-rate metrics are opt-in.
“Hey Siri, log this job lead.” A Shortcut on iPhone and Mac sends dictated notes and
recruiter emails to a private serverless endpoint that structures them into an
application tracker and reads the result back. Email text is treated as untrusted
input: the model can only return whitelisted fields.
A Garmin Connect–style workout calendar and builder for Apple Watch. Structured
runs — tempos, intervals, mile repeats, long runs — are scheduled into the Workout
app with pace and heart-rate alerts, mirrored into Apple Calendar, and can come from
the app, the web builder on this site, or a plan Claude wrote.
Running on my Ultra 4 · App Store release planned⌚ Web Builder
⌚🍎 Apple Workouts MCP Server
AgentsMCP ServersPythonWorkoutKit JSONOAuth 2.1 · Sign in with AppleRailway
The server side of HoodaRun and the Apple counterpart to mcp-garmin. Claude or
ChatGPT build workouts and mile-to-marathon plans; the server compiles them to
WorkoutKit-shaped JSON, serves an Apple Calendar feed, and keeps each invited
runner's plan, profile and completed workouts in a separate account.
A companion app on top of the ClimatePulse gold layer: 57 years of station trends
from this site's API next to current conditions, air quality and active weather
alerts for where you are, with summaries written on-device.
A private flight-training logbook for the hobby side: hours, landings and maneuvers
stored on the phone, the current METAR attached when a flight is logged, and a lesson
debrief drafted on-device from my own notes. Nothing leaves the device.
No benchmark results published yet
Numbers appear here once the suite has been run on the MacBook itself. Nothing on this tab is estimated.
python3 apple/benchlab/bench.py run --backend ollama --models qwen3:8b
—Fastest generation (tok/s)
—Fastest prompt processing (tok/s)
—Lowest time to first token (ms)
—Model runs
—Engines compared
Model
Engine
Quant
Gen tok/s
Prompt tok/s
TTFT ms
Memory GB
Watts
Cloud $ / 1k runs
No Apple Health export processed yet
This dashboard fills in after the pipeline runs against a real export from the Health app.
python3 apple/runos/runos.py ~/Downloads/export.zip
—Latest week (mi)
—4-week average (mi)
—Acute : chronic load
—Lifetime miles
—Runs after dedup
—Days to race
Goal race
—
🏃 Running Journey
Running has been my passion and a source of discipline and motivation. I've competed in various distances and continue to push my limits. Notable achievements include:
Marathon PR
TBD
In Training
Half Marathon PR
1:24:31
2025 Aramco Houston HM
8K PR
29:48
2025 Sugar Land Turkey Trot
5-Mile PR
30:22
2025 Sugar Land Turkey Trot
5K PR
18:15
2025 Women's Quarter Marathon
Currently Training: 2027 Aramco Houston Half Marathon Last Race: 2026 NYCRuns Brooklyn Experience Half Marathon — 1:27:41
Marathon Personal Record: TBD (Will make my marathon debut in late 2027 or early 2028)
Follow my training journey on my public Strava account: here.
📊 Strava Intelligence
Analyzing your training data...
⌚ Garmin Training Plans — Generated From Real Training Data
mcp-garmin
reads my logged Garmin history, works out the gap between current fitness and a
goal race, and writes a whole training block — runs, strength, fuelling notes —
straight to the Garmin calendar. The block below is real output: a sub-3:00
Chevron Houston Marathon build, generated from 34 mi/wk of logged running and a
1:25 half marathon.
118sessions scheduled
17weeks to race day
33strength sessions
52.6peak mi / week
2×strength every week
Verdict: on_track — the goal fits the runway, so the plan builds straight
toward it. When it doesn't, the plan says so: a 5:12 miler asking for sub-4:30
gets told that's normally a two-or-three-season project, and the block is built
toward the PR this season can actually deliver instead.
The generated block
Wk
Phase
Miles
Long
Strength
3-up-1-down cycles ramping 8%/week from current mileage, down weeks in amber,
long runs reaching 20 twice before a three-week taper. Strength lands on quality
days so easy days stay easy and nothing sits the day before a long run.
On the calendar, on the watch
Written over the API. Two weeks of the block on the Garmin Connect calendar — easy runs, quality, both strength days, Sunday long run.Strength A on the watch. Garmin renders the targeted muscle groups from the exercise codes the server wrote.
What every plan carries
Two strength sessions a week on quality days — posterior chain and anti-extension
core on day A, hip control and anti-rotation on day B, dumbbells and a band.
Down and race weeks swap the heavy day for a mobility reset so the habit survives
when the load shouldn't. Each workout description carries its own fuelling and
recovery line, so the guidance is on the watch rather than in a document nobody
opens, and each week returns a nutrition, hydration and recovery brief alongside
the schedule. The same engine builds high-school track blocks for the sub-2:00
800, sub-4:30 1600, sub-10:00 3200 and sub-15:00 5K, with weekly mileage ceilings
set by training age and a full rest day every week.
⌚ HoodaRun — Build a Workout, Run It on Apple Watch
HoodaRun is my Apple Watch Ultra workout app: a Garmin Connect–style builder for
easy runs, tempos, intervals, mile repeats, fartleks and long runs. Build one here,
sign in with your Apple ID, and it's saved to your own iCloud. HoodaRun on your
iPhone picks it up and schedules it in the Workout app with step-by-step pace and
heart-rate alerts. Claude-built plans from
mcp-apple-workouts
use the exact same workout format.
yashhooda.ai builder→your private iCloud (CloudKit)→HoodaRun on iPhone→Workout app on Apple Watch
Build
Duration: 15:00, 90s, 1mi,
400m, 1km or open (lap button).
Pace is min/mi, e.g. 6:35-6:55.
Rep sets end with the Action button; holds and rest are timed.
Preview
Checking iCloud…
Upcoming in your iCloud
Sign in to see your scheduled workouts.
"On Watch" means HoodaRun has scheduled it. Open HoodaRun on
your iPhone to sync. Workouts are stored only in your own iCloud account.
Tool · Running × Weather
Heat-Adjusted Pace
Air temperature and dew point decide how much of your sweat can actually evaporate. Add them together and you get the number that predicts how much slower the same effort will feel today.
CONDITIONS — · SUM — · ZONE —
100120140160180
Or enter conditions by hand.
Conditions
Units
Your run
Pace unit
Goal pace in cool conditions
:/mi
Effort
—
Pace cost
—
Slowdown
—
Finish impact
—
Zone
If the forecast shifts
Scenario
Temp / dew
Pace
Finish
Model: the temperature + dew point sum, interpolated across the standard heat-pace bands, then scaled by effort — easy running responds least because effort, not pace, is the target — and by how long you’ll be out there, since heat compounds with time on your feet. Heat tolerance is individual and improves with acclimation; treat this as a starting point, not a prescription. Live conditions from NOAA/Aviation Weather METAR.
Tool · Running × Weather
Wind & Cold Adjustment
Cold air barely slows you down — 32° to 50°F is where you race your best. Wind is the part that costs real time, and it costs it as the square of the wind speed. This works out both: what the wind takes, and what the chill means for how you dress.
CONDITIONS — · CHILL — · ZONE —
5035205−10
Or enter conditions by hand.
Conditions
Units
Wind speed unit
Your run
Pace unit
Goal pace in calm air
:/mi
Wind on your route
Where it hits you on the outbound leg.
Route shape
—
Wind cost
—
Cold cost
—
Finish impact
—
Zone
What to wear
If the wind is different than forecast
Scenario
Temp / chill
Pace
Finish
Model: drag rises with the square of the air speed flowing over you, so the extra cost per mile scales with 2·v·w + w², where v is your running speed and w the wind. Calibrated so a 10 mph headwind costs about 11 s/mi at 7:00 pace, matching Pugh's 1971 wind-tunnel work and Davies 1980. Two consequences fall straight out of the physics rather than being bolted on: a tailwind returns only a fraction of what the headwind took, so an out-and-back always loses net time; and a crosswind costs the same as that net out-and-back. Cold itself is scored separately and stays near zero above freezing, because 32–50°F is the performance optimum — below that the cost comes from footing, clothing weight and cold airways, not from thermoregulation. Wind chill uses the NWS formula, valid at or below 50°F with wind above 3 mph. Live conditions from NOAA/Aviation Weather METAR.
Tool · Pace
Pace Calculator
Give it any two of pace, time, and distance and it solves the third — then shows what that pace is worth at every race distance.
Solve for
Time
Finish time
hms
Distance
Pace
Pace
:
Calculated from your time and distance.
—
per mile
—
per km
—
mph
—
km/h
—
m/min
—
m/s
—
Race times at this pace
Straight arithmetic — no fatigue curve. Holding 5K pace for a marathon is a math result, not a prediction. For that, use the heat predictor below or a Riegel-style equivalence.
Tool · Fitness
Race Predictor & Training Paces
Enter one recent race. It works out your VDOT, predicts every other distance, and turns that fitness into the five training paces: easy, marathon, threshold, interval and repetition.
A recent race
Finish time
hms
Use a race run all-out in cool weather on a flat course.
Show paces
Pace unit
—
Goal race prediction
—
Goal race pace
—
Riegel check
—
Training paces
Zone
Pace
Reps
What it's for
Equivalent race times
Race
VDOT
Pace
Riegel
Built on Daniels & Gilbert's oxygen-power equations (1979): the oxygen cost of running a given speed, and the share of VO₂max a runner can hold for a given duration. VDOT is the VO₂max those two imply for your race. Training paces are speeds at a fixed share of VDOT: easy 62–70%, threshold 88%, interval 98%, repetition 105%; marathon pace is the marathon prediction itself. Riegel's formula (time × distance ratio1.06) is shown beside it as a second opinion. Predictions assume you have trained for the distance: long races, the marathon most of all, come out optimistic without the mileage behind them. Heat, hills and wind are not included; for heat, send the prediction to the tool below.
Tool · Running × Weather
Same Race, Different Air
Enter a result and the conditions you ran it in. This strips the heat penalty out to find the cool-air performance underneath, then re-applies it for any other temperature and dew point.
What you ran
Finish time
hms
Units
Use the conditions at the start, not the average.
Conditions to predict
—
Time swing
—
Pace swing
—
Heat you ran through
—
Zone
Predicted finish
Temp \ dew
40°
50°
60°
65°
70°
75°
Swipe the table sideways →
Same temperature + dew point model as the pace tool, with one addition: a duration factor, because heat compounds with time on your feet. A 5K loses less to a hot day than a marathon does. Individual heat tolerance and acclimation move these numbers, so treat a prediction as a range, not a promise.
Yash's most recent completed training week — refreshed every Monday, and fed to the site's AI agent
updated —
—Miles last week
—Runs
—Longest run (mi)
—Commits
—Active repos
—Days to Aramco Houston Half Marathon
Loading…
Loading…
Running from Strava, commits from GitHub, distilled by a weekly GitHub Actions pipeline. The same summary is injected into this site's AI chat so it always knows what Yash is currently working on.
🏆 Certifications
Professional certifications that reflect my skills in data engineering, AI, and data science.
Databricks Certified Data Engineer Associate
Validates my knowledge of data engineering concepts, ETL pipelines, Delta Lake, and building scalable data solutions on Databricks.
I built a custom AI assistant called TARS using OpenAI's GPT-4. TARS is designed to solve real-world problems through natural conversations. Try it out below!
First solo hike in Arapaho National Forest. Soundtrack: Hans Zimmer – First Step & Day One (Interstellar).
4.07 miDistance
335 ftElevation Gain
1h 18mTime
499Calories
107 bpmAvg HR
Route Map & Stats
3D View
Activity Summary
📷 Photo Journal
This hike wasn't just exercise — it was a milestone. Being out there alone reminded me of the power of independence. The silence of the forest, the vastness of the mountains, and the rhythm of my footsteps gave me peace and clarity. Taking this hike solo was my own "first step." Just like in Interstellar, sometimes the journey begins when you step into the unknown — and the views at the end are worth it.
❄️ Snow Album
A collection of my favorite snow moments — because nothing beats a good snowfall.
❄️ Snow Highlight Reel
Rare snowfall in the Lone Star State — Texas doesn't get snow often, but when it does, it's something special.
🌨️
Historic February 2026 Nor'easter — New York City
One of the most powerful nor'easters on record, dumping 25–30 inches of snow across New York City in February 2026. These photos were taken during the storm and its aftermath.
🔍 Network Analyzer
Professional network reconnaissance tools — DNS lookup, WHOIS, ping, traceroute, and HTTP header inspection.
// Select a tool and enter a target to begin...
🏆 Live Sports Scores
LIVE DATA
LEAGUES
🏙️ MY TEAMS — HOUSTON
Loading NBA scores...
Loading MLB scores...
Loading MLS scores...
Loading NFL scores...
Loading World Cup scores...
Loading Rockets scores...
Loading Astros scores...
Loading Texans scores...
📋 Build Log
Automated log of everything shipped on yashhooda.ai — features, security hardening, pipeline work, and agent activity. Updated continuously.
--
Shipped Items
--
Tech Tags
--
Last Updated
Loading build log...
📬 Contact Info
I'd love to connect! Feel free to reach out to me: