07 — The 13-Month Pitch (Who You Are At M13)

Thirteen months from now, someone will ask you what you do. This file has the answer, in six different lengths for six different situations. Every version grounds in specific shipped artifacts. No adjectives without evidence. No claims without a URL.

When to use this file: M11 onward. Rehearse the 30-second version until it’s muscle memory. Adapt the others to context.

The Core Sentence

“I build agentic services on top of LLMs AND the inference infrastructure that serves them — I understand every layer from the HTTP request to the tensor core, including the multi-node fabric between them.”

Everything below is an expansion or compression of this.

Version 1 — The 30-Second Elevator

For: recruiter first-contact call, a stranger at a meetup, a friend of a friend at a wedding.

“I’m an inference engineer. I started as an applied ML engineer at Zoho building agentic products, and over the last year I went deep on the layer under model.generate() — CUDA kernels, engines like vLLM, quantization, distributed serving. I built a small inference engine from scratch, contributed to [vLLM/SGLang], and wrote a reference architecture for on-prem LLM serving. Right now I’m looking for roles where I can do that full-time.”

Delivery notes:

  • Say the whole thing without breathing pause after “engineer.” That first word is the label; everyone attaches to labels.

  • Name the exact project you contributed to; don’t say “an open-source engine.”

  • End with the ask. Recruiters need to know what to route.

Version 2 — The 2-Minute Recruiter Call

For: the actual first-round recruiter conversation, 5 minutes into the call.

“Background: I’ve been at Zoho for [N] years as an applied ML engineer, mostly on recommendations and prediction R&D. Around the middle of last year my work shifted to agentic products — building the harnesses and services on top of LLMs. Real production, on-prem and cloud.

“What I noticed was that most of the interesting engineering problems were living below the API call — how the model was served, how KV cache was managed, why latency was what it was, why cost was what it was. So over the last thirteen months I went deep on that layer.

“Concretely, I built a small inference engine from scratch — continuous batching, paged KV cache, OpenAI-compatible API — with a benchmark harness comparing it against vLLM. I wrote FlashAttention-2 in Triton with numerics tests. I contributed [N] merged PRs to [vLLM/SGLang] around [your area]. I published a quantization bake-off comparing five formats on an 8B model. And I built a reference architecture for enterprise on-prem LLM serving with measured SLOs, informed by the Zoho on-prem product experience.

“What I’m looking for is an inference infrastructure role — probably at a serving-focused company like [vLLM commercial arm, Baseten, Fireworks, Together, Anyscale] or at a company doing serious inference in-house. Distributed inference and rollout infrastructure are the areas I’m most interested in going deeper on.”

Delivery notes:

  • The narrative arc: applied ML → agentic → served the models → learned the stack → shipped artifacts.

  • Every claim has an artifact behind it. Have URLs ready.

  • Name your target list. Recruiters respect specificity.

Version 3 — The 5-Minute Technical Screen Intro

For: the first 5 minutes of a technical study when they say “tell me about your background.”

“I’ll structure this as three chapters: what I did before, what I built in the last year, and what I’m looking to do next.

“Before: Applied ML at Zoho. Recommendation systems, prediction R&D, then agentic services — long-running automation on top of LLMs. Solid Python, distributed services background, production SLOs, on-prem deployment. What I lacked was systems-level understanding of the stack below the API — kernels, engines, quantization, distributed serving.

“Last year: I ran a structured 13-month curriculum to close that gap. Bottom to top: I started with CS:APP-level systems fundamentals and C++ for CUDA, then built a from-scratch inference GPT that matches HuggingFace output token-for-token on Llama-3-8B. Then GPU kernels — I did the full SGEMM ladder in CUDA from naive to double-buffered tensor-core, hitting around 80% of cuBLAS on my 3090, with Nsight Compute evidence for every optimization step. Then FlashAttention — I wrote FA2 forward in Triton, matching SDPA numerics within tolerance, and studied the FA3 and FA4 papers.

“The capstone was a mini inference engine — Python + PyTorch + my Triton kernels — with continuous batching, paged KV cache, prefix reuse, OpenAI-compatible streaming API, and a benchmark harness comparing latency-throughput curves against vLLM. That’s public on GitHub with the benchmark data.

“Around that I did a quantization bake-off on an 8B model across GPTQ, AWQ, FP8, and GGUF Q4_K_M, with speed × quality tables. I’ve merged [N] PRs to [target project], mostly around [your area]. And I wrote a reference architecture doc for enterprise on-prem LLM serving on 8×H100, which pulled together Zoho’s on-prem constraints with the serving techniques I’d learned.

“Next: I want to spend the next several years deepening on distributed inference infrastructure. Disaggregated prefill/decode, prefix-cache-aware routing at scale, and the rollout infrastructure inside training — that intersection between serving and RLHF is where I think the most interesting problems are for the next few years.”

Delivery notes:

  • Three chapters is the frame. study partners remember structure.

  • Land the specific numbers: 80% cuBLAS, token-for-token match, N merged PRs.

  • Show a direction for the next years, not just the next role.

Version 4 — The Portfolio Landing Page

For: yoursite.dev or GitHub profile README. First impression for any recruiter searching.

# [Your Name] · Inference Engineer

I build the layer between the HTTP request and the tensor core.

Ex-Zoho (applied ML → agentic products). Now doing full-stack inference
engineering: kernels, engines, quantization, distributed serving.

## Shipped Work

- **[Mini Inference Engine](https://github.com/you/mini-engine)** — continuous
  batching, paged KV, OpenAI-compatible API, benchmarked vs vLLM.
- **[Enterprise Reference Architecture](link)** — 8×H100 on-prem LLM platform
  with prefix-cache-aware routing, measured SLOs, agentic workload profile.
- **[Triton FlashAttention-2](link)** — from-scratch FA2 forward, matches
  SDPA numerics, benchmarked against official flash-attn.
- **[SGEMM Ladder](link)** — 6 CUDA kernels from naive to tensor-core,
  ~80% of cuBLAS on RTX 3090, Nsight evidence per step.
- **[Quantization Bake-Off](link)** — 8B model × 5 formats × 2 batch sizes
  × quality metrics. Written for r/LocalLLaMA.
- **[N merged PRs to vLLM/SGLang](link)** in the [your area] area.

## Writing

- [13 months from applied ML to inference engineer](link) — meta-retro
- [Prefix caching for agentic loops](link)
- [The three numbers that rule inference](link)

## Contact

[email] · [github] · [x/twitter] · [linkedin]

Open to inference infrastructure roles, remote-first or Bangalore/Chennai.

Rules:

  • No adjectives. “Efficient”, “scalable”, “cutting-edge” — cut them.

  • Every claim links to an artifact.

  • No TBD sections. If it isn’t shipped, it isn’t listed.

Version 5 — The LinkedIn Headline

For: the 220-character LinkedIn title. This is what appears in every recruiter search.

Inference Engineer · vLLM contributor · Built mini LLM serving engine (paged KV, continuous batching) · ex-Zoho applied ML → agentic → serving · Open to distributed inference roles

Rules:

  • Lead with the identity (Inference Engineer).

  • Second, the credibility marker (vLLM contributor or similar — whatever’s true).

  • Third, the concrete artifact (the mini engine).

  • Fourth, the arc.

  • Fifth, the ask.

Version 6 — The Email Signature

For: cold emails, PR comments, general professional signature.

[Your Name]
Inference Engineer
[github link] · [portfolio link]

Three lines. That’s it. If they want more they click.

Version 7 — The “Why Should We Hire You” Answer

For: the near-final round when the hiring manager asks this directly.

“Three reasons:

“First, I’ve closed the gap between applied ML and systems. Most applied ML engineers can call model.generate() and most kernel engineers can’t build a production service. I can do both. That range is rare and it’s what a serving team actually needs.

“Second, I have real production instincts, not just kernel curiosity. My Zoho background is long-running automation services and on-prem deployment. Everything I’ve built in the last year — the mini engine, the reference architecture, the PRs — reflects that. I know what breaks at 3 AM and what the observability has to look like, not just what the paper says.

“Third, I’ve shown I can execute at pace on a self-directed plan. Thirteen months, eight portfolio artifacts, [N] merged PRs, all in personal time alongside a full-time job. That’s the meta-signal. I don’t need to be managed into contribution.”

Delivery notes:

  • Three is the magic number for “why hire me” answers.

  • Each reason grounds in a class of evidence.

  • End with the meta-signal — self-direction — because that’s what senior/staff hires get judged on.

What You Are NOT Claiming (Discipline)

At M13, do NOT claim:

  • “Expert in CUDA.” You’re competent. You’ve done the ladder. That’s honest.

  • “Deep experience in production LLM serving at scale.” You’ve built a reference architecture. You have not run one at 20K QPS. Say so.

  • “Trained large models.” You’ve pretrained a small one and fine-tuned. Say so.

  • “Speak for FlashAttention / vLLM / SGLang.” You’re a contributor, not a maintainer.

Overclaiming is caught in 2 minutes by any senior study partner and permanently destroys trust. Underclaim slightly; let the artifacts overshoot the claim.

The Rehearsal Schedule

M11 week 1:

  • Write the Portfolio Landing Page (Version 4). Publish.

  • Update LinkedIn headline (Version 5).

  • Update email signature (Version 6).

M11 week 2:

  • Rehearse the 30-second version (Version 1) out loud 20 times.

  • Rehearse the 2-minute version (Version 2) 10 times, ideally with a friend listening.

M11 week 3:

  • Rehearse the 5-minute technical screen intro (Version 3) 10 times.

  • Time yourself. Should land at 4:30–5:15 minutes.

M11 week 4:

  • Draft the “why hire me” answer (Version 7) fully written.

  • Practice it 5 times.

M12 onward: Refine per study feedback. What questions kept coming? Fold answers into Version 3.

The Pitch Evolves — Yearly Rewrite

M13 pitch is bootstrap. By M18, R8 has 6 months of history. By M24, you have a talk on record. Rewrite this file every 6 months. The pitch is a living artifact. But the core sentence — HTTP request to tensor core — should remain load-bearing for at least 3 years. It’s a rare enough claim that only a few hundred people globally can honestly say it.

The One Sentence

HTTP request to tensor core. Every layer. The artifacts prove it. That’s the pitch.

Return to README.md · Master fortress: ../README.md