Software design Includes system architecture (e.g.
, client–
server, layered architecture)
Example:
Software design is the process of
planning how a software system will work A school management system might
before actually writing the code. have modules like:
Think of it as creating the blueprint for a Student management
building—developers follow this blueprint
Teacher management
to build the actual software.
Payments
Results processing
It answers questions like:
What will the software do?
Low-Level Design (LLD)
How will the components interact?
What data is needed?
Focus: Details inside each module
What is the structure of the system?
Class diagrams
Function definitions
Goals of Software Design
Database table structures
Good software design aims to make
software that is: Algorithms
Correct – does what it is supposed to do Example:
Efficient – uses memory and CPU well In the student module:
Maintainable – easy to modify or fix Class: Student
Reusable – parts can be used in other Functions: register(), updateRecord(),
projects calculateAverage()
Scalable – can grow without breaking
Interface Design
1. Levels of Software Design Focus: How users interact with the
system
There are three main levels:
User Interface (UI) design
User Experience (UX)
High-Level Design (HLD) – System Design
Layout arrangements
Focus: The big picture
Navigation flow
Defines major components or modules
Example:
Shows how modules interact
Login page
Dashboard Structured Design
Buttons, forms, menu structures Uses Data Flow Diagrams (DFD)
Breaks system into smaller functions
Software Design Principles Object-Oriented Design (OOD)
Uses objects, classes, inheritance,
polymorphism
These are rules that help create good
designs. Component-Based Design
Builds systems from reusable
components
Popular Principles
Model-Driven Design
Uses UML diagrams to model the system
1. SOLID Principles
Single Responsibility – each class should
do one thing Tools Used in Software Design
Open/Closed – code should be open for
extension, closed for modification
UML tools: [Link], Lucidchart, StarUML
Liskov Substitution – child classes should
Wireframing tools: Figma, Adobe XD
replace parent classes without errors
Architecture tools: Enterprise Architect
Interface Segregation – don’t force
classes to implement things they don’t Version control: Git, GitHub
need
Common Design Diagrams
Dependency Inversion – depend on
abstractions, not concrete classes
1. Use Case Diagram – shows how users
2. DRY – Don’t Repeat Yourself Avoid
interact with the system
duplicating code.
2. Class Diagram – shows classes and
3. KISS – Keep It Simple, Stupid Simple
relationships
designs work better.
3. Sequence Diagram – shows how
4. YAGNI – You Aren’t Gonna Need It
objects communicate
Don’t add features before they are
needed. 4. Activity Diagram – flow of actions
5. 5. ER Diagram – database structure
Software Design Methods
Software Design Patterns
These are reusable solutions to common
problems.
Popular Patterns:
Singleton – only one instance of a class
Factory – creates objects without
exposing creation logic
Observer – notifies objects of changes
MVC (Model-View-Controller) – separates
logic, UI, and data
Strategy – interchangeable algorithms
Why Software Design Is Important
Without proper design:
Code becomes messy
Hard to maintain or fix
Bugs increase
System becomes slow
Team cannot collaborate well
Good design saves time, money, and
effort.