Software Architectures (SOLID) & Design Patterns in Java

Are you ready to take your coding skills to the next level? This course is your gateway to writing clean, maintainable, and scalable software by mastering two of the most important pillars of software architecture: SOLID principles and design patterns.

We’ll start by diving deep into the SOLID principles — five core guidelines every professional developer should know. You’ll not only learn the theory behind each principle but also see how to implement them in Java through hands-on examples.

Next, we’ll explore the world of design patterns, the time-tested solutions to common software design problems. You’ll learn how these patterns help you write flexible and reusable code — an essential skill as software systems become increasingly complex.

Section 1 - SOLID Principles

• what are SOLID principles?

• single responsibility principle

• open closed principle

• Liskov's substitution principle

• interface segregation principle

• dependency inversion principle

• what is dependency injection?

Section 3 - Creational Design Patterns

• what are creational design patterns?

• singleton pattern

• factory pattern

• abstract factory pattern

• builder pattern

• prototype pattern

Section 2 - Behavioral Design Patterns

• what are behavioral design patterns?

• strategy pattern

• observer pattern

• command pattern

• iterator pattern

• template pattern and null object pattern

• visitor pattern

Section 3 - Structural Design Patterns

• what are structural design patterns?

• decorator pattern

• flyweight pattern

• facade pattern

• adapter pattern

• composite pattern

• bridge pattern

Section 4 - API Design

• SOAP

• RPC

• REST

Section 5 - Software Architectures

• monolithic architecture

• layered (n-tier) architecture

• service oriented architecture (SOA)

• micorservice architecture

Section 6 - Data Storage Design

• relational databases

• non-relational databases

• scaling relational and non-relational databases

• replication and sharding

• CAP theorem

While the implementation will be in Java, the concepts are language-agnostic and valuable to any developer, regardless of your tech stack.

This is a practical course — I strongly encourage you to code along and re-implement the examples yourself. This is the best way to build a strong foundation and internalize the patterns and principles we’ll cover.

Whether you're a junior developer looking to build solid habits or an experienced programmer aiming to sharpen your design skills, this course is for you.

Thanks for joining — now let’s dive in and level up your software design skills!