Curriculum Overview_


201 Brownfields Software Development ​


Most software development jobs entail programming in an existing codebase. This kind of
programming is known as brownfields development. Furthermore, software developers work in
teams. This module, therefore, focuses on how to work on an existing codebase as a team.
Students work exclusively in the team for the entire module and rotate through at least two
different code bases. We also introduce other technologies, practices and techniques expected
of software developers in the workplace.

By the end of this module, students:

  • Have worked in a team using agile principles and practices;

  • Have analysed a codebase to understand its technical debt and quality;

  • Have continually practised refactoring an existing code base to improve its quality and repay the technical debt;

  • Will be able to apply trunk-based development for effective management of git repositories;

  • Can write unit tests, acceptance tests and integration tests;

  • Will have implemented a build pipeline for continuous integration and delivery;

  • Know how to secure credentials for configurations;

  • Programmed persistence with SQL based relational databases and an object-relational mapper;

  • Will have learned how to recognise commonly encountered problems and solve these using design patterns;

  • Will have written a mobile application;

  • Understand coupling and cohesion in software design and architecture.


  • Automated Testing: Write unit tests, acceptance tests and integration tests.

  • Persistence: Use a relational database and SQL to store and retrieve data.

  • Mobile Development: Develop a mobile application against an existing back-end

  • Code Analysis: Analyse a codebase to establish its technical debt and code quality

  • Refactoring: Refactor existing code to improve its quality and design by applying TDD.

  • Design Patterns: Apply patterns to enhance the structure at the code level.

  • Fundamentals of Software Architecture: Understand coupling and cohesion.


  • DevOps: Create build pipelines for continuous integration and continuous delivery, including automated testing and deployment with Docker.

  • Effective Version Control: Use trunk-based development techniques to maintain a stable main branch of the codebase.

  • Secrets Management: Use PGP to store and access credentials used in production environments securely.


  • Showcases: Every iteration ends with a showcase. Students prepare and present their work for that iteration to mentors and staff.

  • Technical Documentation: Illustrate the architecture and design of the system under
    development, from component level down to modules and classes.

Team Work


  • Planning: Students are given goals for each iteration and plan, estimate and prioritise

  • their work to achieve the iteration goals.

  • Taskboard: Use a task board to manage the backlog of work, track work progress, and keep the board up to date via daily stand-ups.

  • Retrospectives: Reflect on the iteration and identify and implement improvements in the way the team works.

  • Pairing: Practice pair programming to increase shared understanding and quality of the code.

202 Distributed Systems Architecture

We continue with team-based software development and focus on the architecture for
distributed systems and their implementation on cloud platforms.

By the end of this module, students:

  • Will have worked in a multi-team environment using agile principles and practices;

  • Understand and implement the fundamentals of distributed systems architecture;

  • Will have built a system with cloud technologies;

  • Will have written secure code based on the OWASP top 10 code vulnerabilities;

  • Will have programmatically provisioned the infrastructure for a cloud-based system;

  • Will have written a web application;

  • Will be familiar with asynchronous programming;

  • Understand and can apply Domain Driven Design patterns and techniques;

  • Will have written code for load and stress tests; and

  • Are familiar with the design of an API.


  • Decomposition: Design discrete, single responsibility services that collaborate with
    other services in a distributed system.

  • Security: Write code that protects against common security vulnerabilities.

  • API Design: Design and implement an API for services.

  • Web development: Build web applications that use multiple API’s.

  • Asynchronous programming: Write code that executes in a predominantly asynchronous fashion; and the automated testing thereof.

  • Domain-Driven Design: Apply DDD patterns at the code level and the systems level.


  • Infrastructure as Code: Programmatically provision the infrastructure for the system under development, being a critical DevOps technique.

  • Load Testing: Create and execute tests that stress the load and performance of a system.

  • Cloud-Native: Design and deploy a distributed system on a cloud platform.


  • Business Analysis: Learn and apply effective business analysis techniques to communicate requirements precisely.

  • Architecture: Create and present architecture slide decks for the system under

  • development.

  • Technical Documentation: Document the API for use by other developers.

Team Work


Continuous Flow: Students transition from time-boxed iterations to practising continuous delivery.
Multi-team collaboration: Manage dependencies between teams and communicate between teams.