Based on the role QA Engineer

Software Development

A practical, 4-pillar skill track that takes you from zero to shipping. You will learn to think in code, master one language deeply (Python), turn scripts into real software with tests and version control, and put your work in front of users with a deploy, a database, and modern AI-assisted workflows. Deliberately narrower than a role-track CS degree: if the question is 'can I build and ship software,' this is the answer.

199 lessons · about 180 hours

Explore with AI:ChatGPT Claude Perplexity

Think in Code

Your First Language

Build Like an Engineer

Ship Software and Work Modern

What you'll learn

Think in Code

The mental muscles that come before syntax. Compact, deliberately not encyclopedic. Learn to decompose problems, reason about state, and read code you did not write — the three skills every programmer uses every day regardless of language.

Unit 1
Computational Thinking
Before a single line of code, learn the four thinking moves every programmer makes: break a problem into smaller parts, strip away irrelevant detail, spot patterns you have seen before, and write down a precise recipe for solving it. These moves are language-agnostic and transfer to every course that follows.
12 lessons
1. What Abstraction Is (and Is Not)
2. Spotting Similar Problems
3. What Is an Algorithm
4. Breaking Problems into Parts
5. Modeling the Real World as Data
6. Classic Programming Patterns
7. Pseudocode: Thinking Before Typing
8. Top-Down vs Bottom-Up Thinking
9. Knowing When to Stop Decomposing
10. Levels of Abstraction
11. Tracing Algorithms by Hand
12. When Is One Algorithm Better Than Another
Unit 2
Reading and Reasoning About Code
Most of a working developer's day is spent reading code, not writing it. This course builds the muscles to walk into an unfamiliar codebase, trace what a piece of code does, build a mental model of program state, and predict behavior before running anything. Language-agnostic, with examples in plain pseudocode and Python.
9 lessons
1. Line-by-Line Execution
2. Memory as Labeled Boxes
3. Entry Points and File Structure
4. Tracking Variable State on Paper
5. References vs Copies
6. Search as a Reading Tool
7. Predicting Output Before Running
8. The Call Stack
9. Tests, Comments, and Types as Signal

Your First Language

Depth-first Python. One language, learned well, is worth five languages learned shallowly. Covers syntax and types, functions and scope, the collection types you use every day, and the handful of I/O and error skills that turn a script into a useful tool. Python chosen for readability, AI-era relevance, and the fact that almost every downstream skill in this curriculum can be demonstrated in it.

Unit 3
Python Fundamentals
Learn the core of Python — variables, types, operators, expressions, and control flow — well enough to write small programs that read input, make decisions, and produce output. Every downstream course in this curriculum builds on this one.
18 lessons
1. Installing Python
2. Variables and Assignment
3. Arithmetic Operators
4. if, elif, and else
5. for Loops and range()
6. Your First Program
7. Integers, Floats, Strings, Booleans
8. Boolean Operators and Short-Circuit Evaluation
9. Compound Conditions
10. while Loops and Termination
11. The REPL vs Script Files
12. Type Conversion and Coercion
13. Operator Precedence and Parentheses
14. Guard Clauses and Early Returns
15. break and continue
16. Naming Things Well
17. Strings and f-Strings
18. Nested Loops and Conditionals
Unit 4
Functions and Modularity
Functions are the primary tool for organizing code into reusable, testable units. This course covers defining and calling functions, parameters and return values, scope rules, basic recursion, and the purity vs side-effects distinction that drives everything from testing to refactoring.
12 lessons
1. Defining a Function
2. Positional and Keyword Arguments
3. Local vs Global Scope
4. What a Pure Function Is
5. Calling Functions and Using Return Values
6. Default Parameter Values
7. The LEGB Lookup Rule
8. Side Effects: Useful but Noisy
9. One Function, One Job
10. *args and **kwargs
11. Why Global Mutable State Is Dangerous
12. Functional Core, Imperative Shell
Unit 5
Collections and Data Shaping
The built-in collection types you will use every day — lists, dictionaries, sets, tuples — and the iteration idioms that turn long loops into short, clear code. Picking the right collection for the job is one of the first decisions that separates clumsy code from elegant code.
14 lessons
1. Creating and Indexing Lists
2. Creating Dictionaries and Accessing Values
3. Sets: Unordered, Unique
4. enumerate, zip, reversed
5. Slicing
6. Core Dict Methods
7. Set Operations: union, intersection, difference
8. List Comprehensions
9. Mutating Lists: append, extend, pop, insert
10. Modeling Structured Data with Dicts
11. Tuples: Immutable Groupings
12. Dict and Set Comprehensions
13. Aliasing and Copying Lists
14. When a Loop Is Clearer
Unit 6
Errors, Types, and I/O
The skills that turn a toy program into a useful tool: handling errors without crashing, annotating types so your code documents itself, reading and writing files, parsing JSON and CSV, and accepting command-line input. By the end you can write a small script that reads real data, processes it, and writes real output.
14 lessons
1. Types of Errors: Syntax, Runtime, Logic
2. Basic Type Annotations
3. open() and the with Statement
4. JSON: Load, Dump, and Shape
5. try/except Basics
6. Collections and Optional Types
7. Reading and Writing Text
8. CSV: Rows and Columns
9. Reading Tracebacks
10. Type Checking in Practice
11. Paths with pathlib
12. argparse: Command-Line Arguments
13. Raising Your Own Exceptions
14. Your First Real Script

Build Like an Engineer

Scripts become software here. Version control so your work survives mistakes, OOP so code scales past a single file, tests and debugging so you can change code without fear, and design-for-change habits that separate throwaway code from code you can live with in six months.

Unit 7
Design for Change
The habits that make code a pleasure to come back to — naming, small functions, small commits, refactoring with tests as a safety net, and recognizing the smells that signal trouble. This is the course that separates working code from code you can still work on in six months.
13 lessons
1. Naming Is Design
2. The Long Function
3. What Refactoring Is (Precisely)
4. One Logical Change per Commit
5. Short, Focused Functions
6. Duplicated Logic
7. Small, Always-Working Steps
8. Separate Refactors from Features
9. Boring Over Clever
10. Deep Nesting
11. When to Rewrite Instead of Refactor
12. PR Descriptions That Help Reviewers
13. Resist Premature Abstraction
Unit 8
Object-Oriented Programming
Classes, objects, and the OO thinking patterns that let code scale past a single script. Covers classes and instances, methods, encapsulation, inheritance (sparingly!), composition, and the practical design heuristic: prefer composition over inheritance. Focused on writing clean, testable OO code — not an academic survey of the paradigm.
11 lessons
1. What a Class Is (and Is Not)
2. One Class, One Job
3. Composition: Has-A Is the Default
4. __init__ and Instance Attributes
5. Hiding Implementation Detail
6. Inheritance Basics
7. Methods: Functions That Know About Their Object
8. Properties: Computed Attributes
9. When Inheritance Hurts
10. __repr__ for Readable Debugging
11. Dependency Injection: Pass It In
Unit 9
Version Control with Git
Git is the time machine and collaboration tool every developer uses. This course covers the mental model of commits and branches, the local workflow (add → commit → branch → merge), remote collaboration via push/pull/PRs, and the recovery moves that let you undo almost anything without losing work.
13 lessons
1. Working Directory, Staging Area, Commit
2. init, add, commit
3. Remotes, push, and pull
4. Resolving Merge Conflicts
5. Commits Are Snapshots, Not Diffs
6. status, diff, log: Knowing Where You Are
7. Pull Requests and Code Review
8. Undoing Commits, Amending, and Unstaging
9. Branches Are Just Pointers
10. Creating Branches, Switching, Merging
11. Keeping Your Branch Current
12. The Reflog: Git's Safety Net
13. Writing Good Commit Messages
Unit 10
Testing and Debugging
The two skills that let you change code without fear. Testing so you catch regressions automatically; debugging so you can find the source of a failure fast. Covers unit and integration tests with pytest, fixtures and mocking, a debugging methodology, using a real debugger, and systematic techniques like binary-search bisection.
14 lessons
1. Tests Enable Change
2. Installing and Running pytest
3. Fixtures: Setup and Teardown
4. Reproduce First
5. Using a Real Debugger
6. What to Test and What to Skip
7. Writing Good Assertions
8. Mocking Dependencies
9. Isolate, Hypothesize, Test
10. Conditional Breakpoints
11. Parametrized Tests
12. When Not to Mock
13. Rubber-Duck Debugging
14. Binary-Search Bisection

Ship Software and Work Modern

The mile between 'works on my laptop' and 'users are using it.' Command line, a real web app, a real database, a real deploy — plus the 2026 meta-skill: working with AI assistants without letting them put garbage in your codebase. Security basics are woven in, not bolted on.

Unit 11
Deploying and Observing
Put your app on the internet and keep it alive. Covers Docker enough to be useful, deploying to a modern PaaS, managing secrets, structured logging, uptime and error monitoring, and the minimum-viable security hygiene every shipped app needs. Security is folded in here — exactly where it actually matters.
14 lessons
1. A Minimum-Viable Dockerfile
2. Picking a PaaS
3. Never Commit Secrets
4. Structured Logging
5. Images vs Containers
6. Your First Deploy
7. Rotating a Leaked Secret
8. Error Tracking (Sentry-style)
9. Layer Caching and Fast Rebuilds
10. Attaching a Managed Database
11. Auditing Your Dependencies
12. Uptime Checks
13. Custom Domain and HTTPS
14. An OWASP Shortlist for Everyday Apps
Unit 12
Working with Databases
Where your app's data actually lives. Covers SQL basics, schema design, migrations, SQLite for local development, Postgres for production, and the minimum you need to know about ORMs to use one without being surprised. Focused on what you need to build and ship — not every clever query imaginable.
14 lessons
1. SELECT, WHERE, ORDER BY
2. Primary and Foreign Keys
3. SQLite: Zero-Config Database
4. Migrations: Versioned Schema Changes
5. INSERT, UPDATE, DELETE
6. Constraints: Making Bad Data Impossible
7. Postgres: The Production Default
8. Safe Migration Patterns
9. Joins: Connecting Tables
10. Indexes: Fast Lookups (With a Cost)
11. Writing Portable-Enough SQL
12. ORMs: Python Objects for Rows
13. Aggregations and GROUP BY
14. When to Drop to Raw SQL
Unit 13
AI-Assisted Development
The 2026 meta-skill. AI assistants will write most of the boring code in your career; your job is to keep the hard parts under human judgment. This course covers prompting for code, reviewing AI output critically, using agentic tools, when to refuse an AI suggestion, and the tests-and-types discipline that makes AI-assisted work safe rather than sloppy.
13 lessons
1. Scope and Constraints
2. Treat It Like a PR from a Stranger
3. What Agents Are Good At (Today)
4. Tests as the Forcing Function
5. Supplying the Right Context
6. Common AI Failure Modes
7. Where Humans Still Belong
8. Types for Safety
9. Iterating on a Reply
10. Never Merge What You Don't Understand
11. Scoping a Task for an Agent
12. Keep AI Diffs Small
13. Learning to Reject
Unit 14
Building a Web App
From HTTP basics to a running web app you built yourself. Covers the request/response lifecycle, a modern Python framework (FastAPI or Flask), routing, forms, templates, JSON APIs, and the minimum-viable authentication pattern you need to put real users behind your app.
16 lessons
1. Request and Response
2. Hello, Web
3. HTML Templates
4. Authentication vs Authorization
5. Routes, Services, and Data
6. Verbs and Status Codes
7. Routes and Handlers
8. Forms and Validation
9. Password Hashing Done Right
10. Configuration Out of Code
11. Headers in Practice
12. Path Params and Query Strings
13. JSON Endpoints
14. Sessions vs Tokens
15. A README That Actually Helps
16. Protecting Routes
Unit 15
The Command Line and Your Environment
The shell, the filesystem, processes, environment variables, package managers, and virtual environments — the ambient layer every developer works on top of. You will stop being afraid of the terminal and start using it to move ten times faster than you could with a GUI.
12 lessons
1. Navigating the Filesystem
2. Redirecting Output
3. Environment Variables
4. Virtual Environments with venv
5. Copying, Moving, Deleting Files
6. Pipes: Commands as Lego
7. .env Files in Projects
8. pip and requirements.txt
9. Tab Completion and History
10. Essential Text Utilities
11. Processes: ps, kill, bg, fg
12. A Tour of Modern Package Tools