This is a self-guided online video course.

The modules are one of 4 categories: lessons, demonstration, action, or conversation.

The lesson modules introduce you to the essential knowledge you need in order for you to understand the demonstration modules. All lessons modules include a summary so that you don’t have to watch the entire video to recap things you’ve already seen. Post pre-launch, leading up to the official launch, some lesson modules may be mostly text, but they’ll all be converted to video modules.

Demonstration modules are always video because that’s where online courses shine. These modules are what they sound like: screencasts that build upon the lessons. You’ll see how to apply what you’ll do in the action modules.

Action modules are for challenges, exercises, building out chunks of your own projects, assignments and gaining practical experience.

Design is non-linear and nuanced. This is what makes it a bit of an art form. As an Early Adopter, you’re going to run into a lot of unique challenges and you’ll have a lot of questions. Conversation modules fill in this gap.

Conversation modules are extensions of lesson modules. They’re commentaries, conversations, and answers to commonly asked questions. These come from questions you’ve asked in the Discord, the Software Essentialist Mentorship calls, and Q&As that us Early Adopters will organize on occasion.

This is not like any other programming course.

It's a first-principle-focused design course.

It’s focused on skills and the 12 core principles of design, architecture & testing.

It is about skills > tools, technologies, or popular topics.

For example, instead of teaching you about a particular type of messaging technology, you'll build a strong foundation upon which you'll be able to think critically and solve challenges yourself.

It is also a first principles > best practices course. 

Yes, we will cover parts of DDD, TDD, BDD, and so on — but it’s about the fundamental first principles, and the 80-20 of those topics.

What makes this course unique is the approach that I use to teach you this 80-20.

Where you could go, study, and learn each of these topics on your own, you’ll have trouble piecing them all together and making sense of them.

• This is what I’ve spent the last 4 years doing myself, and then teaching to my Software Essentialist Mentorship students.
• If you follow this path, you’ll learn the most important parts of each of these topics at a way faster rate, and you’ll be in an incredible position to go deeper into the esoterics of them later on.
• I will offer more focused chunks of this course later on down the road, where we focus on one of the essentials at a time, and that’ll be the time for us to go exceptionally deep on one of the various topics.
• This is about 20% across each that will yield the greatest results for you.

Yes, you'll be writing a lot of code.

You'll be given plenty of assignments at each distinct milestone to build out your core design, testing & architecture skills in The Physical.

You'll use these to practice building features in:

• the Backend API project
• the Frontend project
• the Desktop application project
• the Chrome Extension project
• the Custom Integration project

You'll also use what you learn about identifying value, decomposing a domain, planning a project and the initial architecture in  The Theoretical to build your own product in Bridging the Gap (Theoretical → Physical).

Lastly, you'll be learning how to safely refactor a legacy project towards one that you can guide with tests.

Lots of code. Lots of design.

How does lifetime access sound?

Absolutely. We have a 30 day money back guarantee! If you aren't satisfied for any reason at all you can ask for your money back in full within 30 days of the purchase.

The current price of the course is $499 USD (on sale).

To make the content more accessible, in the future, I will offer mini-courses that teach segments of the content.

My recommendation is to become a solidbook reader, because in addition to the vast array of topic summaries in that book, you'll also get access to The Essentials which is an outline of the strategies we use in this book to master the 80-20 as fast as possible.

It's getting split up into two books: solidbook and The Essentials.

Expect to receive both this year after we finish tightening up the content in this course. 

This course is the same content as my mentorship program and similar to the upcoming book, The Essentials, but in video format, with more content, deeper explanation, bonuses, a community, and better feedback.

• solidbook: learn the unknown unknowns (text-book/sophia)
• the essentials (book): step by step guide for how to become the developer who can write scalable, testable code on the frontend, backend, desktop, etc (guide/phronesis)
• the essentials (course): same as above but in video format, with access to me, the alumni, key mentorship call recordings - past & future

solidbook is a knowledge-book. It's an expose through a vast array of topics that are good for you to know, but it's just a collection of things that you should probably know about from the past 40-50 years. It has a ton of stuff. Some of is less practical, in my opinion. But, it's a book that succeeds at shining a light on the unknown unknowns.

Lots of devs want it to be done (it's getting done this year) - I have no problem going over the 21 different design patterns and 34 design principles if that's what's desired, but that's NOT what we're going to be doing in The Essentials (book) and The Software Essentialist (video course).

The goal of The Software Essentialist is transformation. Where solidbook is about uncovering all those unknown unknowns, we take a different path in The Software Essentialist/The Essentials. It's first-principles driven.

It's about the 80-20 we need to get good at building products in a scalable way. Those are the 12 Essentials. Each of the 12 Essentials will cover many of the topics from solidbook, but instead of a "here's this topic now", it's all bottom-up from first-principles, to get you to mastery and true understanding.

We will do this by first building a strong foundation of the Metaphysical space. What is software development? What is value? This introduces us to the critical concepts like The Feedback Loop (Essential #2) and the 12 different Guess Points that we need to get good at running Feedback Loops upon.

This is what we orient ourselves around to achieve the end goal of becoming the software designer that can write scalable, testable code on the frontend, backend, desktop, etc.

To accomplish this, we're going to need a ton of practice, and to be given the right information at the right time.

This is one of the critical differences between solidbook and The Essentials.

• solidbook is like a textbook
• The Essentials is a step-by-step guide.

You'll be doing tons of hands-on assignments (ACTION) as we progress from the inside-out through each Guess Point/Feedback Loop Level.

For example, at Guess Point/Feedback Loop Level 1: Unit (Stateless), we're going to just focus on the mechanics of TDD and get good test-driven mechanics down.

In summary:

• solidbook (book): an introduction to the world of software design (text-book/sophia)
• tswe (course): step by step guide for how to become a systems thinker and write scalable, testable code on the frontend, backend, desktop, etc (guide/phronesis). In a mixture of video & text format, with access to me, the alumni, key mentorship call recordings - past & future

This is my 1-on-1 & group training program I offer to small groups of less than 10 students at a time for 3 month blocks minimum (see the form here). I teach them exactly what I’m about to teach you in this online course. The only difference is the format.

Where the mentorship training was offered as live video calls w/ unlimited touch points and weekly classes & Q&As, this online course takes the self-guided + community approach.

To focus on this course, the community, the final version of solidbook & the accompanying book for this course (The Essentials), I'm not taking on any new mentorship students.

As an Early Adopter of this program, you’ll may end up spending some time w/ me 1-on-1 and ad-hoc Q&As as I refine the program. Ask a ton of questions in the Discord. We'll make sure to answer 'em, and fill in any important gaps with updated modules. 

As an Early Adopter, you’ll also get access to key discussions from mentorship calls (past & future) as Conversation Modules.

Yes. The Essentials is an entirely different book with an entirely different goal, but it emerged from solidbook. All solidbook readers will get access to The Essentials emailed to them later this year.

To summarize:

• solidbook is the sophia (knowledge) book which acts as a textbook, showing you the past and present of what you should know about as a software developer. Topic-focused book.
• The Essentials is the phronesis (practical wisdom) book which acts a step-by-step guide to mastering the 80-20 (the most important parts) of the key topics that yield the greatest results. Transformation/results-focused book.

Yes. Here's a review from a previous Software Essentialist Mentorship student.

"I would say because of a lot of the things we've run through with domain driven design/object oriented design my system design skills have improved. This was mainly apparent to me when I was practicing high level design for system design interviews and I found it easier to flesh out the general requirements, api calls, and design itself because of things we learned at the start of the program with design stories and object design."

We won't be doing any of the brutal algorithm questions that they ask in interviews or that I hated doing in university.

We're going to be more practical than that.

You'll learn how to design good abstractions, yes. Abstraction Design,  one of our key essential principles will teach you this.

Algorithmically, we're going to practice writing the simplest possible solutions by guiding our code with tests.

Not fancy or exciting, I know - but it's consistent and it's reliable.