Aditya Krothapalli 💡

[Ritesh Roushan @devXritesh]

if you can't design these 10 systems, are you really ready for a backend interview?

0. URL shortener
1. Rate limiter
2. Distributed cache
3. Notification system
4. News feed (like X)
5. Chat application
6. File storage (like Google Drive)
7. Video streaming (like YouTube)
8. Ride-sharing (like Uber)
9. Payment system

how many can you design without looking up the solution?

[Anshika Pathak @pathakanshika06]

Andrej Karpathy’s 1-hour Stanford lecture explains AI engineering beautifully.

10% → LLM
30% → Prompt
50% → Agent
70% → Loop
100% → Graph

The real power isn’t just prompting models. It’s building systems around them with context, memory, tools, and feedback loops.

“Delete everything, keep Graph.”

A must-watch for anyone building AI agents. 🚀

[Neo Kim @systemdesignone]

System design in 15 lines (save now):

High global latency → use a CDN

Slow database reads → add a cache

Sudden write spikes → add a queue

Distributed transactions → use Saga

Need ACID transactions → use SQL

Flexible data models → consider NoSQL

SQL database too large → shard the DB

Growing server load → scale out

High traffic → add a load balancer

Critical service failures → add redundancy

Need data durability → use replication

Too many requests → add throttling

Unpredictable traffic spikes → enable autoscaling

Realtime updates → use WebSockets

Retries causing duplicates → use idempotency keys

Start here...The rest is just details.

[Abhishek Singh @0xlelouch_]

90% of Kubernetes in 2026 comes down to mastering these 10 concepts:

1) Workloads (Deployment/StatefulSet/Job/CronJob) Pick the right controller; most “K8s bugs” are really wrong restart + rollout expectations.

2) Requests/limits + QoS Class If you don’t set them, the scheduler guesses and the node OOM killer teaches you in prod.

3) Probes (liveness/readiness/startup) Bad probes cause restart loops; missing probes cause traffic to dead pods and slow brownouts.

4) Services + EndpointSlices Know how traffic finds pods; half the weirdness is stale endpoints, wrong ports, or assuming pod IPs matter.

5) Ingress/Gateway + L7 timeouts Defaults bite: 60s proxy timeout, 1MB body limit, missing client IP headers, broken websocket upgrades.

6) DNS and service discovery CoreDNS issues look like app bugs; watch for search path surprises and connection storms on NXDOMAIN.

7) RBAC + service accounts Least privilege is real work; most clusters ship with overpowered bots and nobody notices until audit day.

8) NetworkPolicy + egress control Zero policies means flat network; strict policies mean debugging why metrics, DNS, and image pulls died.

9) Observability (logs/metrics/traces/events) Learn kubectl events, Prometheus labels, and trace sampling; otherwise you chase ghosts.

10) Debugging workflow kubectl describe/logs/exec, ephemeral containers, port-forward, and reading CNI/kubelet errors beats reinstalling the cluster.

[Swapna Kumar Panda @swapnakpanda]

Go GOD LEVEL in SYSTEM DESIGN by learning these concepts NOW:

[Mr. Buzzoni @Mr_Buzzoni]

holy f*ck, Karpathy put an entire AI degree on GitHub for free

7 repos, 306,741 stars, and in the right order they take you from backprop to agents that run research overnight

each repo is the next layer of the one before

1. micrograd -> how a neural net actually learns
backprop in about 100 lines of Python
↳ https://t.co/sZdt2ZhTs5

2. nn-zero-to-hero -> the video course
his lecture notebooks, from one neuron to GPT
↳ https://t.co/3rINVTCeY7

3. minbpe -> how text turns into tokens
the tokenizer every LLM starts with, in clean minimal code
↳ https://t.co/eeC6ySUzES

4. nanoGPT -> your own GPT
the simplest repo to train and fine-tune one
↳ https://t.co/pw8JPMvFmf

5. llm.c -> the same training with nothing hidden
raw C and CUDA, no PyTorch underneath
↳ https://t.co/neU4gdN71w

6. nanochat -> a full chat model end to end
GPT-2 level training cost ~$43,000 in 2019
here it's about $48
↳ https://t.co/MBcyMrTtRd

7. autoresearch -> agents that do the research
an agent edits the training code, trains for 5 minutes, keeps what improved and repeats all night
↳ https://t.co/EoyCfdPydo

train one GPT from scratch and you become the person who gets handed the AI project, along with the raise that comes with it

the classroom half of the same degree, what Stanford actually teaches about AI, is below ↓

[SumitX @Sumits_X]

As a Frontend Developer,

Please slap yourself if you cannot clearly explain at least 10 of the following :

Hydration
Partial hydration
Islands architecture
Streaming SSR
Concurrent rendering
Time slicing
Reconciliation algorithm
Fiber architecture
Virtual DOM diffing complexity
Structural sharing
Immutable data patterns
Referential equality
Memoization pitfalls
Stale closure problem
Event loop (macro vs microtasks)
Task starvation
Layout thrashing
Critical rendering path
Render blocking resources
Tree shaking internals
Code splitting strategies
Dynamic import chunking
Module federation
Shadow DOM
Custom Elements lifecycle
Web Components interoperability
Web Workers vs Service Workers
SharedArrayBuffer
Transferable objects
OffscreenCanvas
WebAssembly integration
Browser compositing layers
Paint vs composite vs layout
GPU acceleration in CSS
CSS containment
Subpixel rendering
IntersectionObserver internals
ResizeObserver loop limits
MutationObserver cost
IndexedDB
Service Worker lifecycle traps
Cache invalidation strategies
Stale-while-revalidate
ETag vs Cache-Control
HTTP/3 and QUIC
Priority hints
Preload vs Prefetch vs Preconnect
CORS preflight
SameSite cookie modes
CSRF vs XSS mitigation
Content Security Policy (CSP)
DOM clobbering
Prototype pollution
Race conditions in UI state
Tearing in concurrent UI
Render waterfalls
Suspense boundaries
Selective hydration
Server components
Edge rendering
Micro-frontend orchestration
Finite state modeling
Event sourcing in frontend
Optimistic UI rollback strategy
Offline conflict resolution
CRDT basics for collaboration
WebRTC
Backpressure in streams API
AbortController
Streaming fetch response handling
Browser memory leak detection
Detached DOM nodes
Garbage collection timing
PerformanceObserver API
Long tasks API
First Input Delay (FID)
Interaction to Next Paint (INP)
Cumulative Layout Shift (CLS)
Largest Contentful Paint (LCP)
Speculative prerendering
Priority inversion in async code
Deterministic rendering

[Shubh Jain @shubh19]

If I had 6 months to become an AI engineer

M1 → Python, APIs, Git
M2 → LLM basics: tokens, context, prompting
M3 → RAG: embeddings, vector DB, chunking
M4 → evals and tracing
M5 → agents with tool calling
M6 → ship 2 projects with live demos

Proof beats certificates

[Amit Sharma @AmitSha77280075]

Don't waste 2 years learning to become an AI agentic engineer in 2026.

Andrew Ng, the godfather of AI, gave the complete playbook to become one from scratch.

1 hour course. Free:

• 00:00 - AI agent basics
• 12:12 - AI Agentic workflows & design patterns
• 53:27 - Practical tips for building AI agents
• 1:20:30 - self-improving AI agent loops
• 1:30:19 - multi-agent AI systems

I watched it last night.

Halfway through, I realized I could get into Anthropic in weeks, not years.

Bookmark now. Watch it. Then build your own AI agent

[Tech Fusionist | Kushal Gangil @techyoutbe]

Go GOD Level in AI Engineering with 240 concepts across 21 simplified visuals (Bookmark NOW)

From LLMs and RAG to AI Agents, Infrastructure, and AI Security. 🚀

[Akhilesh Mishra @livingdevops]

𝗬𝗼𝘂’𝗹𝗹 𝗻𝗲𝘃𝗲𝗿 𝗳𝗼𝗿𝗴𝗲𝘁 𝗔𝗜 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 𝗼𝗻𝗰𝗲 𝘆𝗼𝘂 𝘀𝗲𝗲 𝗵𝗼𝘄 𝘁𝗵𝗲𝘆 𝗰𝗼𝗻𝗻𝗲𝗰𝘁.
The easiest way to learn AI fundamentals is to follow the problems.

You want a computer to understand text. But computers only understand numbers. They have no idea what "hello" means.

>> So you use tokens.
Text is split into small pieces, and each piece gets a number. "Unbelievable" becomes "Un", "believ" and "able". Now the computer can read.

But those numbers are random labels. "Dog" might be 4521 and "puppy" 9873. Nothing tells the computer they mean almost the same thing.

>> So you use embeddings.
Every token becomes a long list of numbers, placed so that similar meanings sit close together. "Dog" lands next to "puppy" and far from "Paris". Now numbers carry meaning.

But a word on its own is not enough. "Bank" means something different in "river bank" and "bank loan". The meaning depends on the neighbours.

>> So you use attention.
Every word looks at every other word and decides which ones matter. Now "bank" knows if it is near a river or a loan.

You have a structure that can read. But it knows nothing yet. Where does the knowledge come from?

>> So you use training.
You feed it a huge amount of text and give it one job: predict the next token. Every wrong guess adjusts billions of numbers called weights. After trillions of guesses, those weights hold grammar, facts, and reasoning.

But the trained model only knows how to continue text. Ask "What is the capital of France?" and it might write three more quiz questions. It is not being difficult. It has never seen a conversation.

>> So you use fine-tuning.
You train it further on thousands of examples of good questions and answers. Now it behaves like an assistant.

But it always picks the single most likely next word. Every answer sounds the same, flat and repetitive.

>> So you use temperature.
Low temperature plays it safe, which is right for code and facts. High temperature takes chances, which is right for ideas and writing. You choose the risk.

Now you paste in a 500-page manual and ask a question. Half of it gets ignored. In long chats, it forgets what you said at the start.

>> That is the context window.
The model can only see so much text at once. Everything outside it does not exist.

Then you ask about your company's internal docs. The weights were frozen during training and were never seen. The model does not say "I don't know". It writes something that sounds right and is completely wrong.

>> That is hallucination.
It is not lying. It is predicting text, not checking facts.

>> So you use RAG.
Before answering, the system searches your real documents and puts the relevant parts into the context window. Now it is an open-book exam, not a memory test.

But it can still only talk. It cannot check your server, query your database, or open a ticket.

So you give it tools. The model decides which tool to call, reads the result, and keeps going until the job is done.

>>That is an agent everyone seems to be building these days.

[Swapna Kumar Panda @swapnakpanda]

Agentic AI is the FUTURE.

Go GOD Level in Agentic AI by completing these practical courses:

[Tech Fusionist | Kushal Gangil @techyoutbe]

Day 1: System Design Fundamentals for AI

- what is ai system design?
- Ai vs traditional systems
- core functionalities
- High-level AI System Design
- Key Terms to understand before deep dive
- Build Design mindset
- Tools that can help in system design

[Neo Kim @systemdesignone]

If you want to become god-level at system design (in 3 weeks), then learn these 15 case studies:

[Vishal Singh @vishalsingh2972]

If you learn AI Agent Engineering, you will never be unemployed again.

I'd blindly follow these 12 stages.

STAGE 01 → Agent Architecture & State Machines
↳ Learn: DAGs, LangGraph, Temporal, checkpointing.
↳ Build: An agent that loops, branches, pauses and resumes.
↳ Why: Chat loops break. Production agents need durable state.

STAGE 02 → Tool Use & MCP
↳ Learn: Function calling, JSON-RPC, Pydantic, MCP, OAuth.
↳ Build: A secure MCP server with read-only Postgres access.
↳ Why: Agents need standardized tools, not fragile wrappers.

STAGE 03 → Trajectory Evals & Observability
↳ Learn: Tracing, golden datasets, step-level grading, LLM judges.
↳ Build: CI that evaluates 50 scenarios, tool paths and failures.
↳ Why: Correct outputs can hide dangerous execution paths.

STAGE 04 → Memory & Context Engineering
↳ Learn: Working, episodic, semantic memory, token budgets.
↳ Build: An agent that compresses 50 turns into useful memory.
↳ Why: Unlimited context doesn't mean better reasoning.

STAGE 05 → Agent Security & Guardrails
↳ Learn: Prompt injection, tool poisoning, least privilege.
↳ Build: A security layer blocking unauthorized agent actions.
↳ Why: One compromised agent can threaten the entire system.

STAGE 06 → Sandboxed Execution
↳ Learn: E2B, gVisor, Docker, network isolation.
↳ Build: An agent that executes Python inside a secure sandbox.
↳ Why: Never give an LLM unrestricted host access.

STAGE 07 → Human-in-the-Loop
↳ Learn: Async approvals, webhooks, durable pauses, audit logs.
↳ Build: A $10k invoice agent that waits for Slack approval.
↳ Why: High-stakes actions need human accountability.

STAGE 08 → Computer Use & GUI Automation
↳ Learn: DOM parsing, screenshots, Playwright, visual grounding.
↳ Build: An agent that navigates a portal and downloads CSVs.
↳ Why: Legacy software doesn't always have APIs.

STAGE 09 → Self-Correction Loops
↳ Learn: Validators, tracebacks, bounded retries, error analysis.
↳ Build: A coding agent that fixes errors and retries up to 3 times.
↳ Why: Reliable agents recover instead of giving up.

STAGE 10 → Graceful Degradation
↳ Learn: Circuit breakers, timeouts, browser fallbacks, model routing.
↳ Build: An agent that uses browser automation when APIs fail.
↳ Why: Production systems break. Reliable agents adapt.

STAGE 11 → Multi-Agent Orchestration & A2A
↳ Learn: A2A protocols, typed handoffs, agent topologies.
↳ Build: Researcher + Coder + Reviewer with typed A2A handoffs.
↳ Why: Poor handoffs turn collaboration into chaos.

STAGE 12 → Public Teardowns & Portfolio
↳ Learn: ADRs, cost-per-task, p95 latency, benchmarking.
↳ Build: A public teardown showing costs, failures and evals.
↳ Why: Real engineering beats another LangChain demo.

The goal isn't to build an agent that works once.

It's to build one that works reliably, securely and at scale in production.

📌 Bookmark this + send it to someone learning AI agents.

[diva @divaagurlxw]

90% of AI Engineer interviews in 2026 are just these 15 concepts repeated:

1/ Transformers & LLM Fundamentals: how LLMs predict the next token, self-attention, multi-head attention, positional encoding, and why transformers replaced RNNs

2/ Tokenization & Embeddings: BPE, how text becomes tokens, and how vectors capture meaning

3/ Prompt Engineering: system prompts, few-shot learning, chain-of-thought, and structured outputs (JSON/schema)

4/ RAG: chunking strategies, retrieval, context injection, context windows, and why RAG beats fine-tuning for fresh data

5/ Vector DBs & Search: vector databases, semantic search, hybrid search , reranking, and HNSW indexes

6/ Function Calling, Tool Calling & MCP: how LLMs trigger APIs, code and databases, and the standard protocol for connecting them

7/ AI Agents & Agentic Workflows: plan, act and observe loops, orchestrated multi-step pipelines, and AI coding agents

8/ Memory & Multi-Agent Systems: short-term and long-term memory, and specialized agents collaborating on a task

9/ Fine-Tuning: full fine-tuning, LoRA, QLoRA, PEFT, and when to fine-tune vs prompt vs RAG

10/ Alignment & Distillation: RLHF, DPO, and knowledge distillation (big model teaches small model)

11/ Quantization & Model Compression: INT8/INT4, pruning, sparsity, and the quality vs speed vs cost tradeoff

12/ Inference & Serving: prefill vs decode, KV cache, speculative decoding, LLM serving, vLLM, batching, and model routing

13/ Multimodal AI & Vision-Language Models: text, image, audio and video in one system, and models that see and reason about images

14/ Evals & Hallucination Detection: LLM evaluation, LLM-as-judge, prompt evaluation, and catching confident but wrong answers

15/ Safety, Observability & Production: guardrails, AI safety, prompt injection, tracing, cost optimization, and production GenAI systems

Know these 15 deeply and you can crack most AI engineer interviews

[Unnati @Unnati_builds24]

If I had to pass an AI engineer technical interview in the next 24 hours, I'd practice these 25 problems.

They cover 95% of the concepts.

1) Design a RAG system for 10M documents
2) Your RAG gives wrong answers. Debug it
3) Pick a chunking strategy for legal contracts
4) BM25 vs dense vs hybrid search: when to use each
5) Add a reranker and measure if it helped
6) Reduce LLM cost by 70% without hurting quality
7) Cut first-token latency for a chat app
8) Design a semantic cache with hit-rate tracking
9) Route requests between a cheap and a smart model
10) Build an agent that uses tools reliably
11) Your agent gets stuck in a loop. Fix it
12) Design memory for a long-running assistant
13) Make LLM output always valid JSON
14) Detect and reduce hallucinations
15) Build an eval suite for a customer support bot
16) LLM-as-a-judge: how to make it trustworthy
17) Block prompt injection in a tool-using agent
18) Redact PII before it hits the model
19) Fine-tune vs RAG vs prompting: pick one and defend it
20) Fine-tune a small model with LoRA on 5K examples
21) Serve an open model at scale (batching, KV cache, quantization)
22) Stream responses over SSE and handle disconnects
23) Trace every step of a multi-agent workflow
24) Roll back a bad prompt change in production
25) Design ChatGPT-style chat for 1M daily users

Don't memorize answers.
Practice explaining trade-offs out loud.

That's what interviewers actually grade.

Bookmark this. You'll need it before your next interview.

[Tijori @Tijori1]

Insightful video by @suru27 on how to evaluate casting and forging companies.

One important metric is what percentage of revenue comes from machining

Here is a list of companies with high machined share, might be a good starting point to start researching

[Aditya Krothapalli 💡 @ikrothapalli]

@naval No one that’s allowed right , only for saying we preach “It is better that ten guilty persons escape than that one innocent suffer." But in practice we are ensuring that 10 guilty escape and innocents also suffer 😂

[Aditya Krothapalli 💡 @ikrothapalli]

@EquityValueIn Styrenix ka kab ayega recognition 😂