Software Engineering Practices
Design, test, refactor, review, estimate and run software the way professional teams do.
Leads to: Software Developer, Mobile Developer, Back-End Developer, QA / Test Engineer
Before you start
This course builds on Back-End Web APIs, Data Structures & Algorithms and Git & the Command Line. Take them first if you are new to the topic.
About this course
A mid-level course for learners who can already build a back-end API, use common data structures and work with Git, and now want the habits that make software maintainable in a team. The design module covers single responsibility and DRY (and when not to apply them), the strategy and adapter patterns, and a repeatable process for sketching a scalable web service. The quality module goes deeper on unit tests with stubs, fakes and spies, safe refactoring under characterization tests, and debugging production issues from logs and stack traces. The team module covers trunk-based development and semantic versioning, code review and short design docs, and how to estimate work and talk about scope, risk and technical debt. The last module is about running software: structured logs, metrics and traces, keeping secrets and dependencies safe with free GitHub tools and CI, and handling incidents with blameless postmortems. Every lesson has a reading, free videos and a quiz; most also have a JavaScript exercise checked automatically in the browser, or a guided task you do on your own machine or a free GitHub account. Prerequisites: Back-End Web APIs, Data Structures & Algorithms, and Git & the Command Line.
Course content
Module 1
Design
3 lessons · 2h 29mApply single responsibility and DRY with judgement, use the strategy and adapter patterns, and sketch a scalable web service.
- 30mDesign principlesReading
Apply single responsibility and DRY with judgement, so code is easy to test and change.
- 1h 5mCommon design patternsReading
Use the strategy pattern to swap rules at run time and the adapter pattern to wrap an external interface.
- 54mIntro to system designReading
Sketch a scalable web service with requirements, estimates, an API, a data model and a diagram.
Module 2
Quality
3 lessons · 2h 45mWrite fast, deterministic unit tests with test doubles, refactor safely under tests, and debug production issues from logs and stack traces.
- 51mTesting in depthReading
Write fast, deterministic unit tests by injecting stubs and spies, and check that your tests catch bugs.
- 1h 7mRefactoringReading
Spot code smells and refactor in small steps while characterization tests keep behaviour the same.
- 47mDebugging production issuesReading
Turn a stack trace and logs into a hypothesis, a failing test and a fix.
Module 3
Working in a Team
3 lessons · 2h 10mIntegrate through trunk-based development and semantic versioning, review code and design docs, and communicate estimates, scope and risk.
- 26mBranching and releasesReading
Use trunk-based development with small, short-lived branches and version releases with semver.
- 50mReviews and design docsReading
Review pull requests well and write a short design doc that others can comment on before you build.
- 54mEstimates and trade-offsReading
Break work down, estimate with ranges, and communicate scope, risk and technical debt honestly.
Module 4
Running Software
3 lessons · 2h 21mAdd structured logs and metrics, handle secrets and dependencies securely, and respond to incidents with blameless postmortems.
- 41mLogging, metrics, tracingReading
Add structured JSON logs with redaction and a labelled request counter to a request handler.
- 48mSecure developmentReading
Keep secrets out of Git, keep dependencies patched, and put security checks in CI.
- 52mIncidents and postmortemsReading
Respond to an incident in clear roles, mitigate first, and write a blameless postmortem with owned action items.