Full-Stack Engineer
Frontend, backend, and everything that connects them.
- SQL fundamentalsWhat a SELECT actually does in execution order rather than in the order you type it, and why GROUP BY, HAVING, and WHERE are not interchangeable filters on the same data.
- PostgreSQL in productionWhat EXPLAIN actually says once you know where the loops divide, why VACUUM is not optional, and how a table can be 500,000 rows and still choose to scan every one of them — correctly.
- Indexes, joins, and reading a query planWhy a LEFT JOIN can return more rows than either table has, how the four join types relate as sets, and where the selectivity crossover actually sits — measured, not assumed.
- MongoDBEmbed or reference, why a document's growth pattern decides the schema more than the query pattern does, and the write-amplification bug that only appears once an array stops being small.
- Cloud fundamentals — regions, IAM, and the shared responsibility modelThe vocabulary every cloud provider assumes you already have: regions and availability zones as a blast-radius decision, IAM as default-deny, and the shared responsibility line that determines who gets paged for a breach.
- AWS — the services that show up in most stacksEC2, S3, RDS, Lambda and IAM roles as the five services almost every AWS architecture is built from, and the mental model — instance vs managed service vs event-driven function — that generalizes to any provider.
- Azure — resource groups, Entra ID, and Cloud Run's closest cousinWhat's genuinely different about Azure once you already know AWS — resource groups as a real management unit rather than a tagging convention, and Entra ID's tenant-first identity model.
- GCP — projects, IAM inheritance, and Cloud RunWhat's genuinely different about GCP once you already know AWS and Azure — the project hierarchy IAM inherits down through, and Cloud Run's per-request billing as a distinct point between Lambda and a always-on container.
- Containers — layers, caching, and what isolation actually meansA container is a process, not a VM — namespaces and cgroups instead of a hypervisor, and image layers as a cache Docker computes from, which is why Dockerfile instruction order is a real performance decision.
- CI/CD — the pipeline as the only path to productionWhy caching only helps when it's actually restored, what a deployment strategy trades off (blue-green vs rolling vs canary), and the discipline that makes a pipeline trustworthy — nothing reaches production except through it.
- How LLMs workThe mental model an engineer actually needs — next-token prediction, attention, context as the only state, and which observed behaviours follow from the architecture rather than from a bug.
- Tokens and samplingWhat temperature, top-p and top-k actually do to a probability distribution, why they interact, and why "set temperature to 0 for reproducibility" is only half true.
- PromptingWhat actually moves the needle — structure, examples, and output contracts — and how to tell a prompt problem from a retrieval problem before spending a week on the wrong one.
- Context engineeringThe context window is a budget, not a container. How to decide what goes in it, in what order, and what to do when the conversation outgrows it.
- HallucinationsWhy fabrication is a property of the training objective rather than a bug, what actually reduces it, and how to build a system that fails loudly instead of confidently.
- RAGRetrieval-augmented generation as a pipeline of separately-measurable stages — and why debugging it end-to-end is the most expensive mistake in the field.
- Tool useFunction calling as an interface design problem — why the schema is the prompt, what a tool should return, and the authorisation mistake that turns a helpful agent into a confused deputy.
- AgentsThe think-act-observe loop, the four ways it fails in production, and why the controls around the loop matter more than the model inside it.
- Rendering strategiesStatic, server-rendered, streaming, client-rendered and incrementally regenerated pages, compared on one timeline instead of by adjective — when the byte arrives, when the pixel arrives, and when the click actually works.
- ReactReact's rerender-and-diff model, measured in browser work and shipped bytes.
- VueVue's proxy-tracked updates and the dependency graph they create.
- AngularAngular's signal- and component-tree update model, with its explicit costs.
- SvelteSvelte's compile-time component updates and the runtime work they leave behind.
- AstroAstro's server-first HTML and explicit island boundaries for client work.
- Next.jsNext.js's React server/client boundary and the cost of crossing it.
- NuxtNuxt's Vue universal rendering and payload boundary between server and browser.
- State managementDecide where frontend state belongs, how it moves, and when a shared store is the wrong answer.
- Forms and validationMake forms helpful in the browser while keeping the server as the authority over accepted data.
- Web performanceTrace loading and interaction costs to measured budgets under stated network, device, and cache conditions.
- Frontend testingTest browser behavior and component contracts at the boundary where users observe the interface.
- REST APIsThe parts of REST that only bite you past the first CRUD endpoint — caching headers, content negotiation, versioning, and the hypermedia question everyone skips.
- Graph Query APIsGraphQL solves over-fetching by letting the client shape the query — which means the client now also shapes the cost, and an unbounded query is an unbounded bill.
- Validation and SerializationThe server is the trust boundary, not the browser — schema validation and serialization are where an attacker-controlled string either becomes a typed value or reaches your database as-is.
- Realtime APIsWebSockets and Server-Sent Events remove polling and hand you reconnection, backpressure, and fan-out instead — and the question that actually matters is what happens to a message sent while the client was gone.
- Authentication & AuthorizationTwo different questions bolted together in most codebases — who you are and what you can do — and what revoking access actually costs under a session, a JWT, and OAuth.
- API SecurityDefensive coverage of the vulnerabilities that actually show up in backend APIs — every recommendation stated as a threat, a mitigation, and a way to verify it holds.
- Background JobsWhat moves work out of the request path — scheduling, idempotent execution, and catching the job that fails silently instead of loudly.
- Service DecompositionWhat splitting a monolith into services actually buys, argued honestly in both directions — including the concrete conditions under which not splitting is the better call.
- Domain-Driven DesignWhy a boundary drawn around a business capability outlives one drawn around a technical layer, and how to find it by watching where the language changes.
- Repository Layout — Monorepo vs PolyrepoThe trade-off repository layout actually encodes — coupling cost against coordination cost — derived without recommending a specific build tool.