Sefism Software Design and Clean Code Roadmap

What this roadmap is

Software design and clean code is Sefism's ten-stage roadmap for students and early-career engineers who can make code work in Java, Python, TypeScript or C#, and now want it to stay easy to read, test and change. It covers object-oriented programming used properly, SOLID, clean code, all 23 classic design patterns, the UML you actually draw, refactoring, designing small systems end to end, and code review.

By the end you should be able to:

• model a problem with classes that protect their own rules, prefer composition over inheritance, and explain each choice in plain words
• spot SOLID violations and code smells in your own and other people's code, and fix them with named refactorings in small steps behind tests
• recognise when each of the 23 Gang of Four patterns fits, write it in your language, and say when a plain function is the better answer
• take a small system such as a parking lot, a rate limiter or an expense splitter from requirements to a class diagram and working, tested code
• give code review comments people act on, and turn the comments you receive into a checklist that improves every change you send

Who it suits, and who should start elsewhere

It suits students who have finished a first programming course and an OOP course, junior developers whose pull requests keep coming back with the same comments, and anyone preparing for a low level design round, where you are asked to turn a short brief into classes and code.

If you cannot yet write a few hundred lines without a tutorial, do Programming foundations first; its fifth stage is a lighter first pass at the same ideas. If you want the subject as your degree teaches it, with operating systems and networks alongside, see CS core subjects.

Editions, prerequisites and time

You pick a language: Java (the default), Python, TypeScript or C#. The stages are the same, while the modern language features, pattern references and IDE recommendations follow your choice. In Java, for example, stage 1 teaches records, sealed types and interfaces; in Python, dataclasses, Protocol and properties; in TypeScript, structural types; in C#, records and primary constructors.

The estimate is about 112 hours across 10 stages:

• A student with 10 to 12 hours a week finishes in roughly 13 weeks, about a semester. Write every pattern and refactoring yourself; reading them is not the same skill.
• Someone working full time with about 5 hours a week should plan for around 26 weeks. The good news is that your day job supplies the material: every pull request you send or review is practice for stages 3, 8 and 10.

Stage by stage

1. Object-oriented programming properly (14 hours)

Classes, objects and responsibilities, encapsulation and invariants, abstraction and interfaces, inheritance used sparingly, polymorphism instead of type checks, composition over inheritance, optional value objects and immutability, and your language's modern OOP features. Milestone: a small domain model from a one-paragraph brief, with private state, an interface with two implementations, no type switches and unit tests for its rules. A getter and setter pair for every field protects nothing.

2. SOLID with before and after code (12 hours)

Single responsibility, open/closed, Liskov substitution, interface segregation, dependency inversion, dependency injection in practice, and DRY, KISS and YAGNI as counterweights. Milestone: a messy module such as order checkout refactored in separate commits, one per principle, with unit tests using fakes. Learn each principle by the smell it prevents.

3. Clean code: naming, functions and errors (10 hours)

Names that explain themselves, small functions, arguments, flags and side effects, comments that explain why, guard clauses, error handling that fails loudly, the Law of Demeter (optional), and style guides, formatters and linters. Milestone: an old project cleaned up with a formatter and linter in CI, no flag arguments, specific exceptions, and a list of the ten changes you made and why.

4. Creational patterns (8 hours)

What a pattern is and is not, then Singleton (and why to be careful), Factory Method, Abstract Factory, Builder and Prototype. Milestone: all five written from memory in your language, with one realistic use and one sentence on when not to use each. You will use Builder and factories most, and write your own Singleton almost never.

5. Structural patterns (10 hours)

Adapter, Bridge, Composite, Decorator, Facade, Flyweight and Proxy. Milestone: a comparison of Adapter, Bridge, Decorator and Proxy with code for each, plus a Composite model and a caching Proxy with tests. Those four look nearly identical in code, so learn them by intent, not by shape.

6. Behavioural patterns (14 hours)

Strategy, Observer and events, Command and Memento, State and state machines, Template Method, Iterator, Chain of Responsibility and middleware, Mediator, and Visitor and Interpreter. Milestone: a small project using at least four behavioural patterns for real reasons, such as an order workflow with State, pricing with Strategy, notifications with Observer and undoable actions with Command.

7. UML and class diagrams you actually need (6 hours)

Class diagrams, the five relationship arrows, multiplicity and navigability, sequence diagrams, optional state and use case diagrams, and diagrams as code with PlantUML and Mermaid. Milestone: a class diagram and a sequence diagram for a project you built, in Mermaid or PlantUML in its repository, plus a state diagram for its most important object.

8. Refactoring and code smells (12 hours)

What refactoring is and is not, recognising smells, going from a smell to a named refactoring, characterisation tests, automated refactoring in your IDE, and the Gilded Rose kata. Milestone: the kata completed with characterisation tests, the new item type added, and a commit history of small steps, each naming the refactoring it applied. The advice is to do the kata twice, a month apart.

9. Designing small systems end to end (20 hours)

The largest stage: a repeatable method for low level design, finding entities and responsibilities, four case studies (parking lot, library management, rate limiter, expense sharing), thread safety in small designs, and presenting and defending a design. Milestone: three small systems designed and built with written requirements, a class diagram, working tested code and a list of trade-offs. Build every design; code shows the flaws a diagram hides.

10. Code review: giving and taking it (6 hours)

What to look for and in what order, approving when a change improves the code, writing comments people act on, sending small changes, receiving feedback, and reviewing others' code to learn. Milestone: five review comments written with Conventional Comments on real pull requests, plus your personal checklist of the comments you receive most often.

Projects that fit

• Receipt-scanning expense splitter: the stage 9 expense design as a real app, with split strategies and exact money
• Approval workflow engine with escalations for small offices: State, Strategy, Observer and Chain of Responsibility in one system
• Interpreter and type checker for a small language: Interpreter, Visitor and Composite at full size
• Peer code review platform for university courses: the code review stage turned into a product

How it works on Sefism

Everything on Sefism is free to learn from. The public page at Software design and clean code shows the full stage list for your chosen language, with the first two stages open: their topics, milestones and recommended material. Later stages show their title, summary, hours and topic count.

To open every stage, add the roadmap to your dashboard. Adding a roadmap uses credits, new members get starting credits when they join, and your first roadmap is free. Once it is on your dashboard you can:

• open every stage, its topics, checks and recommended material
• tick stages off and track your progress, at a pace set by the hours you have each week
• keep the companion Software design and clean code cheat sheet, which comes with the roadmap
• ask Tauseef a question about any stage, or book a 1:1 session if you want to talk your plan through

If you are new, create a free account first. Credits are there so the platform goes to people who are actually learning, and if you run out while learning seriously, you can ask for more.

The companion cheat sheet

The Software design and clean code cheat sheet has one chapter per stage, all 23 patterns included, with a short sketch in your language for each idea. Use it to revise a pattern before you reach for it, and to name the smell in a review comment.

Related on Sefism

• How to learn low level design and design patterns
• How to learn to write clean code as a junior developer
• How to give code review feedback without creating conflict
• Six rules that keep a codebase worth working in
• Refactoring.Guru: Design Patterns, the Gilded Rose Refactoring Kata and Conventional Comments, all used in the stages
• Grokking SOLID Design Principles and Grokking Design Patterns for Engineers and Managers, recommended for stages 2 and 4 to 6

What you can do afterwards

Write code that other people can change without fear: classes with clear responsibilities, patterns used where they earn their place, refactoring done in small tested steps, and designs you can draw, build and defend. Your review comments get shorter because you have names for what you see.

Frequently asked questions

Do I need to learn all 23 design patterns? Learn Strategy, Observer, Command and State until you can write them without thinking; the roadmap says those cover most of your working life. Learn the rest well enough to recognise them in frameworks and reviews.

Is SOLID still relevant in 2026? As questions to ask of a design, yes. The roadmap teaches it with before and after code and balances it with DRY, KISS and YAGNI, so you do not add abstractions nobody needs.

How long does it take to learn software design? About 112 hours on this roadmap: roughly 13 weeks at 10 to 12 hours a week, or 26 at 5. The habits keep improving long after, through code review.

Which language edition should I choose? The language you write most. Java is the default, and Python, TypeScript and C# each get their own modern idioms, pattern references and IDE recommendations.