⚡ 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 →

🎯 Fit Check — Paste a Job Description

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.

🚀 Projects

Here are some of my notable projects:

🧠 HoodaAgents — Agentic AI Platform

AI / LLM Engineering Ollama Claude & OpenAI APIs LangChain / LangGraph Hybrid RAG · RRF · Reranking Vector Search (Upstash · FAISS · Chroma) Multi-model gateway routes Eval Harnesses & Golden Sets CRAG Agentic / ReAct Loops Rate Limiting Jailbreak Detection VPN/Datacenter Fingerprinting Content Guardrails Kill Switches & Graceful Degradation Multi-Provider Failover CI Test Suites (pytest) 7 layer security gateway GitHub Actions Redis Vercel Node.js Serverless

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.

💬 Try AI Chat 🦙 Ollama Model 📂 GitHub 🎬 HoodaAgents Demo 🔒 Security Update Demo

🛡️ DocShield — Security Gate for AI Document Pipelines

Application Security Indirect Prompt Injection Defense PDF Malware Triage Threat Modeling (STRIDE) OWASP LLM Top 10 MITRE ATT&CK · ATLAS Secrets & PII Detection SARIF 2.1.0 ReDoS & Decompression-Bomb Hardening AI Security Node.js Serverless GitHub Actions

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.

🛡️ Try it live 📂 GitHub 🧭 Threat Model

🌪️ METAR Stream — Real-Time Aviation Weather

Streaming Apache Kafka Spark Structured Streaming Delta Lake Medallion Architecture Python (Pandas · NumPy · PySpark) Live API Data Quality & Reconciliation Kill Switches & Graceful Degradation Docker Redpanda NOAA Aviation Weather API

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.

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.

🌐 Live Dashboard 📂 GitHub

🏃 Running Coach SFT — What a Fine-Tune Didn't Learn

AI / LLM Engineering LoRA / PEFT TRL SFTTrainer Qwen2.5-3B-Instruct Synthetic Data Generation Eval Harness Design Instruction Tuning Hugging Face Hub Pandas & NumPy OLS with Fixed Effects Heterogeneous Text Parsing HF Jobs (A10G) Daniels/Gilbert VDOT Strava 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.

📂 GitHub 🤗 Dataset 🧠 Model

🔌 SLM Offline Agent — Local ReAct, No API Key

AI / LLM Engineering Agentic / ReAct Loops Ollama Python (Pandas · NumPy · PySpark) CI Test Suites (pytest) Content Guardrails GitHub 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.

🦙 Ollama Model 📂 GitHub

🔥 PySpark Coding Assistant — QLoRA on Mistral-7B

AI / LLM Engineering QLoRA Fine-Tuning Eval Harnesses & Golden Sets MLflow HuggingFace PEFT Python (Pandas · NumPy · PySpark) Delta Lake Data 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.

🤗 Model 📊 Dataset 📂 GitHub

✈️ Infinite Flight Live Tracker

Python (Pandas · NumPy · PySpark) FastAPI Leaflet Live API OpenWeatherMap Render

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.

🌐 Live Demo 📂 GitHub

🌎 ClimatePulse – 57-Year Analytics Pipeline

Python (Pandas · NumPy · PySpark) Delta Lake ETL/ELT Medallion Architecture Data Modeling REST API Ingestion Incremental Processing & Control Tables Data Quality & Reconciliation Scikit-Learn NOAA API GitHub Actions

End-to-end Bronze → Silver → Gold pipeline analyzing 57 years (1970–2026) of NOAA daily station data across 24 global cities — Austin (home station), Houston, Newark, Dallas, Denver, London, Helsinki, Amsterdam, Brussels, Paris, Rome, Chicago, Los Angeles, San Francisco, Seattle, New York City, 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 an Austin-vs-Houston layer contrasting winter freezes and humidity (dew point, afternoon RH). Denver included for Boulderthon marathon race planning context.

📂 GitHub 🌐 Live Dashboard

⌚🏃🏽‍♂️ Garmin MCP Server — Training Plans Built From Your Actual Fitness

Python (Pandas · NumPy · PySpark) MCP Servers Pydantic Garmin Connect Structured Workout Schema Strength Workout API Riegel Performance Modelling Progressive Load Ramps Docker pytest GitHub Actions

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.

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.

📂 GitHub

🗺️ HoodaRoutes — Route Generation Scored Against Your Goal Race

Full-Stack Node.js Serverless REST API Ingestion Live API Claude API Structured LLM Output + Validation Deterministic Fallbacks OAuth 2.0 Signed Session Cookies (HS256) Rate Limiting Webhook Subscriptions Binary Protocol Encoding CI Test Suites (node:test) Vercel Railway Upstash Redis GitHub Actions OpenRouteService OpenStreetMap Strava API Copernicus DEM Garmin FIT Protocol Connect IQ / Monkey C Leaflet

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.

🌐 Live App 📂 GitHub

⚡ PaceForge — Offline AI Running Coach

Offline AI Python (Pandas · NumPy · PySpark) Ollama MCP Servers Local LLM Inference Agentic / ReAct Loops Hybrid RAG · BM25 + Dense Pydantic SQLite Garmin Connect Strava API CI Test Suites (pytest) Property-Based Testing (Hypothesis) mypy --strict GitHub Actions

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.

📂 GitHub 🦙 Ollama Model

🛡️ AI Governance

Responsible AI is an engineering requirement—not a blanket ban and not a box-checking exercise.

🛡️ 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.

🛩️ Off the Clock: Flight Log

Flying is a hobby. Here's my logbook, my live simulator stats, and the data engineering it gives me an excuse to build.

✈️ Live Flight Tracker

Real-time flights across the World powered by ADS-B transponder data and FlightAware. Includes airline, origin, and destination where available. Updates every 5 minutes.

🌪️ 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.

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.

⚡ ERCOT Grid — Texas Power, Live

🌤️ Your Current Weather

Live weather for wherever you're accessing this site from.

🌡️ ClimatePulse — Live Dashboard

🏭 Carbon & Warming

🌀 Hurricane Analytics — Warmer Water, Stronger Storms

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

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

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.

🍎 Apple Silicon Lab

🏃 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 Personal Record: TBD (Will make my marathon debut in late 2027 or early 2028)
• Half Marathon Personal Best: 1:24:31 (2025 Aramco Houston Half Marathon) View Badge
• 8k Personal Record: 29:48 (2025 40th annual Sugar Land Turkey Trot)
• 5-mile Personal Record: 30:22 (2025 40th annual Sugar Land Turkey Trot) View Results
• 5k Personal Record: 18:15 (2025 Women's Quarter Marathon - Houston Running Co) View Results
• Current Weekly Mileage: -- miles this week (live from Strava)
• Currently Training For: 2027 Aramco Houston Half Marathon
• Last Race + Time: 2026 NYCRuns Brooklyn Experience Half Marathon - 1:27:41 View Results

Follow my training journey on my public Strava account: here.

📊 Strava Intelligence

⌚ 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.

The generated block

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

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.

⚡ Last Week — Live Activity

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.

💬 Meet TARS – My AI Assistant

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!

🏔️ Morning Hike around Lake Monarch – Granby, CO

First solo hike in Arapaho National Forest. Soundtrack: Hans Zimmer – First Step & Day One (Interstellar).

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.

🔍 Network Analyzer

Professional network reconnaissance tools — DNS lookup, WHOIS, ping, traceroute, and HTTP header inspection.

📋 Build Log

Automated log of everything shipped on yashhooda.ai — features, security hardening, pipeline work, and agent activity. Updated continuously.

📬 Contact Info

I'd love to connect! Feel free to reach out to me: