1. ML/DL Fundamentals — From First Principles

• Linear algebra, probability and optimisation as they show up in training: gradients, loss landscapes, regularisation, why a run diverges.
• Classical ML and when it beats a neural network. Feature engineering, leakage, class imbalance.
• Deep learning: backpropagation, CNNs/RNNs, and transformers — attention, tokenisation, embeddings, context windows — at a mechanism level.
• Evaluation discipline. Split design, metric choice and its failure modes, overfitting diagnosis, the offline/online gap, significance on small samples. This is the single thing we probe most.
• Data intuition: you look at the

2. AI Engineering — Production Judgement

• LLM applications in production: RAG (chunking, embeddings, vector search, reranking), structured output, tool calling, agentic workflows.
• Prompts as engineering artifacts — versioned, tested, measured. Not tuned by vibes.
• Fine-tuning (LoRA/PEFT, instruction tuning) and the judgement to know when it isn’t worth it.
• Serving and optimisation: batching, quantisation, streaming, caching, provider fallbacks.
• Cost and latency ownership. You know what a feature costs at scale and how to halve it.

3. Software Engineering — this carries equal weight

An AI feature is 20% model and 80% the system around it. We will interview this as seriously as the ML.

Python, at depth-

• Production-shaped code: type hints, tested, reviewed, packaged. Not notebook-shaped.
• Async/await and concurrency — you know when it helps, when it doesn’t, and what blocks the event loop.
• Comfortable profiling and fixing slow code rather than guessing at it.
• FastAPI (or equivalent) in production, including dependency injection, validation with Pydantic, and background tasks.

4. REST API Design

• Sensible resource modelling, HTTP semantics and status codes used correctly.
• Versioning, pagination, filtering, and a consistent error contract clients can actually handle.
• Idempotency, retries and timeouts — especially in front of slow, flaky, expensive model calls.
• Authentication and authorisation (JWT/OAuth2), rate limiting, and per-tenant quota enforcement.
• Streaming responses (SSE/WebSocket) for token-by-token output.
• Documented interfaces — OpenAPI, kept honest.

5. Databases & Data Systems

• Strong relational fundamentals in PostgreSQL: schema design, normalisation and when to denormalise deliberately.
• Indexing you can justify — you read query plans (EXPLAIN ANALYZE) rather than adding indexes hopefully.
• Transactions, isolation levels, and where race conditions actually come from.
• Finding and fixing N+1 queries, and knowing what your ORM is doing underneath.
• Migrations on a live database without downtime.
• Connection pooling and behavior under concurrent load.
• Multi-tenant data modelling and row-level access control.
• A vector store for embeddings, and Redis for caching and queues — with a clear view of what belongs in each.

6. Running AI Systems in Production

• Docker, CI/CD, cloud (AWS or equivalent).
• Logging, tracing and alerting designed for AI systems specifically — where non-determinism means “it didn’t crash” is not the same as “it worked”.