Purpose
These learning paths provide a structured progression through engineering fundamentals, from foundational concepts to advanced practice.
Each path is designed to develop engineering judgement, not just technical knowledge. The goal is to produce engineers who can make sound design decisions, not just write working code.
Beginner Path
Objective
Build a solid understanding of core engineering principles and apply them in everyday work.
Prerequisites
- Some experience writing code in any language.
- Familiarity with basic development workflows (version control, testing, deployment).
Topics
-
Separation of Concerns
- Core concept and why it matters.
- Identifying mixed responsibilities in existing code.
- Practice: Refactor a monolithic function into focused modules.
- Reference: Engineering Fundamentals Handbook
-
Code Organization
- Feature-based vs layer-based organization.
- Module boundaries and responsibilities.
- Practice: Restructure a small project by feature.
- Reference: Code Organization Guide
-
Basic Testing
- Test pyramid and where to focus.
- Writing unit tests for isolated logic.
- Practice: Add tests to an untested module.
- Reference: Testing Strategies Guide
-
Error Handling
- Distinguishing recoverable and unrecoverable errors.
- Writing meaningful error messages.
- Practice: Audit and improve error handling in a service.
- Reference: Error Handling Guide
-
Code Review Fundamentals
- Reviewing for correctness, design and maintainability.
- Writing constructive review feedback.
- Practice: Review a pull request using the code review checklist.
- Reference: Code Review Playbook
Suggested Projects
- Refactor a small existing project to improve separation of concerns.
- Add comprehensive error handling and logging to a service.
- Build a simple feature with tests following the test pyramid.
Assessment
Demonstrate by: Successfully reviewing a peer's pull request with meaningful feedback on design, not just style.
Intermediate Path
Objective
Make consistent design decisions, manage complexity and contribute to architecture discussions.
Prerequisites
- Completed Beginner Path or equivalent experience.
- Comfortable with testing and code review practices.
Topics
-
Coupling and Cohesion
- Measuring and evaluating coupling.
- Improving cohesion through module design.
- Practice: Analyse coupling in an existing system and propose improvements.
- Reference: Engineering Glossary
-
Dependency Management
- Dependency inversion principle.
- Dependency injection patterns.
- Practice: Refactor a tightly coupled module to use dependency injection.
- Reference: Engineering Fundamentals Handbook
-
Technical Debt Management
- Strategic vs accidental debt.
- Assessment and prioritization.
- Practice: Conduct a technical debt assessment on a code area.
- Reference: Tech Debt Assessment Checklist
-
Logging and Observability
- Structured logging standards.
- Log levels and context.
- Practice: Add structured logging to a service and verify in development.
- Reference: Logging Guide
-
Architecture Awareness
- Understanding architectural patterns (layered, hexagonal).
- How engineering decisions affect architecture.
- Practice: Document the architecture of an existing system using C4 Level 1-2.
- Reference: Software Architecture Handbook
Suggested Projects
- Identify and document technical debt in a team codebase.
- Propose and implement a refactoring that improves coupling.
- Write an ADR for a significant design decision.
Assessment
Demonstrate by: Leading a code review that catches design-level issues. Contributing to an architecture review with meaningful observations.
Advanced Path
Objective
Shape engineering strategy, influence organizational practices and mentor other engineers.
Prerequisites
- Completed Intermediate Path or equivalent experience.
- Experience leading medium-to-large features or projects.
Topics
-
System Design and Trade-offs
- Quality attribute trade-off analysis.
- Architectural decision documentation.
- Practice: Evaluate two architectural approaches and document the trade-offs in an ADR.
- Reference: Architectural Patterns Guide
-
Engineering Strategy
- Defining engineering standards for a team or organization.
- Balancing velocity, quality and innovation.
- Practice: Draft an engineering standard for a capability.
- Reference: Engineering Fundamentals Handbook
-
Mentoring and Review
- Reviewing for engineering growth, not just code correctness.
- Providing feedback that builds judgement.
- Practice: Mentor a junior engineer through a code review cycle.
- Reference: Code Review Playbook
-
Cross-Capability Integration
- How engineering principles intersect with architecture, security and testing.
- Building shared standards across capabilities.
- Practice: Identify a cross-cutting concern and propose a standard that spans multiple capabilities.
-
AI-Assisted Engineering
- Using AI for code review, design exploration and documentation.
- Maintaining engineering judgement alongside AI assistance.
- Practice: Conduct a code review with AI assistance and evaluate the AI's suggestions.
- Reference: AI Workflows for Engineering
Suggested Projects
- Define a team engineering standard and drive its adoption.
- Lead an architecture review for a cross-team initiative.
- Establish an ADR practice for a team or project.
Assessment
Demonstrate by: Influencing engineering practices beyond your immediate team. Mentoring others in engineering fundamentals. Contributing to the engineering knowledge framework.