CF

The 30-Day Design Challenge

8h 52m 30s
English
Paid

This course is designed for those who want to go beyond theoretical knowledge and develop skills in working with production code. Regardless of your level of experience - whether you are a junior developer looking to improve your skills or a data specialist who wants to structure your code - the course will help you move on to more complex tasks.

The course offers 30 engaging software design assignments that will unlock your potential in problem-solving and creative programming approaches. You will encounter tasks of varying complexity: from simple examples focusing on design principles to deep practical exercises, such as creating an API with FastAPI and SQLAlchemy, working with GUI code, functional and object-oriented programming, as well as detailed type annotations in Python.

About the Author: ArjanCodes (Arjan Egges)

ArjanCodes (Arjan Egges) thumbnail

ArjanCodes is the YouTube channel and paid-course brand of Arjan Egges, a Dutch software engineer and academic (formerly Utrecht University faculty) — one of the most cited independent voices on Python software design and architecture. The channel focuses on the engineering disciplines underneath maintainable Python codebases rather than language tutorials.

His CourseFlix listing carries three ArjanCodes courses: The Software Designer Mindset (COMPLETE), The Software Architect Mindset (COMPLETE), and The 30-Day Design Challenge. Together the courses cover the senior-engineer mental model — design patterns, architectural decisions, and the trade-offs that show up in real production codebases.

Material is paid and aimed at intermediate-and-up Python developers ready to think about software design as a deliberate professional skill. For broader content, see CourseFlix's Python and System Design & Architecture category pages.

Watch Online 53 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 53 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Welcome!
All Course Lessons (53)
#Lesson TitleDurationAccess
1
Welcome! Demo
01:59
2
Solution: KISS
02:14
3
Solution: Type Annotations
09:34
4
5 Tips To Achieve Low Coupling In Your Python Code
18:30
5
Solution: Decoupling
03:31
6
Solution: DRY
03:42
7
F-strings In Python_ Everything You Need To Know
23:29
8
Solution: String Formatting
02:33
9
Solution: Law Of Demeter
03:19
10
Solution: Better Discounts
04:32
11
The Strategy Pattern_ Write BETTER PYTHON CODE Part 3
15:31
12
How to Implement the Strategy Design Pattern in Python
27:20
13
Solution: Payment Strategy
03:08
14
Why the Plugin Architecture Gives You CRAZY Flexibility
24:06
15
Solution: Plugins
05:52
16
Functions vs Classes_ When to Use Which and Why_
10:49
17
Solution: Object Oriented To Functional
06:32
18
Cohesion and Coupling_ Write BETTER PYTHON CODE Part 1
26:14
19
Solution: Cohesion
03:53
20
Which Software Architecture Should You Use_ MVC, MVP, or MVVM_
24:27
21
Solution: MVP
05:18
22
Composition Is Better Than Inheritance in Python
23:29
23
Solution: Inheritance
03:39
24
Dependency INVERSION vs Dependency INJECTION in Python
17:52
25
Solution: Abstraction
02:26
26
You Can Do Really Cool Things With Functions In Python
19:47
27
Solution: Higher-Order Functions
03:12
28
Solution: Configuration
02:59
29
Next-Level Concurrent Programming In Python With Asyncio
19:19
30
How To Easily Do Asynchronous Programming With Asyncio In Python
23:09
31
Solution: Concurrency
08:18
32
Solution: Refactoring
03:36
33
A Deep Dive Into Iterators and Itertools in Python
21:01
34
Solution: Itertools
02:10
35
Solution: Inappropriate Intimacy
01:58
36
End of Part 1
00:32
37
Real-Life Case of the Command Design Pattern
32:25
38
Solution: Undo/Redo
03:32
39
Raw SQL, SQL Query Builder, or ORM?
16:19
40
Solution: SQL to ORM
04:29
41
Solution: Unit Tests (Basic)
02:48
42
Solution: Unit Tests (Advanced)
02:15
43
Solution: Operations Layer
04:35
44
Solution: Ticket Cancellation
03:32
45
Observer Pattern Tutorial: I NEVER Knew Events Were THIS Powerful
15:17
46
Solution: Messaging
04:30
47
Attrs, Pydantic, or Python Data Classes?
17:10
48
Do We Still Need Dataclasses? // PYDANTIC Tutorial
16:33
49
Solution: Validation
02:30
50
Let's Take The Bridge Pattern To The Next Level
17:13
51
Solution: Bridge
04:52
52
Solution: Mixins
03:33
53
Wrapping Things Up
00:57
Unlock unlimited learning

Get instant access to all 52 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites should I have before taking this course?
The course is suitable for individuals with varying levels of experience, from junior developers to data specialists. Familiarity with Python is beneficial, as the lessons cover Python-specific concepts like F-strings, type annotations, and async programming. A basic understanding of object-oriented programming and software design principles will also help since the course delves into design patterns and architecture concepts.
What kinds of projects will I work on during the course?
Participants will engage in various solution-based projects that explore practical applications of design and architecture principles. For example, projects involve implementing the Strategy Pattern, developing plugins, and using the Command Design Pattern. The course also includes exercises on unit testing and refactoring, which are essential for working with production code.
Who is the target audience for this course?
The course is aimed at individuals who want to enhance their practical coding skills in Python. It is particularly useful for junior developers seeking to tackle more complex tasks and data specialists interested in structuring their code effectively. The lessons focus on bridging theoretical knowledge with real-world application, making it ideal for those ready to apply concepts in production environments.
How does this course compare in depth and scope to similar courses?
This course covers a broad range of topics in Python design and architecture, including patterns like Strategy and Observer, and principles like DRY and the Law of Demeter. Unlike courses that focus purely on theoretical concepts, this course emphasizes practical application with solution-based projects, allowing participants to work directly with production code and real-world scenarios.
Which specific tools or platforms are covered in this course?
The course primarily focuses on Python and its ecosystem, exploring tools like Asyncio for concurrent programming and SQL to ORM transformations for database interaction. It also covers frameworks and libraries such as Pydantic and Python Data Classes for data validation and class management, providing a comprehensive understanding of Python's capabilities in software design.
What topics are not covered in this course?
The course does not cover non-Python programming languages or focus on frontend development frameworks. While it delves into architectural patterns and design principles, it does not provide an introduction to basic programming concepts, assuming a foundational understanding of Python and software development practices.
How can the skills learned in this course be applied to other courses or careers?
The skills developed in this course, such as understanding design patterns and improving code structure, are valuable across various programming disciplines. Mastery of Python's advanced features and architecture principles can be directly transferred to other software development roles, enhancing one's ability to work on large-scale projects and collaborate with teams effectively. These skills are also beneficial for further studies in software engineering and advanced programming courses.