CF

How to Build the Right Software (in the Right Stack)

2h 34m 35s
English
Paid

In 25 years of working as a developer, manager, and UX designer, one main thing becomes clear: the most challenging part of software development is not writing code, but understanding what exactly needs to be created. This skill is rarely formalized and hardly ever taught, yet it distinguishes good engineers from truly strong ones.

Course Overview

This course is dedicated to a systematic approach to identifying the real issues underlying requirements and feature requests. You will learn how to consistently ask "why" to reach the true needs of the user or business, rather than implementing solutions "on autopilot" or due to historical constraints. Features are considered not as tasks to be executed but as signals pointing to deeper issues.

Choosing the Right Technological Stack

Special attention is given to the deliberate choice of technological stack. Instead of offering universal recipes, the course demonstrates how to align the real goals of a project with the capabilities of various tools—from JavaScript frameworks and static generators to low-code solutions. The goal is not to know more technologies but to be able to choose the appropriate one.

Practical Focus

The training is focused on practice rather than theory. The course includes scenarios of role-playing dialogues using AI, analysis of user interactions with existing systems, and working with legacy code to understand the original architectural decisions. This format helps junior developers see a broader context and experienced ones ensure that their expertise leads to real benefits.

Learning Outcomes

As a result, you will obtain:

  • A repeatable process for making product and technical decisions
  • Confidence in discussing requirements with stakeholders
  • The ability to turn vague requests into meaningful, effective solutions

This is a skill that cannot be automated or replaced by AI: understanding which problems are truly worth solving and why.

About the Author: Anthony Alicea

Anthony Alicea thumbnail

Anthony Alicea is a US software engineer and educator best known for JavaScript: Understanding the Weird Parts — one of the canonical paid courses on JavaScript's underlying mental model (execution context, scope chain, prototype inheritance, the call stack) and one of the most widely-recommended deep-dives into the language for developers ready to move past surface syntax.

The course catalog extends into TypeScript (the deep type-system material rather than the syntax tour), React, Node.js, and the broader JavaScript ecosystem. The teaching style is unusually rigorous about the language fundamentals — Anthony's courses are taught at the level of someone who wants you to understand why JavaScript behaves the way it does, not just memorise the rules.

The CourseFlix listing under this source carries 7 Anthony Alicea courses spanning that range. Material is paid and aimed at developers ready to deepen their craft on the JavaScript / TypeScript stack.

Watch Online 36 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction
All Course Lessons (36)
#Lesson TitleDurationAccess
1
Introduction Demo
02:40
2
Requirements and Solving the Right Problem
03:05
3
Clients and Users are Not Software Designers
09:28
4
The Why Down
11:53
5
The Why Down (Practice)
01:49
6
Control Scope Creep with Alternative Solutions
06:09
7
Constraints Produce Creative Solutions
03:02
8
Silos Are the Enemy
05:57
9
MSP not MVP
06:18
10
Choosing a Stack
02:30
11
The Interactivity Question
02:01
12
JavaScript Frameworks (NextJS, Remix, Vue, Angular, Solid, Qwik, and More)
13:52
13
Static Sites
03:29
14
A Mix Of Things
03:27
15
Vanilla JS, Lightweight Libraries, and Server Frameworks
06:12
16
PHP, Laravel, and Toolboxes
04:51
17
Low-Code and No-Code Solutions
05:35
18
Content Management Systems
04:57
19
Use Design Systems and Templates
03:34
20
SQL vs NoSQL
04:57
21
Fundamentals Beats Tribalism
02:41
22
The Power of User Research
03:04
23
Existing Software and User Observation
02:30
24
Discount Usability Testing
04:01
25
Control Requirements with User Research
03:27
26
Express Results as Problems
03:28
27
Handling Feature Requests (the Right Way)
00:44
28
Feature Requests Are Not Requirements
02:09
29
Why Down Feature Requests
08:21
30
The Why Down (Practice)
00:40
31
Reduce Technical Debt: Make the Smallest Addition Possible
01:56
32
Software Rewrites
00:31
33
Existing Software is a Research Goldmine
06:11
34
1-to-1 Rewrites Are a Wasted Opportunity
05:44
35
Build Less Software
02:15
36
Conclusion - How To Build The Right Software
01:07
Unlock unlimited learning

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

Learn more about subscription

Books

Read Book How to Build the Right Software (in the Right Stack)

#TitleTypeOpen
1WhyDown Worksheet PDF

Related courses

Frequently asked questions

What are the prerequisites for this course?
The course does not require specific technical skills, but a basic understanding of software development principles is beneficial. Familiarity with software development processes and terminology will help you grasp the concepts more effectively, especially when analyzing user interactions and working with legacy code.
What projects or skills will I develop during this course?
You will engage in role-playing dialogues using AI, analyze user interactions with existing systems, and work with legacy code. These exercises aim to enhance your ability to identify the real issues behind feature requests and improve your decision-making skills when choosing a technological stack.
Who would benefit most from taking this course?
The course is designed for junior developers, software engineers, product managers, and UX designers who want to improve their problem-identification skills and learn how to make informed decisions about technological stacks that align with project goals.
How does this course compare in depth or scope to similar courses?
Unlike many courses that focus on programming languages or frameworks, this course emphasizes understanding the underlying problems in software requirements. It provides a systematic approach to questioning and aligning project goals with the right technological stack, offering a unique perspective on software development.
What specific technologies or platforms are covered in the course?
The course covers a range of technologies, including JavaScript frameworks such as NextJS, Remix, Vue, Angular, Solid, and Qwik. It also discusses static site generators, low-code solutions, PHP and Laravel, content management systems, and database options like SQL and NoSQL.
What topics are not covered in this course?
The course does not provide detailed tutorials or step-by-step guides for programming in specific languages or frameworks. Instead, it focuses on the strategic aspects of software development, such as understanding user needs and choosing the right tools for the job.
How much time should I expect to commit to this course?
The course consists of 36 lessons, and while the exact runtime is not specified, it is designed for you to engage deeply with each topic through practical exercises and scenarios. Participants should be prepared to dedicate time not only for lessons but also for practice and reflection.