166 skills · 15 areas

The engineering skill map.

Everything this product can tell you that you do not know, and what each thing depends on. Every mock round, lab, course evaluation and certification exam you finish moves your position on it.

Place yourself on it — free, 12 questions →

Every area

A skill is listed with the level it sits at and, under it, what it rests on. Those prerequisites are the real edges of the graph — a skill is scheduled after everything named under it, which is the order the plan builds.

Data integrity 12 skills

The numbers are wrong and nothing has crashed. Fan-out, double counting, late facts, replays.

  • Join fan-out and double counting

    Intermediate

    Needs first: Group-by traps

  • Dedupe and arrival order

    Intermediate

    Needs first: Idempotency and replay safety

  • Late-arriving facts

    Advanced

    Needs first: Dedupe and arrival order

  • Key stability across loads

    Intermediate

  • Idempotency and replay safety

    Intermediate

  • Timezone and partition drift

    Intermediate

  • Double counting in aggregates

    Beginner

  • Slowly changing dimensions

    Advanced

    Needs first: Key stability across loads

  • Referential integrity without constraints

    Intermediate

  • Backfill correctness

    Advanced

    Needs first: Idempotency and replay safety

  • Schema evolution and compatibility

    Advanced

  • Source-to-target reconciliation

    Intermediate

Query correctness 12 skills

The query runs, returns rows, and answers a different question than the one asked.

  • Window functions

    Intermediate

    Needs first: Group-by traps

  • Null semantics

    Beginner

  • Group-by traps

    Beginner

  • Off-by-one in ranges

    Beginner

  • Pagination correctness

    Intermediate

    Needs first: Off-by-one in ranges

  • Inner, outer and anti joins

    Beginner

  • HAVING versus WHERE

    Beginner

    Needs first: Group-by traps

  • Set operations and duplicates

    Intermediate

  • Date bucketing and boundaries

    Intermediate

    Needs first: Timezone and partition drift

  • Correlated subqueries

    Advanced

    Needs first: Inner, outer and anti joins

  • Reasoning about row counts

    Intermediate

    Needs first: Inner, outer and anti joins

  • Implicit type coercion

    Intermediate

Performance and cost 12 skills

Why it is slow and why it is expensive, which are usually the same cause.

  • Data skew and partitioning

    Advanced

  • Shuffle and exchange cost

    Advanced

    Needs first: Data skew and partitioning

  • Index choice and use

    Intermediate

  • Cost attribution

    Intermediate

  • Caching strategy

    Intermediate

  • Cache invalidation and staleness

    Advanced

    Needs first: Caching strategy

  • N+1 query patterns

    Beginner

    Needs first: Inner, outer and anti joins

  • Reading a query plan

    Advanced

    Needs first: Index choice and use

  • Memory pressure and spilling

    Advanced

  • Batch versus stream cost

    Intermediate

  • File and storage format choice

    Intermediate

  • Autoscaling behaviour

    Intermediate

Observability 11 skills

Knowing something is wrong before a user tells you, and measuring the right thing.

  • Metric definition

    Intermediate

  • Misleading metrics and averages

    Intermediate

    Needs first: Metric definition

  • DORA metric correctness

    Advanced

    Needs first: Metric definition

  • SLOs and SLIs

    Intermediate

    Needs first: Metric definition

  • Alert design and noise

    Intermediate

    Needs first: SLOs and SLIs

  • Distributed tracing

    Advanced

  • Structured logging

    Beginner

  • Label cardinality explosion

    Advanced

    Needs first: Metric definition

  • Percentiles versus averages

    Intermediate

    Needs first: Metric definition

  • Error budgets

    Advanced

    Needs first: SLOs and SLIs

  • Making a failure diagnosable

    Intermediate

    Needs first: Structured logging

Distributed systems 17 skills

What happens when one part fails and the rest carries on without it.

  • Consistency models

    Advanced

  • Retries and backoff

    Intermediate

  • Idempotent writes

    Intermediate

    Needs first: Idempotency and replay safety

  • Multi-region design

    Advanced

    Needs first: Consistency models

  • Queues and delivery guarantees

    Intermediate

  • Exactly-once versus at-least-once

    Advanced

    Needs first: Queues and delivery guarantees

  • Partial failure handling

    Advanced

    Needs first: Retries and backoff

  • Clock skew and ordering

    Advanced

  • Leader election and coordination

    Advanced

    Needs first: Consistency models

  • Backpressure

    Advanced

    Needs first: Queues and delivery guarantees

  • Circuit breaking and bulkheads

    Intermediate

    Needs first: Retries and backoff

  • Thundering herd and stampedes

    Advanced

    Needs first: Caching strategy

  • Split brain and fencing

    Advanced

    Needs first: Leader election and coordination

  • Race conditions

    Intermediate

  • Locking and contention

    Advanced

    Needs first: Race conditions

  • Atomicity and transactions

    Intermediate

    Needs first: Race conditions

  • Networking and timeouts

    Intermediate

API design 8 skills

Contracts other people have to live with: errors, pagination, versions, timeouts.

  • API contracts

    Beginner

  • Versioning and compatibility

    Intermediate

    Needs first: API contracts

  • API pagination

    Intermediate

    Needs first: Pagination correctness

  • Error semantics and status codes

    Beginner

    Needs first: API contracts

  • Rate limiting

    Intermediate

  • Authentication and authorisation flows

    Intermediate

    Needs first: Least privilege

  • Payload and schema design

    Intermediate

    Needs first: API contracts

  • Timeout and deadline propagation

    Advanced

    Needs first: Retries and backoff

RAG quality 10 skills

Retrieval that returns plausible, grounded, current answers rather than confident ones.

  • Chunking strategy

    Intermediate

  • Grounding answers in sources

    Intermediate

    Needs first: Chunking strategy

  • Retrieval evaluation

    Advanced

    Needs first: Chunking strategy

  • Citation correctness

    Intermediate

    Needs first: Grounding answers in sources

  • Hallucination detection

    Advanced

    Needs first: Grounding answers in sources

  • Embedding model choice

    Intermediate

  • Hybrid and keyword search

    Advanced

    Needs first: Embedding model choice

  • Reranking

    Advanced

    Needs first: Hybrid and keyword search

  • Context window budgeting

    Intermediate

    Needs first: Chunking strategy

  • Index freshness and staleness

    Intermediate

Agent reliability 10 skills

Agents that finish, recover, stay inside their limits, and do not loop forever.

  • Tool-call loops

    Intermediate

  • Agent state handling

    Advanced

    Needs first: Tool-call loops

  • Guardrails and refusals

    Intermediate

  • Failure recovery

    Advanced

    Needs first: Tool-call loops, Retries and backoff

  • Agent evaluation harness

    Advanced

    Needs first: Agent state handling

  • Prompt injection

    Advanced

    Needs first: Guardrails and refusals

  • Agent cost and step limits

    Intermediate

    Needs first: Tool-call loops

  • Determinism and temperature

    Beginner

  • Multi-agent coordination

    Advanced

    Needs first: Agent state handling

  • Human-in-the-loop checkpoints

    Intermediate

    Needs first: Guardrails and refusals

ML correctness 10 skills

Models that score well offline and fail in production. Leakage, skew, drift.

  • Data leakage

    Advanced

  • Train/serve skew

    Advanced

    Needs first: Feature pipelines

  • Feature pipelines

    Intermediate

  • Model and data drift

    Advanced

    Needs first: Feature pipelines

  • Choosing an evaluation metric

    Intermediate

  • Class imbalance

    Intermediate

    Needs first: Choosing an evaluation metric

  • Validation splitting

    Intermediate

    Needs first: Data leakage

  • Reproducibility and seeds

    Intermediate

  • Model versioning and rollback

    Intermediate

  • Inference latency and batching

    Advanced

    Needs first: Memory pressure and spilling

Security and compliance 10 skills

Least privilege, secrets, tenant isolation, and what you must not log.

  • Secret handling

    Beginner

  • Least privilege

    Intermediate

  • PII handling

    Intermediate

    Needs first: Least privilege

  • Audit trails

    Intermediate

  • Injection attacks

    Intermediate

  • Transport and at-rest encryption

    Intermediate

  • Dependency and supply chain

    Advanced

  • Access review and rotation

    Intermediate

    Needs first: Least privilege

  • Data residency

    Advanced

    Needs first: PII handling

  • Tenant isolation

    Advanced

    Needs first: Least privilege

System design 10 skills

Turning a vague requirement into constraints, then into a design you can defend.

  • Scoping a problem

    Beginner

  • Articulating trade-offs

    Intermediate

    Needs first: Scoping a problem

  • Capacity estimation

    Intermediate

    Needs first: Scoping a problem

  • Reasoning about failure modes

    Advanced

    Needs first: Partial failure handling

  • Choosing a storage engine

    Intermediate

    Needs first: Index choice and use

  • Read and write path separation

    Advanced

    Needs first: Capacity estimation

  • Choosing async boundaries

    Advanced

    Needs first: Queues and delivery guarantees

  • Migration strategy

    Advanced

    Needs first: Articulating trade-offs

  • Turning requirements into constraints

    Intermediate

    Needs first: Scoping a problem

  • Headroom and growth

    Intermediate

    Needs first: Capacity estimation

Behavioural 9 skills

Telling a real story with a real result, and owning the part that went badly.

  • Situation clarity

    Beginner

  • Personal ownership

    Beginner

  • Action specificity

    Intermediate

    Needs first: Situation clarity

  • Measurable result

    Intermediate

    Needs first: Action specificity

  • Reflection and learning

    Intermediate

    Needs first: Measurable result

  • Conflict handling

    Advanced

    Needs first: Personal ownership

  • Scope of influence

    Advanced

    Needs first: Personal ownership

  • Explaining a decision to non-engineers

    Intermediate

    Needs first: Situation clarity

  • Owning a failure

    Advanced

    Needs first: Personal ownership, Reflection and learning

Language semantics 16 skills

The traps your language has rather than your architecture: copies, equality, overflow, mutation.

  • Mutability and aliasing

    Intermediate

  • Shallow versus deep copy

    Intermediate

    Needs first: Mutability and aliasing

  • Mutable default arguments

    Intermediate

    Needs first: Mutability and aliasing

  • Integer division and truncation

    Beginner

  • Binary floating point

    Intermediate

  • Identity versus equality

    Intermediate

  • Type coercion and truthiness

    Beginner

  • Scope, hoisting and closures

    Intermediate

  • Mutating while iterating

    Intermediate

    Needs first: Mutability and aliasing

  • Sort semantics and stability

    Intermediate

  • Control flow traps

    Intermediate

  • Off-by-one in loops and slices

    Beginner

    Needs first: Off-by-one in ranges

  • Accumulator and state reset

    Intermediate

  • Numeric overflow and limits

    Advanced

    Needs first: Integer division and truncation

  • Error handling and swallowed failures

    Intermediate

  • Resource cleanup and leaks

    Advanced

    Needs first: Error handling and swallowed failures

Delivery and operations 9 skills

Getting it to production repeatedly, and getting it back when it goes wrong.

  • CI/CD pipelines

    Intermediate

  • Deployment strategies

    Intermediate

    Needs first: CI/CD pipelines

  • Configuration and drift

    Intermediate

  • Version control practice

    Beginner

  • Test strategy and coverage

    Intermediate

  • Test isolation and flakiness

    Advanced

    Needs first: Test strategy and coverage

  • Rollback and recovery

    Intermediate

    Needs first: Deployment strategies

  • Infrastructure as code

    Intermediate

    Needs first: Configuration and drift

  • Systematic debugging

    Intermediate

    Needs first: Making a failure diagnosable

Algorithms 10 skills

The interview staples, and defending a complexity claim out loud.

  • Sorting

    Beginner

  • Searching and binary search

    Intermediate

    Needs first: Sorting

  • Hashing and maps

    Beginner

  • Recursion

    Intermediate

  • Trees

    Intermediate

    Needs first: Recursion

  • Graphs

    Advanced

    Needs first: Trees

  • Greedy strategies

    Advanced

  • Backtracking

    Advanced

    Needs first: Recursion

  • Divide and conquer

    Advanced

    Needs first: Recursion

  • Defending a complexity choice

    Intermediate

    Needs first: Sorting, Hashing and maps

Knowing the map is not the same as knowing where you are on it.

The assessment is twelve scenario questions and it is free. It picks each question by how you answered the last, so it finds the gaps rather than confirming what you already know.

Take the free assessment →