Coming soon
Software Engineering
Write code your team trusts. Ship systems that stay up.
The complete course
- modules
- 62
- topics
- 651
- min lessons
- 15
86%
of employers expect AI and information processing to transform their business by 2030.
What you'll be able to do.
Read and debug code you didn't write
Stage 1 · Programming Foundations
Turn vague requests into clear requirements
Stage 2 · Requirements & Design
Model data and keep it consistent
Stage 3 · Data & Distributed Systems
Write tests from unit to end-to-end
Stage 4 · Security & Testing
Ship through CI/CD and handle incidents
Stage 5 · Delivery & Operations
Take a product from spec to release
Stage 7 · Integrated Projects
Seven stages.One steady climb.
Everything between writing code and running software people depend on.
62modules
in 7 stages
651topics
≈ 11 per module
≈163hours
of 15-minute lessons
≈21months
≈11months
≈5months
to finish the whole course
- 1
Programming Foundations
How code runs, fails and gets fixed
14 modules · 145 topics · ≈ 36 hr
- 2
Requirements & Design
What to build, and how to shape it
12 modules · 127 topics · ≈ 32 hr
- 3
Data & Distributed Systems
Data that stays right across machines
10 modules · 107 topics · ≈ 27 hr
- 4
Security & Testing
Proof it works, and stays safe
11 modules · 115 topics · ≈ 29 hr
- 5
Delivery & Operations
From merge to production, on call
8 modules · 86 topics · ≈ 22 hr
- 6
Professional Practice
The team side of the job
6 modules · 61 topics · ≈ 15 hr
- 7
Integrated Projects
Ten projects, start to finish
1 module · 10 topics · ≈ 3 hr
Months
04812160246801234
MonthsFinish · ≈ 21 months · ≈ 11 months · ≈ 5 months
Hours and months are estimates: one 15-minute lesson per topic, every day.
Every module.Every topic.
Stage 1
Programming Foundations
How code runs, fails and gets fixed
14 modules · 145 topics
1The World of Software Engineering9 topics
- What Software Engineers Actually Build
- Programming vs. Software Engineering
- Software as a Product, Service, and Component
- Correctness, Usefulness, and Fitness for Purpose
- Complexity and the Cost of Change
- Engineering Decisions Under Constraints
- The Responsibilities of a Software Engineer
- Working Across Product, Design, Engineering, and Operations
- The Full Lifetime of a Software System
2Software Systems and Their Life Cycles10 topics
- Programs, Applications, Services, and Platforms
- System Boundaries and External Dependencies
- Users, Operators, and Other Stakeholders
- From an Idea to a Running Software System
- Discovery, Development, Delivery, and Maintenance
- Prototypes, Experiments, and Production Systems
- Iterative and Incremental Development
- Predictive, Adaptive, and Hybrid Life Cycles
- Feedback Loops Across the Software Life Cycle
- Retirement and Replacement as Engineering Activities
3Computational Problem Solving10 topics
- Turning a Problem into Inputs, Outputs, and Rules
- Decomposition and Stepwise Refinement
- Abstraction and Essential Detail
- Boolean Logic and Compound Conditions
- Sets, Relations, and Mappings
- States, Transitions, and Invariants
- Examples, Counterexamples, and Edge Cases
- Pseudocode and Algorithm Sketches
- Estimation and Reasonableness Checks
- Distinguishing a Correct Solution from a Practical One
4Programs, Languages, and Execution10 topics
- Source Code and Executable Behavior
- Syntax, Semantics, and Program Meaning
- Compiled, Interpreted, and Hybrid Execution
- Runtimes, Virtual Machines, and Standard Libraries
- Entry Points and Program Startup
- Expressions, Statements, and Evaluation
- Scope, Namespaces, and Name Resolution
- The Call Stack and Function Execution
- Input, Output, and Interaction with the Environment
- Choosing a Language for Constraints and Team Capabilities
5Values, Types, and Data Representation12 topics
- Variables, Values, and Bindings
- Integers, Floating-Point Numbers, and Precision
- Booleans and Logical Values
- Strings, Unicode, and Text Encoding
- Records, Objects, and Structured Values
- Enumerations and Explicit State Representation
- Static and Dynamic Type Checking
- Type Inference and Type Conversion
- Null, Missing Values, and Optional Types
- Equality, Identity, and Comparison
- Dates, Times, Time Zones, and Durations
- Representing Money, Units, and Domain-Specific Quantities
6Control Flow and Functions11 topics
- Conditional Execution and Branching
- Loops and Iteration
- Early Returns and Guard Clauses
- Functions, Parameters, and Return Values
- Function Contracts and Caller Expectations
- Passing Values and References
- Recursion and Base Cases
- Higher-Order Functions and Callbacks
- Closures and Captured State
- Separating Calculation from Side Effects
- Keeping Control Flow Understandable
7Practical Data Structures10 topics
- Arrays and Dynamic Arrays
- Linked Structures and Their Trade-Offs
- Stacks and Queues
- Maps, Dictionaries, and Hash Tables
- Sets and Membership Tests
- Trees and Hierarchical Data
- Graphs and Connected Data
- Heaps and Priority Queues
- Iterators and Collection Traversal
- Choosing Structures by Operations and Constraints
8Algorithms and Computational Cost12 topics
- Algorithm Correctness and Termination
- Linear Search and Binary Search
- Sorting and Ordering Requirements
- Traversing Trees and Graphs
- Recursion vs. Iteration
- Divide-and-Conquer Strategies
- Greedy Decisions and Their Limitations
- Reusing Results with Memoization
- Time and Space Complexity
- Big-O Notation and Its Practical Limits
- Input Size, Constant Factors, and Real Workloads
- Recognizing When an Algorithm Needs to Change
9State, Mutation, and Resource Management10 topics
- Local State and Shared State
- Mutable and Immutable Data
- Aliasing and Unexpected Changes
- Object Lifetimes and Resource Ownership
- Stack and Heap Allocation as Programming Concepts
- Garbage Collection and Managed Memory
- Explicit Cleanup and Scoped Resource Management
- Files, Connections, and Other Finite Resources
- Copying, Sharing, and Defensive Boundaries
- Preventing Resource Leaks and Unbounded Growth
10Errors, Failures, and Defensive Programming10 topics
- Invalid Inputs, Programming Defects, and Operational Failures
- Exceptions, Error Values, and Result Types
- Validation at System Boundaries
- Recoverable and Unrecoverable Conditions
- Preserving Error Context
- Error Propagation and Translation
- Cleanup When Operations Fail
- Assertions and Internal Consistency Checks
- Avoiding Silent Failure and Misleading Success
- Designing Useful Error Messages
11The Development Environment9 topics
- Editors, IDEs, and Language Tooling
- Terminals, Shells, and Command-Line Programs
- Project Structure and Repository Layout
- Installing and Selecting Toolchain Versions
- Running Programs and Automated Checks Locally
- Configuration Files and Environment Variables
- Formatters, Linters, and Static Checks
- Debuggers and Interactive Inspection
- Reproducible Setup for a New Contributor
12Reading and Debugging Code11 topics
- Finding Entry Points and Following Execution
- Reading Unfamiliar Functions and Modules
- Understanding Tests as Behavioral Examples
- Reproducing a Defect Reliably
- Reducing a Problem to a Minimal Example
- Breakpoints, Stepping, and Variable Inspection
- Reading Stack Traces and Error Reports
- Forming and Testing Debugging Hypotheses
- Finding the First Incorrect State
- Separating Symptoms from Root Causes
- Adding a Regression Test After a Fix
13Version Control and Collaborative Changes11 topics
- Repositories, Commits, and Change History
- Working Trees, Staging, and Diffs
- Writing Focused Commits
- Branches and Parallel Work
- Merging and Rebasing as Different History Operations
- Resolving Conflicts with Behavioral Checks
- Pull Requests and Reviewable Change Sets
- Trunk-Based and Branch-Based Workflows
- Tags and Release References
- Reverting Changes and Recovering Safely
- Using History and Bisection to Investigate Defects
14Dependencies, Packages, and Configuration10 topics
- Direct and Transitive Dependencies
- Package Manifests and Lockfiles
- Version Constraints and Reproducible Resolution
- Evaluating a Library Before Adoption
- Dependency Updates and Compatibility Checks
- Separating Application Configuration from Code
- Validating Configuration at Startup
- Handling Secrets Outside Source Control
- Dependency Provenance and Supply-Chain Exposure
- Removing Unused and Abandoned Dependencies
Stage 2
Requirements & Design
What to build, and how to shape it
12 modules · 127 topics
15Understanding Problems and Stakeholders10 topics
- Starting with a Problem Rather Than a Feature
- Identifying Users and Other Affected Groups
- Understanding Existing Workflows
- Interviews, Observation, and Evidence Gathering
- Separating Stated Requests from Underlying Needs
- Stakeholder Conflicts and Competing Priorities
- Current-State and Desired-State Descriptions
- Assumptions, Unknowns, and Open Questions
- Defining Outcomes and Success Criteria
- Deciding Whether Software Is the Right Intervention
16Requirements Specification and Validation11 topics
- Functional Requirements and Business Rules
- User Stories and Use Cases
- Acceptance Criteria and Concrete Examples
- Preconditions, Postconditions, and Exceptional Cases
- Writing Clear and Testable Requirements
- Ambiguity, Inconsistency, and Missing Behavior
- Prioritizing Requirements and Defining Scope
- Prototypes as Requirements-Discovery Tools
- Requirements Reviews with Stakeholders
- Traceability from Need to Implementation and Test
- Managing Requirement Changes and Their Impact
17Quality Attributes and Engineering Constraints11 topics
- Functional Correctness vs. Quality of Service
- Reliability and Availability Requirements
- Performance, Latency, and Throughput
- Scalability and Capacity Expectations
- Security and Privacy Requirements
- Maintainability, Modifiability, and Testability
- Usability and Accessibility
- Compatibility and Portability
- Cost, Schedule, and Resource Constraints
- Writing Measurable Quality-Attribute Scenarios
- Resolving Trade-Offs Between Quality Goals
18Modeling Domains and Workflows10 topics
- Shared Vocabulary and Domain Concepts
- Actors, Roles, and System Interactions
- Entities, Values, and Relationships
- Business Rules and Domain Invariants
- State Machines and Lifecycle Models
- Activity Flows and Decision Points
- Sequence Diagrams and Interaction Scenarios
- Context Boundaries and Different Meanings of the Same Term
- Modeling Exceptions and Alternative Paths
- Keeping Models Useful as the System Changes
19Planning Incremental Delivery10 topics
- Turning Requirements into Small Deliverable Slices
- Vertical Slices vs. Technical-Layer Tasks
- Prioritizing by Value, Risk, and Dependency
- Discovery Work and Time-Bounded Technical Spikes
- Minimum Useful Releases
- Making Work Ready for Implementation
- Defining What Done Means
- Handling Uncertainty in Estimates
- Limiting Work in Progress
- Reviewing Outcomes and Replanning from Evidence
20Readable and Maintainable Code11 topics
- Names That Express Intent
- Small, Cohesive Functions
- Clear Control Flow and Limited Nesting
- Consistent Conventions and Formatting
- Comments That Explain Decisions and Constraints
- Removing Dead Code and Misleading Abstractions
- Duplication vs. Premature Generalization
- Explicit Dependencies and Predictable Behavior
- Separating Domain Rules from Technical Plumbing
- Local Reasoning and Reducing Cognitive Load
- Recognizing Code Smells Without Treating Them as Proof
21Modular Design and Interfaces11 topics
- Modules as Units of Responsibility
- Cohesion and Coupling
- Information Hiding and Encapsulation
- Public Contracts and Private Implementation
- Abstract Data Types
- Dependency Direction and Dependency Inversion
- Composition and Replaceable Components
- Designing Stable Module Boundaries
- Avoiding Cyclic Dependencies
- Balancing Reuse with Independent Change
- Testing Modules Through Their Contracts
22Programming Paradigms and Design Choices11 topics
- Procedural Decomposition
- Object-Oriented Modeling
- Objects, Responsibilities, and Collaboration
- Inheritance and Substitutability
- Composition vs. Inheritance
- Functional Decomposition and Pure Functions
- Immutability and Transformation Pipelines
- Declarative vs. Imperative Code
- Generic Programming and Reusable Abstractions
- Combining Paradigms Within One System
- Choosing a Paradigm for the Problem, Not the Fashion
23Design Patterns and Their Trade-Offs10 topics
- Patterns as Reusable Design Ideas
- Strategy and Interchangeable Behavior
- Adapter and Boundary Translation
- Factory and Controlled Object Creation
- Decorator and Composable Responsibilities
- Observer and Change Notification
- Command and Explicit Operations
- State and Behavior Across Lifecycle Stages
- Dependency Injection and the Composition Root
- Pattern Overuse and Accidental Complexity
24Software Architecture Fundamentals11 topics
- Architecture as High-Impact Design Decisions
- System Context and Architectural Boundaries
- Components, Connectors, and Responsibilities
- Static Structure and Runtime Behavior
- Deployment Views and Execution Environments
- Quality Attributes as Architectural Drivers
- Architectural Constraints and Assumptions
- Trade-Off Analysis and Risk Identification
- Architecture Decision Records
- Prototypes for Testing Architectural Assumptions
- Architecture Evaluation and Evolution
25Architectural Styles and System Boundaries10 topics
- Layered Architecture
- Modular Monoliths
- Client-Server Systems
- Ports and Adapters
- Event-Driven Architecture
- Service-Oriented Decomposition
- Microservices and Their Coordination Costs
- Data-Centered and Pipeline Architectures
- Synchronous vs. Asynchronous Boundaries
- Choosing the Simplest Architecture That Meets the Requirements
26API Design and Contracts11 topics
- APIs as Agreements Between Components
- Resource-Oriented and Operation-Oriented Interfaces
- Naming, Consistency, and Discoverability
- Request and Response Models
- Validation Rules and Error Contracts
- Pagination, Filtering, and Sorting
- Idempotent Operations and Retry-Safe Contracts
- Versioning and Backward Compatibility
- API Schemas and Machine-Readable Descriptions
- Public, Partner, and Internal APIs
- Designing Interfaces for Real Consumer Workflows
Stage 3
Data & Distributed Systems
Data that stays right across machines
10 modules · 107 topics
27Application Data Modeling10 topics
- Translating Domain Concepts into Stored Data
- Identity, Keys, and Relationships
- Required, Optional, and Derived Values
- Enforcing Data Invariants
- Normalization and Intentional Denormalization
- Historical Records and Changing Business Facts
- Modeling Status, Ownership, and Lifecycle
- Separating Internal Models from External Representations
- Schema Evolution and Migration Planning
- Avoiding Data Models That Encode Accidental Assumptions
28Relational Persistence and Querying11 topics
- Tables, Rows, and Relational Structure
- Creating, Reading, Updating, and Deleting Records
- Selecting, Filtering, and Ordering Data
- Joins and Relationship Traversal
- Aggregation and Grouping
- Constraints and Referential Integrity
- Parameterized Queries
- Indexes and Query-Access Patterns
- Object-Relational Mapping and Its Trade-Offs
- Connection Management and Query Boundaries
- Diagnosing Excessive Queries and Inefficient Data Access
29Files, Formats, and Alternative Storage10 topics
- Text and Binary Data Formats
- Serialization and Deserialization
- Schema Validation and Format Compatibility
- Safe File Paths and File Operations
- Streaming Data vs. Loading Everything into Memory
- Document Stores and Aggregate-Oriented Data
- Key-Value Stores and Simple Access Patterns
- Object Storage for Files and Large Blobs
- Embedded Storage and Local Application State
- Choosing Storage by Access, Consistency, and Operational Needs
30Transactions and Data Consistency11 topics
- Atomicity, Consistency, Isolation, and Durability
- Transaction Boundaries and Business Operations
- Read and Write Anomalies
- Isolation Levels and Their Trade-Offs
- Optimistic and Pessimistic Concurrency Control
- Lost Updates and Concurrent Modification
- Constraints as a Last Line of Defense
- Commit, Rollback, and Failure Recovery
- Handling Duplicate Requests and Repeated Effects
- Coordinating Database Changes with External Side Effects
- Testing Consistency Under Concurrent Access
31Concurrency Within an Application11 topics
- Concurrency vs. Parallelism
- Processes, Threads, and Tasks
- Shared Memory and Message Passing
- Race Conditions and Nondeterministic Behavior
- Atomicity and Visibility of Changes
- Locks, Mutexes, and Critical Sections
- Deadlock, Livelock, and Starvation
- Thread-Safe Data Structures
- Immutable Data and Ownership-Based Designs
- Cancellation and Task Lifetimes
- Testing Concurrent Code and Its Interleavings
32Networked Applications11 topics
- Clients, Servers, and Request Lifecycles
- Addresses, Ports, and Name Resolution
- Connections, Streams, and Message Boundaries
- HTTP Methods, Status Codes, and Headers
- Stateless Requests and Stateful Sessions
- TLS and Secure Transport as Application Requirements
- Timeouts, Connection Failures, and Partial Responses
- Connection Pools and Resource Limits
- Proxies, Gateways, and Load Balancers
- Network Latency and the Cost of Remote Calls
- Diagnosing Application-Level Network Failures
33Asynchronous Work and Background Processing11 topics
- Blocking and Nonblocking Work
- Futures, Promises, and Asynchronous Results
- Event Loops and Task Scheduling
- Queues and Background Workers
- Job State and Progress Reporting
- Retries, Backoff, and Retry Limits
- Duplicate Delivery and Idempotent Handlers
- Ordering Requirements and Parallel Workers
- Backpressure and Bounded Queues
- Dead-Letter Handling and Failed-Job Recovery
- Cancellation, Shutdown, and Unfinished Work
34Distributed Application Design11 topics
- Why Remote Components Fail Independently
- Partial Failure and Uncertain Outcomes
- Replication and Multiple Copies of State
- Strong and Eventual Consistency
- Consistency and Availability During Network Partitions
- Ordering, Clocks, and Causality
- Delivery Guarantees vs. Processing Effects
- Coordinating Work Across Service Boundaries
- Sagas and Compensating Actions
- Transactional Outbox and Reliable Event Publication
- Choosing What Must Be Distributed and What Should Stay Together
35User Interfaces and Interaction Engineering11 topics
- Connecting User Tasks to Interface Behavior
- Separating Presentation from Domain Logic
- UI State and State Transitions
- Forms, Validation, and Error Recovery
- Loading, Empty, Success, and Failure States
- Responsive Behavior Across Devices
- Semantic Structure and Assistive Technology
- Keyboard Navigation and Focus Management
- Localization, Text Direction, and Locale-Sensitive Data
- Optimistic Updates and Their Failure Cases
- Testing Usability and Accessibility with Real Workflows
36Integrating External Services10 topics
- Evaluating an External API or SDK
- Translating External Models at System Boundaries
- Credentials, Permissions, and Service Configuration
- Rate Limits and Usage Quotas
- Webhooks and Incoming Event Validation
- Handling Provider Outages and Degraded Responses
- Sandboxes, Test Accounts, and Contract Differences
- Avoiding Duplicate External Actions
- Monitoring Integration Health and Cost
- Provider Changes, Fallbacks, and Exit Strategies
Stage 4
Security & Testing
Proof it works, and stays safe
11 modules · 115 topics
37Secure Software Construction12 topics
- Trust Boundaries and Untrusted Inputs
- Secure Defaults and Least Privilege
- Threat Modeling for a Feature or Service
- Input Validation vs. Output Encoding
- Preventing Injection with Safe Interfaces
- Safe Handling of Files, Uploads, and Paths
- Protecting State-Changing Requests
- Restricting Server-Side Requests and External Destinations
- Secrets Handling and Safe Logging
- Dependency Vulnerabilities and Remediation
- Security Tests in the Development Workflow
- Responding to a Reported Vulnerability
38Identity, Authentication, and Authorization10 topics
- Identity, Authentication, and Authorization as Separate Concerns
- Users, Service Accounts, and Machine Identities
- Sessions, Tokens, and Credential Lifetimes
- Integrating Established Identity Providers
- Password Handling with Established Security Libraries
- Roles, Permissions, and Policy-Based Access
- Object-Level and Tenant-Level Authorization
- Enforcing Access Checks on the Trusted Side
- Account Recovery, Revocation, and Logout Behavior
- Auditing Sensitive Actions and Permission Changes
39Privacy and the Data Life Cycle10 topics
- Identifying Personal and Sensitive Data
- Data Minimization and Purpose Boundaries
- Mapping Where Data Enters, Moves, and Leaves
- Retention, Deletion, and Backup Implications
- Redaction and Safe Diagnostic Data
- Pseudonymization vs. Anonymization
- Privacy-Preserving Test Data
- Designing User Controls for Data Access and Export
- Preventing Cross-Tenant Data Exposure
- Translating Privacy Obligations into Engineering Requirements
40Test Strategy and Test Design11 topics
- Verification vs. Validation
- Testing as Evidence Rather Than Proof of Perfection
- Risk-Based Test Prioritization
- Unit, Integration, System, and Acceptance Tests
- Example-Based Test Design
- Equivalence Classes and Boundary Values
- Decision Tables and State-Transition Tests
- Happy Paths, Failure Paths, and Recovery Paths
- Test Data and Environment Control
- Balancing Test Speed, Fidelity, and Maintenance Cost
- Defining a Test Strategy for a Specific System
41Unit Testing and Testable Design11 topics
- Testing a Small Unit Through Observable Behavior
- Arrange, Act, and Assert
- Naming Tests as Behavioral Statements
- Independent and Deterministic Tests
- Stubs, Fakes, Mocks, and Spies
- Controlling Time, Randomness, and External Dependencies
- Testing Errors and Exceptional Conditions
- Parameterized Tests
- Property-Based Testing
- Test-Driven Development and Its Trade-Offs
- Avoiding Tests That Mirror the Implementation
42Integration, Contract, and End-to-End Testing11 topics
- Testing Collaborating Components
- Integration Tests with Real Persistence
- Contract Tests Between Producers and Consumers
- API-Level Functional Tests
- End-to-End User Journeys
- Test Environments and Representative Configuration
- Fixtures, Seed Data, and Cleanup
- Testing Background Work and Eventual Outcomes
- Detecting and Controlling Flaky Tests
- Interpreting Failures Across Multiple System Layers
- Keeping Broad Tests Focused on High-Value Behavior
43Testing Quality Attributes10 topics
- Load, Stress, and Endurance Tests
- Measuring Latency Distributions and Throughput
- Capacity Limits and Saturation Behavior
- Reliability and Recovery Tests
- Fault Injection in Controlled Environments
- Security and Authorization Tests
- Accessibility and Compatibility Tests
- Migration and Data-Integrity Tests
- Establishing Baselines and Detecting Regressions
- Distinguishing Laboratory Results from Production Guarantees
44Diagnosing Complex Failures10 topics
- Reconstructing a Failure from Incomplete Evidence
- Correlating Logs, Metrics, and Traces
- Separating Code, Data, Configuration, and Environment Causes
- Reproducing Production Conditions Safely
- Investigating Intermittent and Timing-Dependent Defects
- Diagnosing Memory Leaks and Resource Exhaustion
- Finding Bottlenecks with Profilers
- Investigating Recent Changes with Controlled Comparisons
- Testing a Root-Cause Explanation Against the Evidence
- Verifying a Fix Beyond the Original Failure Case
45Refactoring and Technical Debt11 topics
- Refactoring vs. Changing Behavior
- Establishing a Safety Net Before Restructuring
- Extracting Functions and Modules
- Simplifying Conditional Logic
- Improving Names and Data Structures
- Removing Duplication Without Premature Abstraction
- Introducing Seams Around Difficult Dependencies
- Recognizing Architectural and Operational Debt
- Intentional Trade-Offs vs. Uncontrolled Deterioration
- Prioritizing Debt by Risk and Change Cost
- Refactoring Incrementally While Continuing Delivery
46Reasoning About Correctness9 topics
- Specifications as Statements of Required Behavior
- Preconditions and Postconditions
- Representation Invariants
- Loop Invariants and Termination Arguments
- State Machines and Invalid Transitions
- Making Invalid States Harder to Represent
- Refinement from Abstract Rules to Concrete Code
- Model Checking as a Verification Technique
- What Formal Reasoning Can and Cannot Guarantee
47Code Review and Static Quality Checks10 topics
- Reviewing for Correctness, Clarity, and Maintainability
- Preparing a Change for Efficient Review
- Distinguishing Blocking Issues from Preferences
- Reviewing Tests Alongside Implementation
- Checking Error Handling and Failure Behavior
- Reviewing Security and Data-Handling Boundaries
- Automated Formatting and Linting
- Type Checking and Static Analysis
- Interpreting Warnings and False Positives
- Giving Actionable Feedback and Resolving Disagreements
Stage 5
Delivery & Operations
From merge to production, on call
8 modules · 86 topics
48Build Systems and Software Artifacts10 topics
- Source Inputs, Build Steps, and Outputs
- Dependency Graphs and Incremental Builds
- Toolchain Pinning and Repeatable Builds
- Build-Time vs. Runtime Configuration
- Packaging Libraries, Applications, and Services
- Container Images as Deployable Artifacts
- Artifact Versioning and Provenance
- Software Bills of Materials
- Build Caches and Cache Correctness
- Producing and Promoting the Same Verified Artifact
49Continuous Integration and Delivery Pipelines10 topics
- Integrating Small Changes Frequently
- Pipeline Stages and Their Responsibilities
- Fast Feedback and Early Failure Detection
- Automated Tests and Quality Gates
- Branch Protection and Required Checks
- Pipeline Permissions and Secret Boundaries
- Artifact Storage and Promotion
- Parallel Work and Pipeline Dependencies
- Handling Failing and Flaky Pipelines
- Maintaining Delivery Automation as Production Code
50Environments, Deployment, and Release Management12 topics
- Development, Test, Staging, and Production Environments
- Environment Parity and Configuration Differences
- Deployment vs. Release
- Release Readiness and Change Approval
- Feature Flags and Controlled Exposure
- Rolling, Blue-Green, and Canary Deployments
- Database Migrations During Application Rollout
- Health Checks and Startup Validation
- Rollback vs. Roll-Forward Recovery
- Release Notes and Operational Communication
- Verifying User-Visible Behavior After Deployment
- Retiring Flags and Temporary Release Mechanisms
51Observability and Production Feedback11 topics
- Designing Software to Explain Its Behavior
- Structured Logs and Correlation Identifiers
- Metrics, Counters, Gauges, and Histograms
- Distributed Tracing and Request Paths
- User-Centered Indicators and Technical Indicators
- Instrumenting Critical Business Flows
- High-Cardinality Data and Telemetry Cost
- Dashboards That Support Specific Decisions
- Actionable Alerts and Alert Fatigue
- Protecting Sensitive Data in Telemetry
- Turning Production Evidence into Engineering Work
52Reliability, Recovery, and Incident Response11 topics
- Defining Reliability from the User's Perspective
- Service-Level Indicators and Objectives
- Error Budgets and Reliability Trade-Offs
- Timeouts, Retries, and Cascading Failure
- Circuit Breakers, Bulkheads, and Load Shedding
- Graceful Degradation and Reduced Functionality
- Backup, Restore, and Recovery Verification
- On-Call Readiness and Incident Roles
- Stabilization, Communication, and Recovery
- Blameless Post-Incident Analysis
- Turning Incident Findings into Verified Improvements
53Performance and Resource Efficiency11 topics
- Measuring Before Optimizing
- Latency, Throughput, and Resource Consumption
- Averages, Percentiles, and Tail Behavior
- CPU-Bound and I/O-Bound Work
- Algorithmic Improvements vs. Local Optimizations
- Caching and Cache Invalidation
- Batching, Pagination, and Streaming
- Reducing Database and Network Round Trips
- Memory Use, Allocation, and Resource Pooling
- Controlling Concurrency and Avoiding Overload
- Balancing Speed, Cost, Energy Use, and Complexity
54Legacy Systems and Maintenance11 topics
- Understanding a System Without Complete Documentation
- Corrective, Adaptive, Preventive, and Perfective Maintenance
- Recovering Intent from Code, Tests, and History
- Characterization Tests for Existing Behavior
- Identifying Hidden Dependencies
- Working Around Unsupported Components
- Incremental Replacement and the Strangler Approach
- Data Migration and Reconciliation
- Managing Old and New Implementations Together
- Avoiding Unnecessary Full Rewrites
- Planning Safe Retirement and Decommissioning
55Compatibility and Software Evolution10 topics
- Source, Binary, Behavioral, and Data Compatibility
- Public Contracts and Accidental Contracts
- Semantic Versioning and Its Limits
- Additive Changes and Breaking Changes
- Deprecation Policies and Migration Guidance
- API and Event-Schema Evolution
- Expand-and-Contract Database Changes
- Mixed-Version Systems During Rollout
- Preserving User Data and Existing Workflows
- Testing Upgrade, Downgrade, and Recovery Paths
Stage 6
Professional Practice
The team side of the job
6 modules · 61 topics
56Documentation and Knowledge Transfer9 topics
- Documentation for Users, Developers, and Operators
- README Files and Getting-Started Paths
- API References and Practical Examples
- Architecture Views and Decision Records
- Runbooks and Troubleshooting Guides
- Explaining Assumptions, Constraints, and Known Limits
- Documentation Close to the Code
- Keeping Documentation Current Through the Change Process
- Handoffs, Onboarding, and Reducing Single-Person Dependency
57Teamwork and Engineering Communication10 topics
- Shared Ownership and Clear Responsibilities
- Working with Product Managers and Designers
- Communicating with Nontechnical Stakeholders
- Writing Useful Issues and Technical Proposals
- Design Reviews Before Expensive Commitments
- Pairing, Mentoring, and Collaborative Problem Solving
- Asynchronous Collaboration and Decision Visibility
- Managing Dependencies Between Teams
- Escalating Risks and Blockers Early
- Disagreeing Constructively and Recording Decisions
58Engineering Management and Software Economics11 topics
- Estimating Effort Under Uncertainty
- Scope, Time, Cost, and Quality Trade-Offs
- Risk Identification and Contingency Planning
- Build vs. Buy vs. Reuse
- Total Cost of Ownership
- Opportunity Cost and Cost of Delay
- Capacity Planning Without Treating People as Interchangeable
- Managing Technical and Organizational Dependencies
- Forecasting with Ranges and Evidence
- Communicating Progress Through Outcomes and Risks
- Knowing When to Continue, Simplify, or Stop
59Process Improvement and Engineering Quality10 topics
- Processes as Tools Rather Than Goals
- Agile Principles and Feedback Cycles
- Scrum, Kanban, and Context-Appropriate Practices
- Work in Progress, Queues, and Flow
- Retrospectives and Small Improvement Experiments
- Defect Prevention vs. Defect Detection
- Delivery Speed, Change Failure, and Recovery Measures
- Avoiding Vanity Metrics and Perverse Incentives
- Quality Assurance Across the Life Cycle
- Improving Systems of Work Without Blaming Individuals
60Ethics and Professional Responsibility10 topics
- Public Interest and Responsibility for Software Impact
- Safety-Critical Contexts and Limits of Competence
- Honest Claims About Capabilities and Limitations
- Accessibility, Exclusion, and Unequal User Impact
- Privacy, Consent, and Responsible Data Use
- Intellectual Property and Open-Source License Awareness
- Conflicts of Interest and Professional Independence
- Reporting Risks and Unsafe Practices
- Sustainable Choices and Long-Term Stewardship
- Accountability for Decisions Made with Automated Tools
61AI-Assisted Software Engineering11 topics
- Appropriate Uses for Code-Generation and Assistance Tools
- Providing Relevant Context and Explicit Constraints
- Decomposing Work into Reviewable Tasks
- Checking Generated Code Against Actual Requirements
- Verifying APIs, Dependencies, and Technical Claims
- Reviewing Security, Privacy, and Licensing Exposure
- Using Independent Tests and Reference Behavior
- Bounded Tool Access and Human Approval
- Avoiding Automation of Unverified Assumptions
- Measuring Whether Assistance Improves Quality and Delivery
- Maintaining Human Ownership of the Final Result
Stage 7
Integrated Projects
Ten projects, start to finish
1 module · 10 topics
62Integrated Software Engineering Projects10 topics
- A Command-Line Application with Validation and Automated Tests
- A Reusable Library with Stable Contracts and Documentation
- A Data-Backed Application with Explicit Business Rules
- An API Service with Authentication and Authorization Tests
- A Background-Job System That Handles Retries and Duplicates
- An Accessible User Interface Connected to a Tested Service
- An External-Service Integration with Controlled Failure Handling
- A Legacy Refactoring with Characterization and Regression Tests
- A Production Release with Observability and a Recovery Exercise
- A Complete Software Product from Requirements to Maintenance Plan
Fifteen minutes.Every day.
- 1
A lesson fits a lunch break
One idea at a time, in short slides. A whole lesson takes about fifteen minutes.
- 2
Practice with instant feedback
Questions sit inside the lesson. Answer one and see right away whether you got it.
- 3
A streak that brings you back
A lesson a day keeps the streak alive. Small, steady sessions carry you through.
- 1
A lesson fits a lunch break
One idea at a time, in short slides. A whole lesson takes about fifteen minutes.
- 2
Practice with instant feedback
Questions sit inside the lesson. Answer one and see right away whether you got it.
- 3
A streak that brings you back
A lesson a day keeps the streak alive. Small, steady sessions carry you through.
From first commit to senior.
Self-taught coders filling the gaps
Bootcamp grads after a first job
Juniors working toward senior
Where this course leads.
The job this course is built around, and how people get into it.
On the job
- Break a feature into code other people can maintain
- Review a teammate's change and find the bug before users do
- Keep a system fast and running as it grows
How people get in
A degree helps but is not required everywhere. Employers look hard at real projects, code on GitHub and a technical interview.
Be first in line.
Early access for individuals, pilots for teams. Tell us who's learning.
enterprise@astratrainer.com