Raj P.
Sample Migration planning lesson is excellent
Parallel running and rollback points made our table migration far calmer than the last one.
Technical decisions at scale: RFCs, ADRs and team alignment
Make, document and communicate technical decisions across teams with design docs, architecture decision records and clear decision rights
Created by Samuel Mensah
- Updated September 2026
- English
- Advanced
What you will learn
- Classify technical decisions by reversibility and impact
- Define decision rights with a simple framework
- Write clear architecture decision records
- Write RFCs and design documents that invite useful review
- Compare options with explicit trade offs, spikes and cost estimates
- Build alignment and handle disagreement without endless debate
- Write a technical strategy and plan large migrations
Course content
Why technical decisions go wrong
RFCs and design documents
- Article: When to write an RFC 8 min
- Article: Structure of a strong design document 11 min
- Article: Alternatives considered 9 min
- Article: Running the review 10 min
Evaluating options
- Article: Trade off matrices 10 min
- Article: Spikes and prototypes 9 min
- Article: Cost and operational considerations 9 min
- Article: Build, buy or adopt open source 9 min
Building alignment
- Article: Pre alignment before formal review 9 min
- Article: Handling disagreement 10 min
- Article: Architecture forums and review groups 8 min
- Article: Communicating decisions 8 min
Technical strategy and migrations
- Article: Writing a technical strategy 11 min
- Article: Technology radar and standards 8 min
- Article: Planning large migrations 11 min
- Article: Measuring whether decisions worked 8 min
Keeping decisions healthy
- Article: Decision logs across teams 8 min
- Article: Revisiting decisions 8 min
- Quiz: Final check 6 min
Requirements
- Several years of software engineering experience
- Familiarity with architecture concepts such as services, databases and messaging
- Experience working across more than one team
Description
As engineering organisations grow, the hardest problems are rarely purely technical. They are about making good decisions together: choosing a database that five teams will live with, agreeing a migration plan, deciding whether to build or buy. Poor decision processes lead to endless debates, decisions made by whoever argues longest and architectures nobody can explain a year later.
What you will learn
This course gives staff engineers, tech leads and engineering managers a toolkit for technical decisions that scale beyond a single team.
- Classifying decisions by reversibility and impact
- Clarifying who decides, who is consulted and who is informed
- Writing architecture decision records that capture context and consequences
- Writing RFCs and design documents that reviewers can engage with
- Evaluating options with trade off matrices, spikes and cost estimates
- Building alignment before reviews and handling disagreement constructively
- Writing a technical strategy and running large migrations
- Revisiting decisions when circumstances change
Case study
We follow a growing company that must decide how to split a monolith that several teams contribute to, choose a messaging system for new services and plan a database migration. You will write an ADR, an RFC and a short strategy document, with templates and worked examples.
Who it is for
This is an advanced course for senior and staff engineers, architects, tech leads and engineering managers who influence decisions across several teams. You should be comfortable with software architecture concepts such as services, databases and messaging. The course focuses on process and communication rather than any specific technology.
Who this course is for
- Senior and staff engineers who lead cross team technical work
- Tech leads and architects
- Engineering managers responsible for technical direction
Instructor
Samuel Mensah
Engineering manager teaching practical leadership for engineers who now lead people
- 4.4 instructor rating
- 22 reviews
- 8,440 students
- 3 courses
- Sample
I was a backend engineer for years before moving into engineering management, and I still remember how unprepared I felt in my first month. Since then I have managed teams, managed other managers and helped many engineers make the same transition.
I teach leadership as a set of learnable habits: one on ones, feedback, delegation, hiring loops, technical decision records and running a team rhythm that protects focus. I try to be specific. Instead of abstract principles you get scripts, agendas and templates, plus the reasoning behind them.
My courses are for new managers, tech leads and senior engineers who want to grow their influence without losing touch with the work.
Student reviews
Henrik B.
Sample ADRs changed our engineering culture
We started writing ADRs after this course. Six months later, onboarding engineers read them first and ask far better questions.
Nadia F.
Sample Decision rights saved weeks
Naming one approver for our platform decision ended a debate that had run for two months.
Sophie M.
Sample Good balance of process and people
Pre alignment before reviews made our architecture forum much less tense.
Oluwaseun B.
Sample Strong on RFC structure
The alternatives considered lesson improved every design doc I have written since. Wanted more examples from very large companies.
Marcus L.
Sample Thoughtful and practical
The reversible versus irreversible matrix is now the first thing we discuss for any proposal.
Elisa G.
Sample Advanced in the best way
Valuable if you lead cross team work. Less useful if you mostly work within one team.
Keep exploring
All Tech Leadership courses
More in Tech Leadership
$89.99
Enroll now