12 Factor App: From Monoliths to Cloud-Native

Why 12 Factor still matters

Who this course is for - developers, architects, DevOps engineers

What systemic problems 12 Factor eliminates in modern distributed systems

How 12 Factor relates to Cloud, Kubernetes, and SaaS operating models

• Course Mental Model Diagram

The origin of 12 Factor at Heroku

Deployment challenges before the cloud era

Monolithic systems vs cloud-native architecture shift

Why PaaS platforms required architectural standards

Evolution of 12 Factor principles into the Kubernetes era

• Timeline Diagram

High-level walkthrough of all 12 factors

Logical grouping of factors by concern - code, config, processes, operations

Separation of build, release, and run responsibilities

Interdependencies between factors and systemic reinforcement

• 12 Factor Framework Map

How to apply 12 Factor thinking in real production environments

Introduction to Factor 1 and the One Codebase principle

What “one codebase” really means in practice

Multiple deploys from a single repository - environments, stages, regions

Monorepo vs multirepo - architectural trade offs and organizational impact

• Artifact: Repo Structure Diagram

Version control requirements - mandatory use of VCS, branch strategy, traceability

Anti patterns - forked codebases, duplicated services, environment specific branches

Introduction to Factor 2 and why dependency discipline defines production stability

Explicit dependency declaration - no hidden system libraries or implicit runtime assumptions

Dependency isolation - virtual environments, containers, classpath isolation

• Artifact: Dependency Isolation Diagram (show during isolation explanation)

Role of package managers - version resolution, transitive dependencies, semantic versioning

Reproducible builds as an architectural requirement, not a convenience

Lock files and deterministic builds - ensuring identical artifacts across environments

Supply chain risks, artifact versioning, and integrity control

• Artifact: Build Reproducibility Flow

Introduction to Factor 3 and why configuration must be separated from code

Config vs Code separation - defining a strict architectural boundary

Environment variables as the standard interface for configuration

Secrets handling within configuration - treating secrets as externalized config, not embedded values

Anti pattern: configuration stored in the repository or hardcoded in source

Multi environment scaling - using the same codebase across Dev, Stage, and Prod through configuration

• Artifact: Config Injection Diagram

Why secrets require specialized management beyond standard configuration

Centralized secret storage - vaults and secret management systems

Secret injection patterns - runtime retrieval vs platform level injection

Rotation strategies - automated rotation, short lived credentials, zero downtime updates

Encryption principles - encryption at rest and in transit

Compliance and governance considerations - auditing, access control, least privilege

• Artifact: Secrets Lifecycle Diagram

Why environment strategy is a structural concern in distributed systems

Dev, Stage, and Prod separation - purpose, risk isolation, and promotion flow

Environment specific configuration vs environment specific code

Feature flags vs configuration - dynamic behavior control without redeployment

Infrastructure drift and configuration drift - why environments silently diverge

Drift prevention strategies - parity, automation, and immutable deployments

• Artifact: Environment Parity Model

Introduction to Factor 4 and the concept of treating backing services as attached resources

What qualifies as a backing service - databases, caches, message queues, external APIs

DB, cache, and queue abstraction - decoupling application logic from infrastructure details

Service binding patterns - how applications connect to external services through configuration

• Artifact: Service Attachment Diagram

Swappable service design - replacing a database, cache, or broker without changing application code

Vendor lock risks - architectural coupling to cloud specific managed services

Cloud migration readiness and portability strategy - designing for replaceability and resilience

• Artifact: Service Portability Model

Connection configuration strategy - environment driven service binding and runtime flexibility

Introduction to Factor 5 and why lifecycle separation defines deployment stability

Build stage - compilation, packaging, and artifact creation

• Artifact: Build Pipeline Diagram

Immutable builds - why artifacts must not change after creation

Release stage - combining artifact with environment specific configuration

Config injection timing and release versioning discipline

• Artifact: Release Lifecycle Diagram

Rollback strategy - reverting to previous release safely and predictably

Run stage - runtime execution model and process responsibility

Separation of build and run - why runtime must not modify artifacts

• Artifact: Build vs Run Separation Visual

Stateless runtime expectations - ensuring scalability and disposability

Introduction to Factor 6 and the stateless process principle

Why state kills scalability - memory coupling, local persistence, and coordination complexity

Stateless vs stateful processes - architectural differences and operational consequences

• Artifact: Stateless vs Stateful Diagram

Horizontal scaling mechanics - replicating identical processes behind load balancers

Crash recovery and disposability - replacing failed instances without data loss

Session management in distributed systems - why local session storage breaks scaling

Sticky sessions as an anti pattern - hidden coupling between user and instance

External session storage and token based authentication - decoupling identity from runtime

• Artifact: Session Externalization Flow

Introduction to Factor 7 and the principle of port binding

Self contained services - application exposes itself over a defined port

Embedded web servers - why applications must not depend on external web containers

Container networking fundamentals - how services communicate in containerized environments

• Artifact: Port Binding Architecture Diagram

Service exposure models - internal vs external access patterns

Reverse proxies - centralized traffic routing and TLS termination

Ingress controllers - cluster level HTTP routing in orchestrated environments

Load balancers - distributing traffic across replicated service instances

• Artifact: Traffic Routing Diagram

Introduction to Factor 8 and the process based concurrency model

Process model scaling - separating web, worker, and background processes

• Artifact: Process Scaling Model

Worker vs web processes - responsibility boundaries and workload isolation

Queue consumers - asynchronous processing and workload distribution

Horizontal vs vertical scaling - architectural and operational trade offs

• Artifact: Scaling Decision Matrix

Auto scaling triggers - metrics driven elasticity and capacity control

Cost implications of scaling strategies - efficiency, overprovisioning, and resource optimization

Fast startup requirement

Graceful shutdown

Signal handling

Crash resilience

• Artifact: Lifecycle Timing Diagram

Health checks

Circuit breakers

Restart policies

• Artifact: Failure Recovery Flow

Why parity matters

Docker impact

Infrastructure drift problems

• Artifact: Parity Comparison Chart - show on Infrastructure drift problems slide

Integration environments

Synthetic data

Release confidence

• Artifact: Environment Stack Diagram - show on Release confidence slide

Logs as event streams

Stdout logging model

Aggregation systems

• Artifact: Log Streaming Architecture

Logs vs metrics vs traces

Correlation IDs

Incident meaning

• Artifact: Observability Triad Diagram

One off processes

DB migrations

Scripts isolation

• Artifact: Admin Execution Flow

Access control

Execution audit

Rollback readiness

• Artifact: Admin Risk Model

How factors reinforce each other

Failure scenarios

Design trade offs

• Artifact: Factor Dependency Map

Service granularity

Shared infrastructure challenges

Deployment pipelines

• Artifact: Microservices 12 Factor Overlay

Pods as processes

ConfigMaps and Secrets

Service binding

• Artifact: Kubernetes Mapping Diagram

Hardcoded configuration

Stateful services

Local file storage

• Artifact: Anti Pattern Checklist

Refactoring monoliths

Incremental adoption

Risk management

• Artifact: Migration Roadmap