CloudViva learning

From cloud basics to your first confident release.

Follow structured paths with prerequisites, sequenced modules, hands-on labs, and a practical capstone.

See upcoming batches Browse the curriculum
Illustrated learning path progressing through four cloud and DevOps stages

Upcoming batches

Register interest for the next cohort.

Dates, delivery format, and fees are being finalized. Registering interest is not a paid booking; we’ll share the details before enrollment.

Interest openDates TBA

Cloud foundations for builders

A provider-neutral foundation in cloud architecture, identity, networking, operations, and cost.

Register interest
Interest openDates TBA

Your first CI/CD pipeline

Start with Git and pull requests, then build CI checks and a safe staging release from zero.

Register interest
Interest openDates TBA

Terraform: build and safely change cloud infrastructure

Progress from your first resource to plans, state, modules, tests, and reviewed changes.

Register interest
Interest openDates TBA

Containers and Kubernetes for app teams

Build a container, deploy it to a local cluster, then scale, update, and debug it.

Register interest

Learning paths

Choose a foundation, not a pile of tools.

Each path focuses on concepts you can carry between cloud providers and projects. Platform-specific examples are identified as such.

COURSE 01

Cloud foundations

Learn how cloud environments are organized, secured, operated, and paid for before choosing a specific provider.

Ask about this course

Best for: New to cloud or moving from on-premises systems
Before you start: No cloud-provider experience required. Basic computer and web-app concepts are helpful, but examples start from first principles.

Modules and hands-on labs

  1. 01
    Cloud model and shared responsibility
    • IaaS, PaaS, and SaaS trade-offs
    • Regions, zones, and availability
    • What the provider secures versus what your team owns

    Lab: Draw a simple application architecture and mark who operates each layer.

  2. 02
    Identity and network boundaries
    • Users, roles, service identities, and least privilege
    • IP addresses, subnets, routes, and DNS
    • Public and private access boundaries

    Lab: Design a public web tier and private data tier, then trace one request through the network.

  3. 03
    Choose compute, storage, and data services
    • Virtual machines, containers, and serverless
    • Object, block, and file storage
    • Managed databases and service trade-offs

    Lab: Select services for a small API and explain the operational trade-offs.

  4. 04
    Operate a cloud workload
    • Logs, metrics, alerts, and health checks
    • Backups, restore tests, and recovery objectives
    • Budgets, tags, and cost visibility

    Lab: Build a first-week operations checklist with an alert, a restore check, and a budget guardrail.

  5. 05
    Design review and provider mapping
    • Review security, reliability, and cost together
    • Map concepts to one chosen cloud provider
    • Document assumptions and open questions

    Lab: Present a provider-mapped design for a small production web service.

Capstone deliverable: Produce a cloud architecture diagram, access boundary, operations checklist, and cost assumptions for a small web service.

COURSE 02

DevOps and CI/CD from scratch

Start with source control, automate repeatable checks, and build a safe route from a code change to a production release.

Ask about this course

Best for: Developers and small teams currently deploying by hand
Before you start: No CI/CD pipeline or prior DevOps practice required. Basic command-line use and a small application repository are recommended.

Modules and hands-on labs

  1. 01
    Source control and team workflow
    • Commits, branches, and pull requests
    • Small changes, reviews, and protected main branches
    • Separate application code from deployment configuration

    Lab: Create a repository workflow with a feature branch, pull request, review checklist, and merge rule.

  2. 02
    Pipeline anatomy
    • Events, workflows, jobs, steps, actions, and runners
    • YAML structure and workflow triggers
    • Reading logs and diagnosing a failed job

    Lab: Create a pull-request workflow that runs on every proposed change and inspect a deliberate failure.

  3. 03
    Continuous integration
    • Install dependencies reproducibly
    • Run lint, tests, and a build
    • Save and identify a versioned build artifact

    Lab: Make a failing test block a merge, then publish an artifact from a passing build.

  4. 04
    Deliver safely to staging
    • Environment-specific configuration
    • Secret storage and short-lived cloud identity
    • Approvals and controlled deployment permissions

    Lab: Deploy a sample application to a non-production environment without putting credentials in the repository.

  5. 05
    Release, observe, and recover
    • Smoke checks and release verification
    • Logs, alerts, and ownership after deployment
    • Rollback triggers and incident notes

    Lab: Simulate a bad release, detect it with a check, and document the rollback path.

Capstone deliverable: Deliver a sample application through pull-request checks to a staging environment, with an artifact, deployment approval, smoke check, and rollback note.

COURSE 03

Terraform: build and safely change cloud infrastructure

Move from a first Terraform configuration to reusable modules, state management, testing, and careful change review.

Ask about this course

Best for: Developers or operators who want repeatable infrastructure changes
Before you start: Basic command-line and cloud-resource familiarity recommended. No Terraform experience required.

Modules and hands-on labs

  1. 01
    Start with a working configuration
    • Providers, resources, and the dependency graph
    • Initialize, format, and validate a configuration
    • Read provider documentation and resource arguments

    Lab: Create one small resource, format the configuration, initialize the provider, and validate it.

  2. 02
    Make configuration reusable
    • Variables, outputs, locals, and data sources
    • References and implicit dependencies
    • Separate configuration from secret values

    Lab: Parameterize the first configuration and output a value needed by a second component.

  3. 03
    Plan, apply, and understand change
    • Read a plan before applying
    • Create, update, replace, and destroy actions
    • Use targeted review and avoid unsafe shortcuts

    Lab: Change a resource and explain the plan, including any replacement or data-loss risk, before applying.

  4. 04
    State, collaboration, and drift
    • What state records and why it matters
    • Remote backends, locking, and team collaboration
    • Detect configuration drift and recover carefully

    Lab: Move a practice project to shared state and identify a simulated out-of-band change.

  5. 05
    Modules, tests, and environment design
    • Extract and version a reusable module
    • Test configuration assumptions
    • Review security and policy checks in a change workflow

    Lab: Build a module interface and add automated checks for its expected inputs and outputs.

Capstone deliverable: Build a small provider-specific environment from reusable Terraform modules, store state appropriately, run checks, and submit a reviewed plan through a pull request.

COURSE 04

Containers to Kubernetes: deploy, scale, and update an app

Follow an application from container image to a running cluster workload, then practice how to expose, scale, update, and debug it.

Ask about this course

Best for: Developers who want to understand how containerized apps run in a cluster
Before you start: Basic command-line use recommended. The first module introduces container images before moving into Kubernetes concepts.

Modules and hands-on labs

  1. 01
    Package an application as a container
    • Images, containers, registries, and tags
    • Ports, environment configuration, and filesystem basics
    • Build a small image reproducibly

    Lab: Build and run a sample web app locally, then inspect its logs and exposed port.

  2. 02
    Understand the cluster model
    • Control plane and worker nodes
    • Pods, Deployments, and desired state
    • Namespaces and basic resource requests

    Lab: Create a local practice cluster and inspect its nodes and system components.

  3. 03
    Deploy and discover an application
    • Apply a Deployment manifest
    • Labels, selectors, and Services
    • Inspect events, pods, and application logs

    Lab: Deploy a containerized app and reach it through a Service inside the cluster.

  4. 04
    Expose and scale deliberately
    • Ingress or load-balancer concepts
    • Replica counts and horizontal scaling
    • Readiness probes and resource limits

    Lab: Expose the app in a local environment, increase replicas, and observe the rollout.

  5. 05
    Update and debug a workload
    • Image updates and rollout history
    • Roll back an unsuccessful release
    • Diagnose configuration, scheduling, and health failures

    Lab: Ship a new app version, trigger a failing deployment, and recover using rollout history.

Capstone deliverable: Deploy a sample app to a local cluster, expose it, scale it, update its image, and document a debugging and rollback path.

A first practical lesson

What belongs in a first CI pipeline?

Keep the first version small: validate a change, run the project’s checks, and make failures visible. Add deployment only after the team can trust those checks.

  1. 1

    Review a change

    A pull request gives teammates a place to discuss the change before it reaches the main branch.

  2. 2

    Run checks

    Automated tests catch common mistakes consistently. Start with a quick, reliable check.

  3. 3

    Create an artifact

    Build a versioned package once so later environments can use the same output.

  4. 4

    Deploy deliberately

    Start in a non-production environment, verify the release, and define how to roll back.

Example: verify changes before merge
name: verify

on:
  pull_request:
  push:
    branches: [main]

jobs:
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npm test

This GitHub Actions example assumes a Node.js project with an npm test script. Adapt the runner and commands to your stack; it does not deploy to production.

Provider-aware, not provider-locked. Learn concepts first, then see how they map to a specific platform.

Start from zero. DevOps foundations do not assume a working CI/CD pipeline already exists.

Practice safely. Examples use non-production workflows; credentials and production access are handled separately.

Not sure which path fits?

Tell us what you’re trying to learn or ship, and we’ll point you to the closest track or upcoming cohort.

Ask about training