Full stack means following a feature across boundaries

A full-stack developer should be able to trace a user action from interface to API, database and operational outcome. That is a more useful goal than trying to master every language and cloud service in a tool list.

Full-stack work spans frontend, backend, databases, infrastructure and collaboration. Treat this map as a way to organise your learning, then deepen the skills your product and team need most.

Frontend: represent the real state of the system

Start with HTML semantics, layout and JavaScript. Build an interface that exposes loading, empty, success and error states. A form should remain understandable when submission fails or the user navigates with a keyboard.

Learn a component framework deeply enough to reason about state ownership and rendering. Avoid copying server data into several independent stores without a reconciliation plan. Types can document the contract; runtime validation must still check external input.

Use automated component checks where useful, but also operate the journey in a browser. Test long labels, narrow screens and focus after validation errors. See the five essential web skills for a focused foundation.

Backend: make rules authoritative

An API must decide who may perform an action and which state transitions are valid. A hidden client control is not authorisation. Structure code so validation, business rules and persistence responsibilities are understandable without jumping through unnecessary layers.

Choose one backend ecosystem and learn its request lifecycle, error handling, authentication and testing tools. REST, GraphQL and WebSockets solve different communication needs; using all three is not a maturity requirement.

For an order workflow, trace what happens if a request is repeated, a provider times out or a user requests someone else’s order. Consistent error contracts and explicit state transitions make those cases easier to test.

Databases: protect meaning as well as rows

Learn schema design, constraints, indexes and transactions before sharding. Database constraints can protect invariants even when more than one application path writes data. Investigate slow queries using a representative workload rather than assuming a new database will fix them.

An atomic transaction groups related changes, but does not make an external payment or email part of the same database commit. Decide how to record pending work and recover from partial failures. Test backup restoration into an isolated environment; a scheduled backup alone does not prove recoverability.

Operations: make the application observable and recoverable

Understand the deployment path, environment configuration, secrets handling, web-server boundary and writable directories. Automate repeatable checks and document a rollback before changing production.

Start with the hosting arrangement the product needs. Containers can help with repeatability; orchestration introduces additional operating responsibilities. Kubernetes is not a prerequisite for full-stack competence.

Log useful event identifiers and error context without recording credentials or unnecessary personal data. Monitor a meaningful health signal and a critical user journey. An HTTP 200 from a landing page does not prove the database or payment flow works.

Mobile: an optional specialisation with its own constraints

If the product includes mobile clients, learn permissions, secure storage, network recovery and platform release processes. Shared code does not replace Android and iOS testing. Keep the API contract explicit so clients can be upgraded independently.

Choose a mobile platform after checking its current support, target devices and the integrations required by the product.

Collaboration: make changes reviewable

Use Git to preserve intent and isolate changes. Explain the problem, resulting behaviour and validation in a pull request. Describe what remains untested. A useful handover allows another developer to run the project without receiving secrets in chat.

AI tools can assist with exploration and implementation. The developer remains responsible for understanding generated code, checking its dependencies and verifying its behaviour. Ask for explanations and counterexamples rather than accepting confident output as evidence.

Learn through one complete vertical slice

Build one feature end to end: an accessible form, validated endpoint, authorised database operation, failure handling and a reproducible deployment. Add a test for a real risk and document one recovery scenario. Then deepen the weakest boundary before adding more technologies.

Choosing a technology stack provides a decision process for applying this capability map to a specific product.