LevelUpWith

Explore / Cloud Pro: Choose and Use

Lift, Shift, Stay Free: Multi-Cloud Modernisation for Enterprise Apps

Assess a private-hosted legacy estate, refactor and containerise its web, database-backed and desktop apps into one image and config contract per app, and use reviewed, AI-assisted Terraform/OpenTofu pipelines to deploy each app to Google Cloud Run, Azure Container Apps and Amazon ECS Express Mode.

Read lesson 1 free →

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor.

Photographic 3D course artwork for Lift, Shift, Stay Free: Multi-Cloud Modernisation for Enterprise Apps

Expert · 60 levels · 4 free · Created Nov 2026 · Professionally curated by levelupwith.com

What's inside

  1. Level 1: Why Portable Containers: The Lift-Off TargetFree
    Learn the course's goal: one container image and one config contract per app that deploys unchanged to Google Cloud Run, Azure Container Apps and Amazon ECS Express Mode, so the organisation can move between clouds for price, recovery or preference.
    • Explain what 'one image, one config contract' means and why it avoids vendor lock-in
    • Name the three default targets and say why ECS Express Mode, not App Runner, is the default AWS target now that App Runner closed to new customers on 30 April 2026
    • List the moving parts that are allowed to differ per cloud (infrastructure code, identity, networking) and those that must not (image, config contract)
  2. Level 2: Inventorying the Estate with AI Coding ToolsFree
    Use GitHub Copilot, Claude Code, Codex or Google Antigravity to scan repositories, build-server jobs and server configs into a structured application inventory that a person then reviews.
    • Write a prompt and output schema that has an AI tool list each app's language, runtime, framework, build job and hosting server
    • Cross-check the AI-generated inventory against build-server jobs (Jenkins, TeamCity, Azure DevOps Server, Octopus) and the servers that are actually running, and flag gaps
    • Set guard rails for AI tools in this phase: read-only access, no secrets in prompts, and a human sign-off on every entry
  3. Level 3: Mapping Dependencies and Integration Points
    Trace each app's runtime dependencies (databases, file shares, message queues, SMTP, LDAP/Active Directory, scheduled tasks and other apps) into a dependency graph that shows which apps have to move together.
    • Extract connection strings, hostnames and outbound calls from code and config into a dependency map
    • Group tightly coupled apps into move groups and spot hidden dependencies such as hard-coded IPs and UNC paths
    • Mark each dependency as one that moves to the cloud, stays on-premises behind a hybrid link, or is replaced
  4. Level 4: Finding State: Sessions, Files and Local Disk
    Identify where each app keeps state (in-memory sessions, local file writes, uploaded files, caches, machine-specific registry or config) that will break on stateless, scale-out container platforms.
    • Audit an app for local-disk writes, sticky sessions and singleton assumptions
    • Classify each piece of state as move to a managed store, externalise, or remove
    • Explain why scale-to-zero and multiple instances break apps that assume one long-running server
  5. Level 5: Applying the 7 Rs to Each App
    Assign each app one of the 7 Rs (retire, retain, rehost, relocate, replatform, repurchase, refactor) using evidence from the inventory, dependency and state work.
    • Score apps on business value, technical fit and migration effort to pick an R for each
    • Tell replatforming into a container apart from refactoring, and justify which one a given app needs
    • Produce a disposition table that a stakeholder can challenge and approve
  6. Level 6: Deciding What Not to Move
    Recognise the apps and components that should be retired, kept on-premises or left on VDI: licence-bound software, hardware-attached systems, latency-critical links and apps near end of life.
    • Apply clear exit criteria that keep an app out of the container programme
    • Document a retain or retire decision with its risks, owner and review date
    • Avoid sunk-cost moves by comparing the cost of modernising with the cost of replacing
  7. Level 7: Comparing Cloud Run, Container Apps and ECS Express
    Compare the three default targets on what they share (an HTTP container, a port, a health check path, environment variables, autoscaling) and where they differ, checking each fact against current vendor docs.
    • Map one app's needs to the equivalent settings on Cloud Run, Azure Container Apps and ECS Express Mode (for example, ECS Express Mode runs on Fargate with a configurable container port and health check path)
    • Identify the platform-specific behaviours to design around, including scale-to-zero support, request timeouts and how instances are shut down
    • Explain App Runner's status: existing customers can keep using it and create new services, it gets no new features, and AWS recommends ECS Express Mode as the migration path
  8. Level 8: Writing the Per-App Config Contract
    Define a provider-neutral contract for each app (port, health endpoints, environment variables, secret names, resource limits and shutdown behaviour) that every cloud's deployment must satisfy.
    • Write a versioned config contract file that lists every required and optional setting with types and defaults
    • Separate contract values from cloud-specific bindings, such as which secret store or identity provides a value
    • Review an AI-drafted contract against the inventory, then sign off the wave-one app list
  9. Level 9: Twelve-Factor Config: Out of Files, Into the Env
    Refactor hard-coded settings, web.config/app.config transforms and per-server properties files into environment-driven configuration that matches the config contract.
    • Replace environment-specific config files with environment variables plus typed config loading in Python, .NET, TypeScript or Java
    • Use an AI tool to find and refactor hard-coded values, then check the diff against the contract
    • Make the app fail fast at startup with a clear message when a required setting is missing
  10. Level 10: Secrets Out of Code and Images
    Remove passwords, keys and connection strings from source, config files and build steps, and read them at runtime from injected values that map to each cloud's secret manager.
    • Scan repositories and history for committed secrets, then rotate any that are found
    • Refactor code so secrets arrive only at runtime, never baked into an image layer or build argument
    • Define secret names in the config contract so that Google Secret Manager, Azure Key Vault and AWS Secrets Manager can each supply them
  11. Level 11: Logs as Event Streams
    Replace file-based and Windows Event Log logging with structured JSON written to stdout/stderr, so every platform's log collector can pick it up without agents.
    • Configure structured logging in Python, .NET, Node/TypeScript and Java to write JSON to stdout
    • Add correlation IDs and severity fields that map cleanly onto each cloud's logging service
    • Remove log rotation and local log-file assumptions from the app and its config
  12. Level 12: Making the App Stateless
    Move the sessions, uploads, caches and scheduled jobs identified during the survey out of the process and off local disk, so any instance can serve any request and instances can be thrown away.
    • Move session state to a shared store and file uploads to object storage behind a small storage interface
    • Split in-process scheduled tasks into separate jobs or triggers
    • Prove statelessness by running two instances behind a load balancer and killing one mid-test
  13. Level 13: Health Checks: Startup, Liveness, Readiness
    Add health endpoints that report correctly when the app is starting, alive and ready to take traffic, and wire them to each target's health check settings.
    • Build lightweight liveness and readiness endpoints that do not cascade failures from downstream dependencies
    • Set the health check path and port in the config contract so that the Cloud Run, Container Apps and ECS Express Mode settings all agree
    • Diagnose a deployment that fails because the health check path or port does not match the app
  14. Level 14: Graceful Shutdown and Fast Startup
    Handle SIGTERM correctly, drain in-flight requests and close connections within the platform's shutdown window, and cut the startup time that drives cold starts.
    • Implement SIGTERM handling in each language runtime and make sure the app process receives the signal (PID 1, exec-form entrypoint)
    • Drain requests and release database connections before the platform kills the container, checking the shutdown window in each vendor's docs
    • Profile startup and remove slow work at boot, such as eager loading and blocking network calls
  15. Level 15: Dockerfile Fundamentals for Legacy Code
    Write multi-stage Dockerfiles that separate build from runtime, run as a non-root user, use exec-form entrypoints and pin base images by digest.
    • Write a multi-stage Dockerfile with a minimal runtime stage and a non-root user
    • Pin base images by digest and order layers so that caching works
    • Review an AI-generated Dockerfile against a written checklist covering root user, secrets, pinning, entrypoint and port
  16. Level 16: Containerising Python Services
    Package legacy Python web apps (Flask, Django, WSGI/ASGI) into slim, reproducible images with locked dependencies and a production-grade server.
    • Build a Python image with locked dependencies, a slim base and compiled wheels in the build stage
    • Run the app under a production WSGI/ASGI server that listens on the contract port and handles SIGTERM
    • Have an AI tool generate smoke tests for the containerised app, then review them
  17. Level 17: .NET Framework vs Modern .NET and Windows Containers
    Decide whether a .NET Framework app should be ported to modern .NET for Linux containers or kept in Windows containers, weighing port effort against which targets will actually run the image.
    • Assess a .NET Framework app's blockers to porting (System.Web, WCF, COM, registry, Windows auth) using upgrade analysis tools and an AI assistant
    • Check current vendor docs to see whether each target platform runs Windows container images, and record what that means for portability
    • Build a modern .NET image with a chiselled or slim base and configure it for the contract port and environment-based config
  18. Level 18: Containerising Node.js and TypeScript Apps
    Build TypeScript and Node apps into lean images that ship only compiled output and production dependencies, with correct signal handling.
    • Compile TypeScript in a build stage and copy only the dist folder and production node_modules into the runtime stage
    • Make sure SIGTERM reaches the Node process, for example by running node directly or using a minimal init
    • Use lockfile-based, reproducible installs and remove dev tooling from the runtime image
  19. Level 19: Containerising Java: Memory and Startup
    Package Java apps so the JVM respects container memory limits and starts quickly enough for autoscaling and scale-to-zero platforms.
    • Configure container-aware JVM memory settings (for example, MaxRAMPercentage) to match the contract's resource limits
    • Build layered images for Spring Boot or similar frameworks with a JRE-only runtime stage
    • Compare startup-reduction options such as class data sharing, lazy initialisation and native images, and their trade-offs
  20. Level 20: Slim, Scanned, SBOM-Backed Images
    Add a guard-rail stage to the build that minimises the image, scans it for vulnerabilities, generates an SBOM and signs the result before any AI-built or human-built image is accepted.
    • Generate an SBOM and run a vulnerability scan with a defined severity threshold that fails the build
    • Sign images and attach SBOMs to them so that any cloud's registry and deploy step can verify where they came from
    • Apply one acceptance gate (scan, SBOM, signature, contract smoke test) to every image in the estate
  21. Level 21: Desktop App Triage: Web, Thin Client or VDI
    Learners sort legacy desktop apps into three paths: rebuild as a web front end, keep a thin client over a containerised API, or leave the app on VDI. Each app is scored on its UI complexity, local hardware or file dependencies, offline needs and how many people use it.
    • Score each desktop app in an inventory against a written rubric and pick web, thin client or VDI for it
    • Find blockers that make a desktop app hard to move, such as COM/ActiveX controls, local printers or scanners, mapped drives and per-machine licences
    • Write a short decision record per app that a reviewer can approve or challenge
  22. Level 22: Extracting an API from a Fat Client
    Learners use an AI coding assistant to move business logic and direct database calls out of a WinForms, WPF, Swing or Electron client and into a versioned HTTP API that ships in a container.
    • Have an AI tool map the direct SQL calls and business rules buried in client code, then check the map by hand
    • Write an OpenAPI contract for the extracted operations and generate the server stub and client stub from it
    • Turn the desktop client into a thin client that calls the containerised API and holds no database credentials
  23. Level 23: Strangling a Desktop UI into a Web Front End
    Learners replace a desktop UI with a web front end one screen at a time, using the strangler-fig pattern. The new screens call the same containerised API, so old and new interfaces run side by side during the move.
    • Choose the first screens to move to the web, based on how often they are used and how independent they are
    • Serve the new web front end from the same image and config contract as the API, or as a separate container with its own contract
    • Plan when each desktop screen is retired and how users are moved over without a big-bang cutover
  24. Level 24: Leaving Desktop Apps on VDI, Done Properly
    Learners keep apps that should not be rewritten on virtual desktop infrastructure (VDI) and connect them safely to back ends that have moved to containers or managed databases.
    • Explain when VDI is the right long-term answer and when it is only a stopgap
    • Design network and identity paths from VDI-hosted clients to cloud-hosted APIs and databases without opening the database to the internet
    • Write review triggers that would move a VDI-retained app back into the modernisation queue
  25. Level 25: Database Strategy: Managed vs Portable
    Learners decide, for each database, whether to use a cloud-managed engine or a portable option, and set out a data portability contract based on engine version, wire protocol, extensions and connection settings.
    • Compare managed database services on the three clouds with self-run or cross-cloud options, looking at lock-in, operating effort and recovery
    • List the engine features that break portability, such as vendor-only extensions, proprietary auth and engine-specific SQL
    • Add database connection settings to the app's config contract so the same image works with any target engine endpoint
  26. Level 26: Migrating SQL Server Workloads
    Learners move on-premises SQL Server databases to managed SQL Server offerings on each cloud, dealing with instance-level features that legacy apps quietly depend on.
    • Find dependencies on SQL Agent jobs, linked servers, CLR assemblies, cross-database queries and Windows authentication
    • Decide whether each dependency is rehosted, replaced with a containerised job or refactored away
    • Check from the vendor documentation which SQL Server versions, editions and features each target cloud supports
  27. Level 27: Oracle: Retain, Rehost or Convert
    Learners decide what to do with Oracle databases by weighing licensing, PL/SQL depth and risk. The options are to retain Oracle on a supported hosting option or to convert the schema and code to PostgreSQL with tool-assisted conversion and testing.
    • Estimate conversion effort from PL/SQL packages, triggers, sequences and Oracle-specific types
    • Use schema conversion tools and AI assistants to draft PostgreSQL equivalents, then check them with regression tests
    • Write a recommendation that weighs licence cost, risk and portability for one Oracle-backed app
  28. Level 28: PostgreSQL and MySQL as the Portable Core
    Learners treat PostgreSQL and MySQL as the most portable relational targets. They handle version parity, extension availability and character set or collation differences across the three clouds' managed services.
    • Build a compatibility matrix of engine versions and extensions across the target managed services, checked against vendor docs
    • Test the app against the same engine version in a local container and in each managed service
    • Remove or isolate engine features that would block a move between clouds
  29. Level 29: NoSQL Stores: MongoDB, Cosmos DB, DynamoDB, Firestore
    Learners compare the data models, consistency options and API compatibility of the four NoSQL stores, and design a repository layer that keeps the app's dependence on any one store small and visible.
    • Map an app's access patterns to document and key-value models and find features that exist in only one store
    • Explain where MongoDB-compatible APIs help portability and where their gaps matter, using current vendor docs
    • Build a repository interface with a swappable adapter for each store and run one shared test suite against them
  30. Level 30: Executing Data Migration and Cutover
    Learners plan and rehearse a database move using bulk load plus change data capture (CDC), with validation, a cutover window and a tested rollback path.
    • Choose between offline dump and restore and online replication for a given size and downtime budget
    • Check migrated data with row counts, checksums and application-level smoke tests
    • Write and rehearse a cutover and rollback runbook, including DNS or connection-string switching
  31. Level 31: Connection Pooling Under Scale-to-Zero
    Learners stop serverless container scale-out from exhausting database connections. They combine app-side pool sizing and max-instance limits with managed poolers such as Amazon RDS Proxy, the PgBouncer built into Azure Database for PostgreSQL and Cloud SQL Managed Connection Pooling.
    • Calculate the worst-case number of connections from max instances, concurrency and pool size, then set limits so it fits the database
    • Choose and configure a managed or self-run pooler for each cloud, noting requirements such as the Cloud SQL edition needed for Managed Connection Pooling
    • Handle cold-start connection set-up and stale connections after scale-to-zero safely in the app code
  32. Level 32: Designing Internal and External APIs
    Learners separate internal service-to-service APIs from public APIs. They set ingress visibility, versioning and authentication for each, so the same contract works on Cloud Run, Azure Container Apps and ECS Express Mode.
    • Mark each endpoint as internal-only or external and set the matching ingress mode on each platform
    • Version OpenAPI contracts and run contract tests in the pipeline
    • Choose an authentication pattern for each audience: OIDC/JWT for users and workload identity for services
  33. Level 33: A Portable API Edge: Gateways and Rate Limits
    Learners put a gateway layer in front of external APIs to handle authentication, quotas and routing. They decide when to use each cloud's native gateway and when to use a portable gateway in a container.
    • Compare native API gateway services with a containerised open-source gateway, looking at lock-in and operating effort
    • Express routing, auth and rate-limit policy as configuration that can be moved between clouds
    • Add a gateway in front of one migrated API without changing the app image
  34. Level 34: Private Networking on Each Cloud
    Learners keep app traffic off the public internet using each platform's private networking: Cloud Run Direct VPC egress, VNet-integrated internal Azure Container Apps environments with private DNS, and VPC-placed ECS services.
    • Configure private egress from a container app to a private database on each cloud
    • Deploy an internal-only environment or service and resolve it through private DNS
    • Draw one network diagram that shows the equivalent parts on all three clouds
  35. Level 35: Hybrid Links Back to the Data Centre
    Learners connect cloud-hosted containers to systems that stay on premises. They use site-to-site VPN or dedicated interconnects, hybrid DNS and firewall rules, with careful attention to latency and failure modes.
    • Choose between VPN and dedicated interconnect options per cloud based on bandwidth, latency and resilience needs
    • Design two-way hybrid DNS resolution between on-premises and cloud private zones
    • Find chatty cross-link calls that will hurt performance and plan to cache, co-locate or batch them
  36. Level 36: Keyless Runtime Identity for Containers
    Learners remove stored credentials from running apps by giving each container its platform identity: Google service accounts, Azure managed identities or ECS task roles, all with least-privilege permissions.
    • Assign a dedicated runtime identity to each app on each cloud and grant only the roles it needs
    • Change app code to use the default credential chain of each cloud SDK instead of embedded keys
    • Audit an app for leftover static credentials, using AI-assisted search and then reviewing the results by hand
  37. Level 37: Workload Identity Federation Across Clouds
    Learners use OIDC-based workload identity federation so pipelines and workloads on one platform get short-lived credentials on another, with no long-lived keys.
    • Set up federated trust from a CI provider's OIDC tokens to Google Cloud, Microsoft Entra ID and AWS IAM
    • Limit trust with audience, subject and branch or environment conditions
    • Let a workload on one cloud call a service on another cloud through federation
  38. Level 38: Secrets Management Behind the Config Contract
    Learners keep secrets in Google Secret Manager, Azure Key Vault and AWS Secrets Manager, and pass them to the same container image as environment variables or mounted files, with rotation that does not need a rebuild.
    • Map each secret in the config contract to the matching secret store on each cloud
    • Read secrets through runtime identity and handle rotation without restarting or rebuilding the image
    • Add secret scanning and pre-commit guard rails so AI-generated code cannot commit credentials
  39. Level 39: Generative AI Behind a Provider-Neutral Gateway
    Learners send app calls for large language model (LLM) inference through one gateway interface, so models from different providers or clouds can be swapped, tried in turn as fallbacks and governed without changing app code.
    • Design a provider-neutral inference API and set model routing and fallback in configuration
    • Apply authentication, quotas, cost tracking and prompt and response logging rules at the gateway
    • Run the same app against two different model providers by changing only gateway configuration
  40. Level 40: Instrumenting Apps with OpenTelemetry
    Learners add OpenTelemetry traces, metrics and logs to Python, .NET, Node/TypeScript and Java containers. They use automatic and manual instrumentation and send the data over OTLP, so telemetry is not tied to any vendor.
    • Turn on automatic instrumentation per language and add manual spans around key business operations
    • Set OTLP export endpoints and resource attributes through the config contract
    • Pass trace context across the thin client, API, gateway and database calls so one request can be followed from start to finish
  41. Level 41: Portable Telemetry: One OpenTelemetry Collector Per Cloud
    Learners send traces, metrics and logs from every containerised app through an OpenTelemetry Collector configured once, so each cloud's monitoring backend can be swapped without changing application code.
    • Write one OpenTelemetry Collector configuration whose exporters for Google Cloud, Azure Monitor and AWS can each be turned on or off by environment variables
    • Trace a single request from the browser or thin client through the API, database and generative AI gateway, and find the slowest span
    • Review AI-generated instrumentation to remove high-cardinality attributes and personal data before telemetry leaves the app
  42. Level 42: Mapping Build-Server Jobs to Modern CI/CD
    Learners list existing Jenkins, TeamCity, Azure DevOps Server and Octopus jobs and match each step to an equivalent in GitHub Actions, GitLab CI or Azure Pipelines.
    • Use an AI coding tool to pull every build, test and release step out of existing job definitions into a reviewed migration table
    • Pick a target CI/CD platform using clear criteria: where the code is hosted, the runner model, secrets, and approval gates
    • Find manual release steps and undocumented server-side scripts that must become code before migration
  43. Level 43: The Build Pipeline: One Image, Built Once
    Learners build a CI pipeline that builds, tests, scans, signs and produces an SBOM for one immutable container image per commit, which is then promoted unchanged to every cloud.
    • Write a pipeline that tags images by commit digest and pushes them to a neutral or replicated registry
    • Add vulnerability scanning, SBOM generation and image signing as stages that block the build when they fail
    • Explain why rebuilding an image per environment or per cloud breaks the one-image contract
  44. Level 44: Keyless Pipelines with OIDC Federation
    Learners swap stored cloud credentials in CI for OIDC workload identity federation, so pipelines get short-lived tokens for Google Cloud, Azure and AWS.
    • Set up federated trust between a CI platform and each of the three clouds, limited to a specific repository, branch or environment
    • Remove long-lived service account keys and access keys from pipeline secrets
    • Check AI-generated trust policies for overly broad subject claims
  45. Level 45: Terraform and OpenTofu Foundations for Portability
    Learners set up the infrastructure-as-code basics needed for multi-cloud work: remote state, locking, provider pinning and a repository layout that Terraform and OpenTofu can both use.
    • Configure remote state with locking for each cloud and explain the risks of sharing state across clouds
    • Pin provider and tool versions so plans are reproducible in CI
    • Choose between Terraform and OpenTofu by weighing licensing, compatibility and organisational policy
  46. Level 46: Designing One Module Interface for Three Clouds
    Learners define a provider-neutral 'container service' module interface that takes the image, config contract, scaling, health checks and networking as inputs and returns a URL and an identity as outputs.
    • Write variable and output definitions that capture the per-app config contract without leaking any cloud-specific concepts
    • Decide which settings are portable and which belong in a clearly marked per-cloud escape hatch
    • Have an AI tool draft the interface, then review it against three real apps from the estate inventory
  47. Level 47: Implementing the Cloud Run and Container Apps Modules
    Learners implement the shared module interface for Google Cloud Run and Azure Container Apps, mapping each input to that platform's own resources.
    • Map image, environment variables, secrets references, probes, scaling limits and ingress to Cloud Run and Container Apps resources
    • Wire in each platform's managed identity and private networking options behind the same inputs
    • Write contract tests that check both modules accept identical inputs and return the same outputs
  48. Level 48: Implementing the ECS Express Mode Module (and App Runner)
    Learners implement the shared interface for Amazon ECS Express Mode as the default AWS target, and keep an App Runner variant only for organisations that are existing App Runner customers.
    • Map the module inputs to ECS Express Mode service configuration, checking every resource against current AWS documentation
    • Explain that App Runner closed to new customers on 30 April 2026 and that AWS recommends ECS Express Mode, then plan an App Runner-to-Express Mode migration path
    • Run the shared contract tests against the AWS module and fix any gaps in behaviour
  49. Level 49: Environments and Promotion Across Clouds
    Learners model dev, test and production environments as configuration over the same modules, and promote one signed image digest through approval gates.
    • Structure per-environment and per-cloud variable files without copying module code
    • Build a promotion workflow with protected environments, manual approvals and automated smoke tests
    • Roll back a failed release by redeploying the previous image digest
  50. Level 50: Policy as Code for Images and Infrastructure
    Learners enforce organisational rules automatically in pipelines, checking Terraform plans, Dockerfiles and container images before anything is deployed.
    • Write policies that reject public ingress, missing tags, unencrypted storage or unsigned images
    • Run policy checks against Terraform plan output and image metadata as stages that block the pipeline
    • Handle policy exceptions with time-limited, reviewed waivers rather than by switching checks off
  51. Level 51: Database Migrations and Data Changes in the Pipeline
    Learners run schema migrations as versioned, backward-compatible pipeline steps, so database changes ship safely alongside container releases on any cloud.
    • Apply expand-and-contract migrations so old and new app versions can run side by side during a rollout
    • Run migrations as a one-off job or task on each platform instead of at container startup
    • Gate destructive schema changes behind explicit human approval
  52. Level 52: Guard Rails for AI-Written Pipelines and IaC
    Learners set up the review process that lets AI coding tools write pipelines and Terraform safely: scoped permissions, mandatory plan review, automated checks and audit trails.
    • Configure AI agents such as Claude Code, Codex, Copilot or Antigravity with least-privilege access that cannot apply infrastructure directly
    • Require a human-reviewed plan diff, passing policy checks and code-owner approval before any apply
    • Write a team playbook covering prompts, review checklists and how to spot fabricated resource arguments
  53. Level 53: Cost Modelling Across Three Platforms
    Learners compare running costs on Cloud Run, Container Apps and ECS Express Mode, using each vendor's current pricing pages instead of rules of thumb.
    • Build a cost model per app from request volume, CPU and memory, minimum instances, egress and managed database charges
    • Spot hidden costs such as load balancers, NAT, logging volume and cross-region data transfer
    • Tag resources consistently so costs can be compared per app across clouds
  54. Level 54: Taming Cold Starts and Tuning Autoscaling
    Learners measure and reduce cold-start latency, and tune scaling rules so apps respond quickly without overspending or overloading the database.
    • Measure cold starts per language runtime and reduce them with slimmer images, startup tuning and lazy initialisation
    • Weigh minimum instances against scale-to-zero for each app's traffic pattern
    • Set concurrency and maximum-instance limits that protect connection pools and downstream systems
  55. Level 55: Load Testing and Capacity Proof
    Learners run repeatable load tests against the same image on each cloud to check its scaling, latency and error budgets before going live.
    • Write a load test scenario that runs in CI against any cloud's endpoint
    • Compare latency percentiles and error rates across platforms using OpenTelemetry data
    • Define service level objectives and alert on how fast the error budget is being used up
  56. Level 56: Multi-Region Recovery Design
    Learners design disaster recovery for containerised apps and their data, choosing recovery time and recovery point objectives and matching patterns for each tier.
    • Choose between backup-and-restore, pilot light, warm standby and active-active for each app based on its recovery targets
    • Plan database replication and failover that fit the chosen managed or portable data store
    • Set up global traffic routing and health-based failover between regions
  57. Level 57: Running a Recovery Game Day
    Learners rehearse a regional outage by failing an app over to another region, then measure recovery against its targets and record what went wrong.
    • Script a controlled failover and failback using the existing pipelines and Terraform modules
    • Measure the achieved recovery time and data loss against the stated targets
    • Write a blameless review that turns findings into backlog items
  58. Level 58: Portability Drill: Planning the Move
    Learners prepare to redeploy a live app to a different cloud by auditing its lock-in points, data gravity, identity, networking and DNS dependencies.
    • Use an AI tool to audit an app for cloud-specific calls, SDKs and configuration outside the portable contract
    • Plan data sync, secrets re-creation, identity mapping and DNS cutover with a rollback point
    • Get sign-off on a runbook with clear go/no-go criteria
  59. Level 59: Portability Drill: Redeploying a Live App
    Learners carry out the drill, redeploying the same signed image and config contract to the target cloud, moving traffic gradually and confirming it behaves the same.
    • Deploy the app to the target cloud with the shared module interface and the existing pipeline, without changing application code
    • Shift traffic gradually while comparing telemetry, cost and error rates between clouds
    • Record every manual step or code change needed as portability debt to fix
  60. Level 60: Final Challenge: Lift-Off for a Whole Estate Exam
    Learners bring the whole course together by taking a sample legacy estate from assessment to a portable, observable, recoverable multi-cloud deployment, defending each decision along the way.
    • Assess the estate with the 7 Rs, refactor and containerise its apps, choose desktop and database strategies, and justify what stays on-premises or on VDI
    • Deliver secure networking, identity, secrets, an AI gateway, OpenTelemetry, pipelines, Terraform/OpenTofu modules and policy as code, all with reviewed AI help
    • Prove portability and recovery by deploying the estate to Cloud Run, Container Apps and ECS Express Mode, and present the cost and risk trade-offs

Access

Levels 1 and 2 are free to read, no account needed. Levels 3 and 4 are free with a free account, and so are 20 answers from the AI tutor. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Read lesson 1 free →

More like this