Interview Prep Hub

Aggregated technical templates + behavioral stories for interview prep. LLM: update when new patterns added, SD problems completed, or behavioral stories refined.

Plan window: May 11 → Nov 11, 2026. Live progress: [[Coach/project_current_week]] · [[Coach/project_dsa_sd_curriculum]]

---

Single-track focus (revised May 11, 2026)

In scope: DSA + System Design + Behavioral + Applications. Everything else deprioritized — see [[synthesis/Job Switch Hub]] kill list.

---

Round Types & What to Expect

---

Prep Priority Map (revised)

Primary track (active prep)

1. DSA patterns        → Python, NeetCode 150 + revision pass by W22
2. System Design HLD   → 15 problems interview-ready by W20
3. Behavioral          → 4 STAR stories drilled to fluency by W4
4. Applications        → Referral DMs W3+, cold apps from W5

Background / on-demand (don't dedicate prep blocks)

5. SQL                  → Done; refresh only if asked in screen
6. API Design           → Verbal review pre-onsite, no dedicated weeks
7. Python internals     → Verbal review pre-onsite, no dedicated weeks
8. AI/RAG domain        → AskTGE war story covers it

Only if specifically asked / role-specific

9.  LLD / Machine Coding → JS interview cards covered; deeper drill only post-screen
10. Frontend internals (JS / React / TS) → study only if FE-heavy role surfaces
11. Frontend SD         → only if FE-heavy role surfaces
12. FastAPI internals   → war story has it; no dedicated week

---

DSA — Pattern Frequency Map

Target: NeetCode 150 done by W16 (Aug 30) + revision pass by W22 (Oct 11).

---

SQL — Interview Level (✅ DONE — maintenance only)

Tested heavily at: Razorpay, PhonePe, Juspay, Zepto (fintech companies). Refresh templates below before any fintech screen.

Must Know

-- Joins: know when to use each
INNER JOIN   -- only matching rows both sides
LEFT JOIN    -- all left, matching right (nulls for no match)
RIGHT JOIN   -- all right, matching left
FULL OUTER   -- all rows both sides

-- GROUP BY vs WHERE
WHERE  → filters BEFORE aggregation
HAVING → filters AFTER aggregation (on aggregated values)

-- CTEs (Common Table Expressions)
WITH recent_orders AS (
  SELECT user_id, COUNT(*) as cnt FROM orders
  WHERE created_at > NOW() - INTERVAL '30 days'
  GROUP BY user_id
)
SELECT * FROM recent_orders WHERE cnt > 5;

-- Window functions — come up constantly in senior interviews
ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC)
RANK()        -- gaps on ties
DENSE_RANK()  -- no gaps on ties
LAG(salary, 1) OVER (ORDER BY date)   -- previous row value
LEAD(salary, 1) OVER (ORDER BY date)  -- next row value
SUM() OVER (PARTITION BY dept)        -- running totals

-- Subquery vs JOIN — know when each is cleaner
-- Indexes: B-tree default, composite index column order matters
-- EXPLAIN plan: seq scan vs index scan
-- N+1 problem: detect with EXPLAIN, fix with JOIN or batch load

Practice

• DataLemur (concept + company-tagged) → LeetCode SQL 50 (volume)
• Target: write medium-complexity queries without reference in 5 min

Interview Questions to Prepare Verbally

• "What's the difference between WHERE and HAVING?"
• "When would you use a CTE vs subquery?"
• "What is a composite index and why does column order matter?"
• "How do you find the second highest salary?" (classic — DENSE_RANK or subquery)
• "What is the N+1 problem and how do you fix it?"

---

FastAPI — Interview Level

What "interview ready" means: can design + explain a complete API from scratch.

# Async endpoint + Pydantic model
@app.post("/items", response_model=ItemOut)
async def create_item(item: ItemIn, db: AsyncSession = Depends(get_db)):
    ...

# Dependency injection — explain this clearly
def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
    ...  # decode JWT, raise 401 if invalid

# Middleware
@app.middleware("http")
async def log_requests(request: Request, call_next):
    start = time.time()
    response = await call_next(request)
    # add latency header
    return response

# Background task (non-blocking)
@app.post("/send-email")
async def send(bg: BackgroundTasks, payload: EmailPayload):
    bg.add_task(send_email_async, payload.to, payload.body)
    return {"status": "queued"}

# Lifespan (replaces @app.on_event)
@asynccontextmanager
async def lifespan(app: FastAPI):
    await db.connect()    # startup
    yield
    await db.disconnect() # shutdown

Interview question: "How does FastAPI handle sync vs async routes?" → Async routes run on event loop. Sync routes run in a thread pool (via run_in_executor) to avoid blocking. Don't mix blocking I/O inside async routes.

See: [[Python/Libraries/FastAPI]]

---

LLD / Machine Coding (deprioritized — review only if asked)

Product companies test this. Python OOP + design patterns. Not a dedicated prep week in revised plan — review the 5 templates below pre-screen if the company posts LLD-specific questions.

Python LLD prep

# Know these patterns cold:
from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool: ...

class StripeProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool:
        ...  # concrete impl

5 Problems to Cover

SOLID principles (verbal):

• S — one reason to change
• O — extend without modifying
• L — subclass replaceable for base
• I — don't force unused interface methods
• D — depend on abstractions, not concrete classes

---

System Design — 15 Problems (Target W6–W20)

Interview level = whiteboard from scratch in 45 min with trade-off discussion.

RAG & LLM = covered via AskTGE war story (separate from SD list). API Gateway = covered via JWT auth + circuit breaker concepts in URL Shortener / Rate Limiter deep dives.

Mark ⬜ → ✅ only after: can explain all key concepts cold + survive 10 min of follow-up questions.

Mark ⬜ → ✅ only after: can explain all key concepts cold + survived 10 min of follow-up questions.

Real interview patterns (10+ companies): — [[Real Interview SD Questions]]

• Push-based systems (WebSockets, notifications, fan-out) appear in 3/10 real interviews — prep this
• Domain-specific problems are norm — research company's product before interview
• LLD (class diagram) catches candidates off guard — Glovo had 30min UML phase
• Ask tooling upfront: "What tool for design? Excalidraw vs Google Doc?"
• Problems you won't find on YouTube: pagination depth, saved-search notifications, subscription payments, cross-DC replication

L7 signals that separate Senior from Staff:

• State the cost of every component you add (latency, dollar, ops)
• Mention hot key problem proactively for any read-heavy system with viral/skewed traffic
• Defend cache with hit rate math, not just "cache = fast"
• Flip to failure-first: "How does this break?" — state inconsistency during failover, cache cold start, key generator SPOF
• Say "we don't need X yet" when numbers don't justify it — brave answer, impressive at senior level

See: [[System Design/Senior SD Mindset]] — full L7 mindset page

SD Interview Formula (cold)

1. Clarify: functional + non-functional requirements, scale numbers
2. Estimates: QPS, storage, bandwidth (back of envelope)
3. High-level: components + data flow diagram
4. Deep dive: 2 hard components (the interesting parts)
5. Trade-offs: why this choice vs alternatives
6. Failure modes + monitoring

---

API Design Principles (3 days)

REST constraints:
- Stateless: no server-side session, JWT in header
- Idempotency: GET/PUT/DELETE idempotent; POST not by default
  → idempotency key header for POST (payment APIs)
- Resource naming: /users/{id}/orders not /getUserOrders

HTTP status codes (must know cold):
200 OK, 201 Created, 204 No Content
400 Bad Request, 401 Unauthorized, 403 Forbidden
404 Not Found, 409 Conflict, 422 Unprocessable Entity
429 Too Many Requests, 500 Internal Server Error, 503 Unavailable

Pagination:
- Offset: simple but slow on large tables (OFFSET 10000 scans 10000 rows)
- Cursor: use last seen ID or timestamp — senior answer, O(1) per page

Versioning: /v1/resource (URL path) or Accept-Version: v2 (header)

Error response: always include { "error": "...", "code": "...", "request_id": "..." }

---

Python Internals (1 week verbal prep)

See: [[Python/Language Core/Python Programming]], [[Python/Libraries/Asyncio]]

---

Behavioral Stories — STAR Map

Full stories: [[Private/Interview Questions for Project or behaviour/Past Experience Q&A For Interview]]

Rules:

• Never publish HCLTech code. War stories only.
• Frame in terms of business impact, not just technical detail.
• Quantify where possible.
• Lead with AskTGE for AI / backend / product roles. Lead with WebSocket geo for distributed systems roles.
• STAR-drill all 4 main stories 10× each in W1–W2 (May 11–24).

---

Frontend Machine Coding (for Full-Stack roles)

Your existing notes: [[FrontEnd/Java script/JavaScript Function Code Examples for Interviews]]

Already covered:

• Debounce (basic + cancel/flush)
• Throttle
• Promise.all / allSettled / race / any
• Currying / infinite currying
• Array polyfills (map, filter, reduce)
• Deep clone

Still needed:

• Memoize function
• Event emitter (on/off/emit)
• LRU Cache (JS class, Map-based)
• Virtual DOM diff (basic)

---

Pre-Interview Checklist

48 hours before

• Revise all 10 DSA pattern templates
• Re-read 3 most recent SD problems
• Review behavioral stories (especially AskTGE)
• Research company (product, tech stack, recent news, engineering blog)

Day of

• Python 3.11+ environment ready
• Pen + paper for SD diagrams
• Clarify constraints FIRST before coding
• Think aloud throughout — interviewers evaluate process

---

Related

• [[synthesis/Job Switch Hub]] — timeline, target companies, kill list
• [[synthesis/Tech Stack Overview]] — positioning guide
• [[synthesis/Concurrency Deep Dive]] — Go + Python concurrency deep dive
• [[synthesis/LLM & AI Stack]] — AI company targeting (Sarvam, Krutrim)
• [[Coach/project_current_week]] — this week's problems + decision gate
• [[Coach/project_dsa_sd_curriculum]] — full 26-week table
• [[DSA/DSA Topics]] — DSA index
• [[System Design/System Design Basics]] — SD fundamentals
• [[Python/Libraries/FastAPI]] — FastAPI wiki page (background reference only)
• [[Python/Libraries/Asyncio]] — async internals (background reference only)