Skip to content
Launchpad

Learning path

Software Developer

One foundation. Five destinations.

About this path

The Software Developer path starts with a rigorous Python foundation - types, control flow, functions, objects and tests - then opens into five specializations. Master the core once, then choose the platform you want to build for without starting over.

Outcomes
What you'll be able to do when you finish.
  • Write clear, idiomatic Python 3 and reason about programs step by step
  • Design programs with functions, modules and object-oriented modeling
  • Choose suitable data structures and reason about their performance
  • Persist and query data with files and databases
  • Write automated tests and work with professional tooling
  • Specialize: desktop apps, Android, iOS, cross-platform mobile, or backend & systems with Go or Rust

Modules

The path is organized into modules; modules into lessons. Work through them in order — each lesson assumes the ones before it.

  1. 01
    Programming Foundations with Python
    Live
    Values, types, names, f-strings and truthiness in Python 3 - a rigorous first step into programming.
  2. 02
    Object-Oriented Design
    Live
    Classes, objects, composition and inheritance, and when each design pays off.
  3. 03
    Data Structures & Algorithms
    Live
    Lists, dicts, stacks, queues and trees, with the reasoning to pick the right one.
  4. 04
    Data & Persistence
    Live
    Files, SQL databases and queries that keep data safe between runs.
  5. 05
    Professional Practice
    Live
    Testing, debugging, version control and collaborating on real projects.
  6. 06
    Desktop Development Specialization
    Live
    Build installable desktop applications with Python and PySide6: windows, widgets, signals, model/view data, settings and packaging.
  7. 07
    Android Development Specialization
    Live
    Build Android apps with Kotlin and Jetpack Compose: from the language and tooling through interfaces, state, persistence and publishing.
  8. 08
    iOS Development Specialization
    Live
    Build iOS apps with Swift and SwiftUI: from the language and Xcode through interfaces, state, persistence and the App Store.
  9. 09
    Cross-platform Mobile Specialization
    Live
    Ship one React Native codebase to iOS and Android: components, styling, navigation, native APIs and Expo-based builds.
  10. 10
    Backend & Systems: Go
    Live
    The Go option of the Backend & Systems track: the language, concurrency with goroutines and channels, HTTP services and the toolchain.
  11. 11
    Backend & Systems: Rust
    Live
    The Rust option of the Backend & Systems track: ownership, traits, error handling and real projects from CLI tools to web services.

Specializations

After the shared foundation, this path opens into five focused specializations — each a live track you can start once its prerequisites are behind you. The foundation you build now carries into all of them.

Desktop
Live
Build installable applications for Windows, macOS and Linux with native GUI toolkits.

6 lessons · track: desktop

Open the desktop track
Android
Live
Build and publish apps for Android phones and tablets, from interface to storage.

6 lessons · track: android

Open the android track
iOS
Live
Build and publish apps for iPhone and iPad with Swift and modern iOS frameworks.

6 lessons · track: ios

Open the ios track
Cross-platform Mobile
Live
Ship one codebase to both major mobile platforms without writing everything twice.

6 lessons · track: cross-platform

Open the cross-platform track
Backend & Systems
Live
Build servers, APIs, background jobs and the data pipelines that power products.

10 lessons · tracks: go + rust — Go and Rust are both preserved as options

Open the go trackOpen the rust track

Competencies you'll build

Every lesson maps to named competencies. These are the ones live lessons cover today; planned modules add more as they ship.

  • Python values, variables & types
  • Python control flow & functions
  • Python collections
  • Python errors & modules
  • Object-oriented design
  • Inheritance, ABCs & Protocols
  • Composition, Dataclasses & Properties
  • Dunder Methods, Iterators & Generators
  • Complexity Analysis
  • Data structures & algorithms
  • Core Data Structures
  • SQL Querying
  • Schema Design
  • Databases from Python
  • Testing fundamentals
  • Professional Python Tooling
  • GUI Fundamentals with PySide6
  • Signals, Slots & Events
  • Kotlin Fundamentals
  • Swift Fundamentals
  • React Native Fundamentals
  • Go Fundamentals
  • Networking Foundations
  • Rust Fundamentals
  • Model/View Programming
  • Desktop Data & Settings
  • Packaging & Distribution
  • Jetpack Compose UI
  • Lifecycle & State
  • Room, DataStore & Permissions
  • Testing & Shipping Android
  • SwiftUI Views & Layout
  • State, Data Flow & Lifecycle
  • iOS Persistence
  • Testing & Shipping iOS
  • Styling & Layout
  • Navigation Patterns
  • Data, Native APIs & Platform Differences
  • Testing & Shipping with Expo
  • Goroutines & Channels
  • HTTP Services in Go
  • Go Tooling & Testing
  • Ownership & Borrowing
  • Structs, Enums, Traits & Errors
  • Real Projects in Rust

Tier 1 — core foundationTier 2 — depth that builds on it

The full visual skill tree arrives in Phase 3 — see your current coverage on the progress page.