Commits To Pipelines

How to Design Developer Platforms & CI/CD Systems

47 modules

190 lessons

—

Part 1

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Commits to Pipelines"Sign in
How to Use This CourseSign in
The Incremental Ladder (Step 0 -> Step 7)Sign in
The Course LensesSign in
Diagram Legend and Notation TypesSign in

Part 2

Version Control as the Source of Truth

Version Control as the Source of TruthSign in
Why VCS Anchors CI/CDSign in
Changesets, Diffs, and Commit HistorySign in
Branches, Tags, and Release LinesSign in

Part 3

Branching Models and Workflows

Branching Models and WorkflowsSign in
Trunk-Based vs Git-Flow-Like ModelsSign in
Feature, Release, and Hotfix BranchesSign in
Trade-Offs: Speed, Stability, and Workflow ComplexitySign in

Part 4

Repository Structures: Mono vs Poly

Repository Structures: Mono vs PolySign in
Monorepos, Polyrepos, and HybridsSign in
Impact on Builds, Pipelines, and ToolingSign in
Code Ownership and ModularizationSign in

Part 5

Commit Discipline and Code Review

Commit Discipline and Code ReviewSign in
Atomic Changes and Commit HygieneSign in
Review Workflows and Approval PatternsSign in
Messages, Issue Links, and TraceabilitySign in

Part 6

Diagramming Developer Workflows

Diagramming Developer WorkflowsSign in
Commit-to-Merge FlowsSign in
Branching Diagrams and Release TrainsSign in
Mapping Repos to Teams and ServicesSign in

Part 7

Build Systems and Toolchains

Build Systems and ToolchainsSign in
Build Tools and OrchestrationSign in
Incremental vs Full BuildsSign in
Reproducibility and DeterminismSign in

Part 8

Dependency Management

Dependency ManagementSign in
Manifests and LockfilesSign in
Version Ranges vs PinningSign in
Caches, Registries, and SecuritySign in

Part 9

Artifact Types and Packaging

Artifact Types and PackagingSign in
Artifact FamiliesSign in
Versioning and ImmutabilitySign in
Deployable UnitsSign in

Part 10

Artifact Repositories and Promotion

Artifact Repositories and PromotionSign in
Repositories for Packages, Images, and BinariesSign in
Retention and Immutability SemanticsSign in
Promotion FlowsSign in

Part 11

Build & Artifact Observability

Build & Artifact ObservabilitySign in
Build Health MetricsSign in
Dependency Graph Visibility and BOMsSign in
Hotspots and BottlenecksSign in

Part 12

CI Fundamentals

CI FundamentalsSign in
CI vs Nightly BuildsSign in
Builds and Tests on Every ChangeSign in
Failing Fast as a System PropertySign in

Part 13

Pipeline-as-Code

Pipeline-as-CodeSign in
Declarative vs Imperative PipelinesSign in
Shared Libraries and TemplatesSign in
Versioning and Testing Pipeline ConfigurationsSign in

Part 14

Triggering and Fan-Out

Triggering and Fan-OutSign in
Trigger TypesSign in
Fan-Out for Multi-Service ChangeSign in
Storming and Redundancy ControlSign in

Part 15

Pipeline Stages and DAGs

Pipeline Stages and DAGsSign in
Stage DesignSign in
DAG ModelingSign in
Resource ManagementSign in

Part 16

CI Infrastructure

CI InfrastructureSign in
Runners, Agents, and ExecutorsSign in
Scaling BuildsSign in
Multi-Tenant CI ClustersSign in

Part 17

CI Health, Limits, and Anti-Patterns

CI Health, Limits, and Anti-PatternsSign in
Broken Main and Red BuildsSign in
Long Pipelines and Developer FrustrationSign in
Keeping CI GreenSign in

Part 18

Test Taxonomy and the Test Pyramid

Test Taxonomy and the Test PyramidSign in
Layers of TestsSign in
Pyramid vs Ice Cream ConeSign in
Choosing a Balanced PortfolioSign in

Part 19

Designing Testable Systems

Designing Testable SystemsSign in
Seams, Contracts, and Dependency InjectionSign in
Test DoublesSign in
Contract Tests for APIs and ServicesSign in

Part 20

Data, Environments, and Isolation

Data, Environments, and IsolationSign in
Test Data ManagementSign in
Ephemeral vs Shared EnvironmentsSign in
Cleanup and ContainmentSign in

Part 21

Test Execution in Pipelines

Test Execution in PipelinesSign in
Parallelization and ShardingSign in
Change-Impact SelectionSign in
Smoke vs Regression vs Full SweepSign in

Part 22

Flaky Tests and Reliability

Flaky Tests and ReliabilitySign in
Detecting and Triage WorkflowsSign in
Quarantine and ThresholdsSign in
Culture and ToolingSign in

Part 23

Quality Gates and Metrics

Quality Gates and MetricsSign in
Coverage with CaveatsSign in
Quality GatesSign in
Balancing Speed and QualitySign in

Part 24

From CI to CD

From CI to CDSign in
Continuous Delivery vs Continuous DeploymentSign in
Promotion-Based PipelinesSign in
Manual Gates vs Full AutomationSign in

Part 25

Environment Topologies and Promotion

Environment Topologies and PromotionSign in
Environment Lanes: dev, test, staging, prod and what "prod-like" is actually forSign in
Promote vs Rebuild: artifact integrity versus environment-specific compilation and the risks of divergenceSign in
Drift and Drift Detection: preventing the environment boundary from silently changing the systemSign in

Part 26

Deployment Mechanisms

Deployment MechanismsSign in
Push vs Pull Deployments: control boundaries and how failure propagatesSign in
Deployment Primitives: conceptual orchestrators, rollout units, and state reconciliationSign in
Configuration and Secret Injection: making runtime variability explicit, auditable, and reversibleSign in

Part 27

Release Strategies

Release StrategiesSign in
Rolling, Blue-Green, Canary: choosing a rollout topology that matches your failure toleranceSign in
Feature Flags and Dark Launches: decoupling deploy from release to reduce blast radiusSign in
Rollback and Roll-Forward: designing recovery paths that work under stressSign in

Part 28

Progressive Delivery and Observability

Progressive Delivery and ObservabilitySign in
Guardrails and SLO-Based Safety: using live signals as release constraintsSign in
Automated rollback triggers: thresholds, noise, and avoiding control-plane flappingSign in
Release health views: connecting deploy events to user impact with minimal ambiguitySign in

Part 29

Multi-Service and Multi-Region Releases

Multi-Service and Multi-Region ReleasesSign in
Coordinated Microservice Releases: dependency ordering and minimizing cross-service deadlocksSign in
Compatibility and Contracts: version skew, backward compatibility, and safe partial rolloutSign in
Region-Wise Rollouts: global coordination, regional blast radius, and operational pacingSign in

Part 30

What Is an Internal Developer Platform (IDP)?

What Is an Internal Developer Platform (IDP)?Sign in
Platform as Product for Developers: making the "easy path" the safe and supported pathSign in
Platform Layers: CI/CD, runtime, observability, catalogs and how they compose into one experienceSign in
Reducing Cognitive Load: avoiding "YAML fatigue" by moving complexity behind stable interfacesSign in

Part 31

Golden Paths and Paved Roads

Golden Paths and Paved RoadsSign in
Opinionated Defaults: why standardization is a reliability strategy, not only a productivity oneSign in
One Obvious Way: defining a canonical service lifecycle from build to deploySign in
Flexibility Without Fragmentation: supporting exceptions without creating a second platformSign in

Part 32

Scaffolding and Service Creation

Scaffolding and Service CreationSign in
Service Templates: repo + pipeline + infra skeleton as a repeatable boundary packageSign in
Bootstrapped Security and Observability: shipping "secure and observable by default" as platform policySign in
Onboarding and First-10-Minutes Experience: designing time-to-first-success as a platform KPISign in

Part 33

Developer Portals and Catalogs

Developer Portals and CatalogsSign in
Ownership and Metadata: service catalogs as the map that makes accountability possibleSign in
UI for Pipelines, Deploys, Incidents, Docs: making platform state visible and navigableSign in
Integrating Runbooks and ADRs: connecting automation to human decision-making during incidentsSign in

Part 34

Platform Extensibility

Platform ExtensibilitySign in
Plugin Models: extension without forking the platform's coreSign in
Integrating Third-Party Tools: scanners, APM, and ecosystem components as controlled dependenciesSign in
Guardrails on Customization: preventing local optimization from breaking platform invariantsSign in

Part 35

Platform Metrics and Developer Experience

Platform Metrics and Developer ExperienceSign in
Delivery Performance Metrics: lead time, deploy frequency, change fail rate, MTTR as system outcomesSign in
DX Metrics: wait time, friction, satisfaction and how they predict platform adoptionSign in
Metrics into Roadmaps: using evidence to choose investments and retire low-value complexitySign in

Part 36

Governance and Policy in Pipelines

Governance and Policy in PipelinesSign in
Policy-as-Code Boundaries: expressing required stages and constraints in machine-enforceable formSign in
Approvals and Separation of Duties: designing human checks that resist collusion and reduce mistake riskSign in
Least Privilege in CI/CD: minimizing what pipelines can do and constraining blast radiusSign in

Part 37

Secrets, Credentials, and Supply Chain Security

Secrets, Credentials, and Supply Chain SecuritySign in
Secret Storage, Rotation, Injection: treating secret movement as a privileged data planeSign in
Provenance and Signing: code signing, artifact signing, and why "who built this" mattersSign in
Scanning Code, Dependencies, Images: catching supply-chain risk where it enters the pipelineSign in

Part 38

Compliance Requirements in CI/CD

Compliance Requirements in CI/CDSign in
Traceability from Commit to Deploy: constructing an evidence chain that survives audits and incidentsSign in
Change Management and Audit Trails: approvals, justifications, and immutable records as system featuresSign in
Evidence Generation: building automated compliance outputs without turning governance into manual toilSign in

Part 39

Guardrails vs Gates

Guardrails vs GatesSign in
Preventative vs Detective Controls: choosing where to stop bad change versus where to detect and respondSign in
Soft vs Hard Enforcement: rollout strategies that increase safety without creating a shadow processSign in
Autonomy vs Control: maintaining developer flow while meeting regulatory and security obligationsSign in

Part 40

Incident & Vulnerability Response via Pipelines

Incident & Vulnerability Response via PipelinesSign in
Emergency Change and Break Glass: designing exceptional paths that remain auditable and safeSign in
Coordinated Patching via CI/CD: scaling response across fleets without losing correctnessSign in
Backports and Multiple Release Lines: keeping long-lived versions secure without endless divergenceSign in

Part 41

Platform Architecture: Control Planes and Data Planes

Platform Architecture: Control Planes and Data PlanesSign in
Control Plane Concepts: configuration, policy, and state as the platform's governing surfaceSign in
Data Plane Workloads: builds, tests, deployments and the isolation requirements they imposeSign in
One Engine or Many: composing pipeline engines and clusters without losing a unified experienceSign in

Part 42

Multi-Tenancy and Scale in CI/CD

Multi-Tenancy and Scale in CI/CDSign in
Tenancy Models: team, project, org boundaries and what can fail togetherSign in
Fair Scheduling and Noisy Neighbor Control: quotas, prioritization, and protecting critical pathsSign in
Rate Limits and Resource Governance: preventing platform overload from becoming company-wide outageSign in

Part 43

Platform Teams and Operating Models

Platform Teams and Operating ModelsSign in
Platform-as-a-Product: roadmaps, support, and lifecycle management for internal usersSign in
Roles and Interfaces: platform PMs, SREs, DX engineers, advocates and how responsibility is partitionedSign in
Feedback Loops to Roadmap: turning developer pain into prioritized platform workSign in

Part 44

Integrating CI/CD with the Rest of the Ecosystem

Integrating CI/CD with the Rest of the EcosystemSign in
Observability, Incidents, On-Call: connecting delivery events to operational realitySign in
Tickets, Docs, Flags, Runtime Config: integrating adjacent control systems without duplicationSign in
Data and AI Workflows in CI/CD Contexts: extending pipeline thinking beyond application code (conceptual)Sign in

Part 45

Migration and Modernization

Migration and ModernizationSign in
From Scripts to Standard Pipelines: defining target patterns and migrating without halting deliverySign in
Incremental Migration of Legacy Apps and Repos: sequencing changes to preserve trustSign in
Coexistence Strategies: running old and new platforms in parallel without fragmenting governanceSign in

Part 46

Case-Style Reference Architectures

Case-Style Reference ArchitecturesSign in
Small Org Reference: simple pipelines and lightweight platform boundariesSign in
Mid-Size Reference: multi-team IDP with standardized golden paths and shared servicesSign in
Large Enterprise Reference: multi-region CI/CD with strong governance and regulated workload supportSign in

Part 47

Evolution and Next-Gen Developer Platforms

Evolution and Next-Gen Developer PlatformsSign in
Continuous Everything: integrating security, compliance, and broader workflows into delivery systemsSign in
AI-Assisted Development and Self-Healing Pipelines: conceptual capabilities and the new failure modes they introduceSign in
Long-Term Maintenance: deprecation, compatibility, and evolving platforms without breaking trustSign in

Course overview