Catalog My learning Blog
Full-Stack Developer Course: React, .NET and SQL Server · Phase 15 · Lesson 150 · 7 min read

Senior Full-Stack Developer Roadmap

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: A Skills Self-Assessment, a 12-Month Plan and a First-90-Days Checklist
  4. Real-World Examples
  5. Review Questions & Answers

Learning Objective

Assess your skills across the 150 days, choose a growth direction, build a portfolio and learning system that keeps you current, understand the paths beyond senior engineer, and hold yourself to professional standards for security, privacy and accessibility.

Concept Explanation

You started as a frontend developer and can now build, secure, deploy, and operate a system across React, ASP.NET Core, SQL Server, and Azure, and can design one on a whiteboard. The next stage is choosing where to go deeper, since nobody stays current on everything. The useful image is a T-shaped engineer: broad competence across the stack, with one or two areas of real depth. The 150 days point to several deep directions. Backend and data depth means distributed systems, database internals, and performance. Platform and reliability means Kubernetes, infrastructure as code, observability, and incident leadership. Security engineering means threat modeling, identity, cryptography, and secure design reviews. Frontend depth means performance, accessibility, design systems, and complex state. AI engineering means retrieval, evaluation, and safe integration of models. Choose by what energizes you and what your product needs, and revisit the choice yearly.

Careers branch after senior engineer. The individual contributor track continues to staff and principal levels, where the work becomes setting technical direction, resolving ambiguity, and multiplying other engineers. Will Larson's book Staff Engineer describes four common archetypes: the tech lead who guides a team, the architect who owns a technical area, the solver who is pointed at the hardest problems, and the right hand who extends a leader's reach. The management track trades hands-on work for growing people and running a team. Both paths require skills that this course touched on in Days 146 and 147: written communication, review, estimation, and influence without authority. Try leading a project or mentoring before deciding, and know that moving between tracks is normal.

Staying current is a discipline. The platform moves on a predictable calendar: .NET ships a release every November, with long-term support releases in even-numbered years and shorter support for the odd ones, so plan upgrades before support ends, as you saw with Azure Functions on Day 140. Follow the release notes and roadmaps of your stack, security advisories for your dependencies, the OWASP projects, and a small number of trusted writers, instead of a flood. Learn by building, not only reading: keep a side project or a lab environment, and practice the skills that decay, such as restoring from a backup and rotating a secret. Teach what you learn through internal talks or writing, since explaining exposes gaps. Read source code and postmortems, which are the best free education in how real systems fail. The Pragmatic Programmer, published in 1999, called this maintaining a knowledge portfolio, investing regularly and diversifying like a financial one.

Professional responsibility runs under everything. Software touches people's money, health, privacy, and work, and the choices you make about security, data collection, accessibility, and how you use models have consequences for people who never see your code. Build security in as a default, collect the minimum, make products usable by everyone, be honest about what a system can and cannot do, and speak up when you see something unsafe, using the postmortem culture of blamelessness for others and accountability for yourself. Report vulnerabilities responsibly through the channels a security.txt file describes and never test systems you have no permission to test. Take care of yourself, too: sustainable pace, sleep, and boundaries make better engineers than heroics, and the profession lasts decades. Set goals in concrete terms, review them quarterly, and ask for feedback often.

DirectionWhat to study nextA first project
Backend and dataDistributed systems, database internals, performanceBuild a small event-sourced service with projections and load tests
Platform and reliabilityKubernetes, Bicep or Terraform, observability, SRE practiceRun a game day for your own project and publish the postmortem
SecurityThreat modeling, identity protocols, cryptography basics, secure reviewThreat model an open source project and report a finding responsibly
Frontend depthWeb performance, accessibility, design systemsAudit a real site for accessibility and fix the top issues
AI engineeringRetrieval, evaluation, safe tool useBuild an assistant with permission-aware retrieval and an adversarial test suite
LeadershipWriting, mentoring, planning, influencingLead a design review and write the design document and ADRs

Worked Example: A Skills Self-Assessment, a 12-Month Plan and a First-90-Days Checklist

The data structure lets you score yourself honestly, the plan turns it into quarterly goals, and the checklist helps in a new role.

Shell
// skills.ts: score each 0 to 4 (0 = never used, 2 = can do with documentation, 4 = could teach it and review others' work).
// Be honest. The gaps are the plan.
export const skills = {
  'C# and ASP.NET Core APIs':               3,
  'SQL Server, EF Core and performance':    2,
  'React, state and performance':           4,
  'Authentication, authorization, OIDC':    2,
  'Threat modeling and secure review':      2,
  'Testing (unit, integration, contract)':  3,
  'Docker, CI/CD, Azure and Bicep':         2,
  'Observability, SLOs and incident work':  1,
  'Distributed systems and messaging':      1,
  'System design and written communication':2,
} as const;

const gaps = Object.entries(skills).filter(([, score]) => score <= 2).sort((a, b) => a[1] - b[1]).map(([name]) => name);
console.log('Focus areas for the next quarter:', gaps.slice(0, 3));
Code
## 12-month plan (review every quarter, keep it to three goals at a time)
| Quarter | Goal | Evidence at the end |
|---|---|---|
| Q1 | Observability and incident skills: define SLOs for one service, run a game day | SLO document, alert history, a published postmortem |
| Q2 | Deepen SQL Server performance and distributed systems: read one book, build the event-sourced project | Benchmarks in a repository, an ADR explaining a trade-off |
| Q3 | Security depth: complete a threat model of a real system and one responsible disclosure or bug fix | Threat model document, a merged fix or accepted report |
| Q4 | Lead a design and its rollout end to end, mentor one person | Design doc, ADRs, rollout and retrospective notes |

Habits: two hours weekly for deliberate practice, one written piece per month (a blog post or internal doc),
one postmortem or open-source codebase read per month, an annual review of this plan with a mentor.
Code
## First 90 days in a new full-stack role
Days 1 to 30: learn. Run the system locally, read the ADRs and last three postmortems, fix small bugs, ask why things are built this way.
  Find the on-call runbooks and the security contacts. Do not change anything you do not yet understand.
Days 31 to 60: contribute. Own a small feature end to end with tests and a rollout plan. Improve one thing in the developer experience.
  Give and receive code review. Write down the questions the docs did not answer, then fix the docs.
Days 61 to 90: lead a slice. Propose a change with a design doc and an ADR. Take part in an incident review or game day.
  Agree goals with your manager and record the feedback you asked for.
Throughout: report anything unsafe you notice (secrets in a repository, missing authorization, unpatched systems) to the right person the same day.

Put your capstone repositories, design documents, and postmortems somewhere you can point to. Evidence of judgment, such as a written trade-off, a threat model, or a recovered incident, persuades more than a list of technologies.

You have a broad full-stack base. Pick one or two areas for depth, set three quarterly goals with visible evidence, and build in public with design documents, postmortems and fixes. Stay current through release calendars and advisories, lead small projects, choose a path, and practice responsibly.
You have a broad full-stack base. Pick one or two areas for depth, set three quarterly goals with visible evidence, and build in public with design documents, postmortems and fixes. Stay current through release calendars and advisories, lead small projects, choose a path, and practice responsibly.

Real-World Examples

  • Microsoft has shipped a new major version of .NET every November since .NET 5 in 2020, with even-numbered releases receiving long-term support and odd-numbered releases shorter support. Teams that track the calendar plan upgrades a year ahead, while teams that ignore it find themselves running unsupported runtimes, as many did with older .NET Framework and AngularJS versions.
  • Will Larson's 2021 book Staff Engineer collected interviews with engineers at many companies and described the common archetypes of the role, showing that senior individual contributor careers take several shapes beyond writing more code. It gave engineers vocabulary for career conversations that were previously vague.
Key TakeawaysAssess your skills honestly, then pick one or two directions for depth on top of your broad full-stack foundation. Turn them into quarterly goals with visible evidence. Stay current through release calendars, advisories, source and postmortem reading, and projects that keep perishable skills sharp, choose between staff and management paths by trying the work, and carry professional responsibility for security, privacy, accessibility, and honesty in everything you ship.

Review Questions & Answers

It means broad competence across the full stack combined with real depth in one or two areas. The breadth lets you collaborate and design across boundaries, and the depth makes you the person others consult on hard problems.

Each version has a support end date after which it receives no security patches, and upgrades take planning across dependencies and infrastructure. Tracking the calendar lets you upgrade on your schedule and not during an emergency.

Evidence, such as a design document, a published postmortem, or a merged fix, shows that you applied the skill and gives you something to point to. It also keeps the plan honest, since reading alone can feel like progress without producing capability.

It means building security and privacy in by default, making products accessible, being honest about limitations, reporting unsafe conditions, and testing only what you are authorized to test. The consequences of software reach people who never see the code.