Courses for developers

How compensation is actually decided, what is negotiable beyond base salary, and the specific words to use when an offer arrives. A few hours here routinely returns more than a year of side projects.

The management interview in detail: people scenarios, hiring, performance conversations, project execution and stakeholder work, with the structures that keep an answer from wandering. Manager answers fail on structure more often than on substance.

Aimed above the first management rung, at directors and senior leaders, covering organisational design, strategy, cross functional influence and the scope questions that separate levels. The questions change shape at this level rather than getting harder.

A working engineer's grounding in modern AI: what a model actually does, how transformers and embeddings work, what training and fine tuning involve, and where the current limits are. Written for people who need to build with this technology rather than publish papers about it.

System design for AI backed products, covering retrieval pipelines, vector stores, model serving, evaluation, cost control and the latency budget that makes or breaks the user experience. This round is now appearing in loops that had no AI content two years ago.

Using AI tools deliberately across a job search: sharpening a resume against a specific posting, preparing for interviews, researching companies and drafting outreach that does not read as generated. Practical, and unusually concrete about where the tools help and where they hurt you.

The course that made system design interviews learnable, working through designs for services like a URL shortener, a news feed, a messaging system and a video platform, each with the requirement gathering, capacity estimates and trade off discussion an interviewer expects.

The building blocks every design answer is assembled from: load balancers, caches, databases, replication, sharding, message queues, consistency models and the CAP trade off. Start here if the full design walkthroughs feel like they assume knowledge you do not have.

The follow on course, working through the real distributed systems that the standard designs are built from, including consensus, distributed storage and coordination. This is the material that separates a senior answer from a mid level one.

The recurring distributed systems patterns behind most designs, including write ahead logs, leases, heartbeats, quorums, segmented logs and consistent hashing. Learn the patterns once and you stop reinventing an answer for every question.

Service decomposition, inter service communication, data ownership and the failure modes that appear the moment a system stops being one process. Interviewers ask about the trade offs, not the diagram.

The named patterns that make service architectures survivable, including API gateway, circuit breaker, bulkhead, sidecar, saga, CQRS and event sourcing. Each one exists because someone lost a weekend to the problem it solves.

How systems actually scale, covering horizontal growth, statelessness, caching layers, database partitioning and the bottlenecks that appear at each order of magnitude. Focused on the reasoning an interviewer is listening for.

A compressed run through the system design round for when the interview is next week and the full course is not going to happen. Enough structure to stop you improvising.

REST, GraphQL, gRPC and event driven interfaces compared on the criteria that actually decide between them: coupling, versioning, latency and who pays the cost of a change. API design rounds are increasingly common and rarely prepared for.

Schema design, normalisation, indexing and the modelling decisions that determine whether a system is pleasant or painful three years in. The data model outlives every other decision in a codebase.

How databases actually work underneath: storage engines, indexes, transactions, isolation levels and the relational versus non relational choice. The layer that makes system design answers defensible instead of hand waved.

The classic object oriented patterns presented with the problem each one solves, so you apply them where they help rather than everywhere. Pattern vocabulary shows up in design rounds and in every code review you will ever have.

The five principles behind maintainable object oriented code, with examples of what violating each one costs later. Short, and it directly improves the code you write tomorrow.

Teaches the twenty or so patterns that sit underneath almost every coding interview question, so you stop memorising solutions and start recognising problem shapes. Solve one sliding window problem here and you can solve the next forty on your own.

The layer below pattern practice: arrays, linked lists, stacks, queues, trees, heaps, graphs and hash tables, each built up from first principles with the complexity analysis that interviewers actually ask about. Start here if pattern courses feel like they are moving too fast.

Dynamic programming broken into a handful of recognisable families such as knapsack, unbounded knapsack, longest common subsequence and palindromic subsequence, rather than presented as a bag of clever tricks. It is the topic most candidates give up on, which is exactly why learning it pays.

Seventy five questions chosen for coverage rather than volume, each mapped back to the pattern it belongs to. This is the list to work when you have four weeks and cannot afford to wander.

Walks through classic object oriented design problems such as a parking lot, a library system and a card game, showing how to go from a vague prompt to class diagrams and working interfaces. Covers the round that candidates most often prepare for last and fail first.