CS404BKK
Design of Software Systems

Faculty
Anton Topchii
Senior Backend Developer at Byrd
Course length
Duration
Total hours
Credits
Language
Course type
Fee for single course
Fee for degree students
Skills you’ll learn
Overview
This course introduces the fundamental principles of software system design through the development of modern web applications using Python and Django. Students learn how to transform functional requirements into maintainable software architectures, model application domains, organise code into cohesive components, and evaluate design decisions using established software engineering principles.
The course combines object-oriented design, SOLID principles, common design patterns, database modelling, web architecture, automated testing, and application security. Django serves as the primary practical framework, allowing students to apply these concepts in a complete web application that includes business logic, persistence, an administrative interface, user-facing views, and a REST API.
Learning highlights
- Analyse software requirements and identify domain entities, relationships, and use cases.
- Design modular software systems with clear responsibilities and boundaries.
- Apply SOLID principles and evaluate coupling and cohesion in existing code.
- Select and implement appropriate software design patterns.
- Build full-stack web applications using Python and Django.
- Acquaintance with SQL databases.
- Design relational data models and implement them with Django ORM.
- Separate presentation, business, and persistence concerns.
- Design and implement RESTful APIs.
- Distinct and write unit, integration, and functional tests.
- Review and refactor code based on software quality principles.
- Identify common web security risks and apply defensive practices.
- Document architectural and implementation decisions.
- Prepare a Django application for deployment in a production environment.
- Present and justify the design of a software system.
Course outline
15 classes
Session 1
Introduction to Software System Design
Session 2
Software development lifecycle. Analysing requirements.
Session 3
Django Architecture and Project Structure
Session 4
Relational Data Modelling and Django ORM, UML modelling
Session 5
Full-Stack web service implementation
Session 6
Object-oriented design and SOLID Principles, Coupling, and Cohesion
Session 7
Design Patterns in Python and Django
Session 8
Business Logic and Application Services
Session 9
Django on scale. Design Instagram.
Session 10
Design patterns, anti-patterns & software quality
Session 11
Automated Testing
Session 12
Django REST framework
Session 13
Network communication for design of software systems
Session 14
Production Readiness and Deployment
Session 15
Final exam
Prerequisites
Students are expected to have successfully completed:
- Intro to programming: Python (modules 1-3) (or similar)
- Software Engineering (or similar)
Students should already be comfortable with:
- Python syntax and standard data structures
- Basic use of Git
Methodology
The course represents a total student workload of 180 hours, distributed as follows:
* 45 hours of contact teaching: 15 three-hour classroom sessions combining lectures, guided practice, and project work.
* 15 hours of office hours with the lecturer: individual consultations, project feedback, technical support, and discussion of architectural decisions.
* 60 hours of independent project work: design, implementation, testing, documentation, and preparation of the individual Django project.
* 60 hours of independent study and preparation: assigned reading, study of technical documentation, short practical exercises, preparation for classroom sessions, revision of course concepts, and preparation of project demonstrations and presentations.
Each three-hour classroom session combines a short theoretical lecture with practical work. A typical session includes:
* Short lecture and discussion: introduction of software design concepts, architectural principles, and practical examples.
* Guided practice: focused programming exercises, design tasks, code analysis, refactoring, or live implementation.
* Individual project work: application of the introduced concepts to the student’s own Django project.
* Review and reflection: code review, architectural discussion, testing, demonstration, and feedback.
Students develop one individual software project throughout the course. The project is implemented incrementally during three five-day micro-sprints. Each sprint introduces a new group of software design concepts and concludes with a working project milestone, a short demonstration, and a review of the student’s implementation and architectural decisions.
Office hours provide students with an opportunity to discuss project scope, resolve technical difficulties, receive individual feedback, and review proposed design decisions. Independent study supports the classroom activities through selected readings, documentation research, practical exercises, and preparation for subsequent project milestones.
Grading
Apply for this course
Design of Software Systems
by Anton Topchii
Total hours
45 Hours
Dates
Oct 19 - Nov 06, 2026
Fee for single course
€1500
Fee for degree students
€750
How to secure your spot
Complete the form below to kickstart your application
Schedule your Harbour.Space interview
If successful, get ready to join us on campus
FAQ
