11 Cloud Computing Projects to Build a Portfolio for Cloud Roles (2026)

The best cloud computing project for your portfolio is not the most impressive one. It is the one that proves the exact skill the role you are targeting asks for, and that you can talk through confidently in an interview. If you are moving into a cloud engineer, DevOps, or site reliability engineer (SRE) role, a focused set of guided projects across infrastructure as code, containers, CI/CD, and observability does more for you than a dozen unfocused tutorials.

This guide lists 11 projects grouped by the skill each one demonstrates, with a note on what it signals to a hiring manager and a guided path to build it. Whether you are a backend developer adding cloud to your stack or a sysadmin making the jump, pick the two or three that fill the biggest gaps in your evidence. According to our cloud engineer salary guide, entry-level cloud engineers in the US start around $127,000, so the roles are worth the effort of building real proof.

We chose these projects on three criteria: they use tools that appear in 2026 cloud job descriptions (Terraform, Kubernetes, GitHub Actions), they produce something you can show (a GitHub repo, a live demo, an architecture diagram), and each maps to a guided course or tutorial so you are not learning alone. New to the field? Start with our Understanding Cloud Computing course and our guide on how to become a cloud engineer, then come back and build.

TL;DR

How to Pick the Right Project for Your Target Role

The strongest portfolio is not the one with the most projects. It is the one that matches evidence to the specific role you are applying for, and covers the skill areas most junior portfolios skip. Before you build, work through three questions and match your choice to the gap.

• What job title am I targeting right now? Cloud engineer, DevOps engineer, SRE, or cloud data engineer? Build the projects tagged to that role first.
• Which skill do I have the least evidence for? Infrastructure as code, containers, CI/CD, data, or security? A monitoring or security project adds more than a third infrastructure build.
• Can I explain every decision in this project? If a project has no documented reasoning, it reads as a tutorial follow-along, not a portfolio piece.

Infrastructure and IaC Projects for Cloud Engineer and DevOps Roles

Infrastructure projects show that you can design and provision cloud environments as code. They are high-signal for cloud engineer, DevOps, and SRE roles because infrastructure as code is how real teams work.

1. Provision a three-tier architecture with Terraform

This is the project that turns a click-through web app into proof you can build cloud infrastructure as code. It reworks the classic three-tier build by defining every resource in Terraform instead of the console.

You provision a load balancer, an autoscaling group of web servers, a private database tier, and a bastion host on AWS or GCP, all in HashiCorp Configuration Language (HCL). The networking design is where the real decision-making shows: private subnets, security groups or firewall rules, and controlled egress. Keep the Terraform state in an encrypted S3 backend with locking so the project looks like production, not a sandbox.

Three-tier architecture: a presentation tier, a logic tier, and a data tier, each scaled and secured separately. Source: AWS documentation.

What it proves to a hiring manager: you can design a standard production topology and manage it as code, not by hand in a web console.

Guided path: start with DataCamp's getting started with Terraform and automate AWS infrastructure with Terraform tutorials, and take the Understanding Cloud Computing course first if the fundamentals are new. Use the AWS three-tier reference architecture as your deep dive into the topology.

• Level: Intermediate
• Stack: Terraform, AWS or GCP, load balancer, VPC, autoscaling
• Best for: Backend developers and sysadmins moving into cloud engineering

2. Build a multi-environment Terraform setup

This is the right project for proving you understand how infrastructure as code works at a real company, not just running terraform apply once. It is a pattern used at almost every serious engineering org.

Build a Terraform codebase with shared modules, variable files, and separate workspaces or directories for dev, staging, and production. Store state remotely in S3 or Terraform Cloud with locking, and reuse one module across all three environments so the difference is configuration, not copy-paste. Document why you split the modules the way you did.

What it proves to a hiring manager: you understand module reuse, state management, and environment isolation, which is a real-world IaC structure rather than a one-off script.

Guided path: follow DataCamp's Terraform on AWS and Terraform import tutorials to get comfortable with modules and state before you split environments.

• Level: Intermediate
• Stack: Terraform, remote state, modules, workspaces
• Best for: Anyone targeting a DevOps or platform engineering role

CI/CD and Automation Projects for DevOps and Platform Roles

Automation projects show that you can build repeatable, reliable delivery. They are core for DevOps roles and increasingly expected in cloud engineering too.

3. Build a CI/CD pipeline for a containerized app with GitHub Actions

A CI/CD pipeline for a containerized app is the single most commonly expected automation project for junior cloud and DevOps roles. If you build only one automation project, build this one.

Create a GitHub Actions workflow that lints the code, runs tests, builds a Docker image, pushes it to a registry such as Amazon ECR, Google Artifact Registry, or Docker Hub, and deploys it to a cloud service. Trigger it on push and on pull requests so each stage does something meaningful. A pipeline that only prints "hello world" fools no one, so make every step real.

What it proves to a hiring manager: you can ship code automatically and reliably, which is the day-to-day of platform and cloud work.

Guided path: DataCamp's CI/CD for Machine Learning course teaches GitHub Actions events, jobs, runners, and pipelines, and the mechanics transfer directly to a cloud deploy. Pair it with Introduction to Git and Introduction to GitHub Concepts, then follow the CI/CD walkthrough tutorial for a worked example.

• Level: Intermediate
• Stack: GitHub Actions, Docker, a container registry, a cloud runtime
• Best for: Developers targeting DevOps and platform roles

4. Schedule a serverless automation task

This is a small, fast project that shows operational thinking, which is rarer in junior portfolios than raw building skill. You can finish it in an afternoon.

Use Amazon EventBridge or Google Cloud Scheduler to trigger a Lambda or Cloud Function on a schedule. Good options are a daily cost report, an archiving job for old records, or a cleanup job that removes stale resources. Give the function an IAM role that follows least privilege, and log what it does.

What it proves to a hiring manager: you think about operations and cost control, not just standing services up.

Guided path: take AWS Cloud Technology and Services for the serverless building blocks, then use the AWS Step Functions tutorial to orchestrate multi-step automation.

• Level: Beginner
• Stack: AWS Lambda or Cloud Functions, EventBridge or Cloud Scheduler, IAM
• Best for: Early-career builders adding an operations signal

Containers and Kubernetes Projects for Cloud Engineer, DevOps, and SRE Roles

Kubernetes projects are high-value for cloud engineer, DevOps, and SRE roles. Even a project on a local cluster, such as kind or minikube, is impressive when the manifests and architecture are well thought out.

5. Deploy a multi-service app on Kubernetes with Helm

This is the project that demonstrates production-grade container literacy, and it covers most of what a junior Kubernetes role expects. It works on a managed cluster or locally.

Deploy a small application with two or three services (a web frontend, an API backend, and a database) using Deployment manifests, Services, ConfigMaps, Secrets, and an Ingress controller. Then package it as a Helm chart with separate values files per environment, and add resource requests and limits plus a Horizontal Pod Autoscaler. Document why you chose the thresholds you did, because that is what turns a basic deployment into one that shows real thinking.

What it proves to a hiring manager: you can run containerized workloads the way production does, with packaging and resource management, not just a single manifest.

Guided path: take Introduction to Kubernetes for hands-on kubectl and manifests, then Getting Started with Google Kubernetes Engine for a managed cluster. The Containerization and Virtualization with Docker and Kubernetes track and Kubernetes tutorial cover the full path, and Introduction to Docker is the prerequisite.

• Level: Advanced
• Stack: Kubernetes, Helm, Docker, Ingress, HPA
• Best for: Cloud engineers and DevOps candidates targeting container-heavy teams

Serverless and Event-Driven Projects for Career Switchers and Early-Career Builders

Serverless projects show you understand event-driven architecture and managed compute. They are fast to build, which makes them a good first end-to-end project when your time is limited.

6. Build a static site with a serverless contact form

This is the fastest route to your first complete cloud project, and it produces a live URL you can share. It reworks basic static hosting into something that actually does work on the backend.

Host a static site on Amazon S3 with CloudFront, or on Google Cloud Storage, then add a contact form that calls API Gateway and a Lambda function (or Cloud Functions). The function sends a confirmation through Amazon SES or SNS. The whole thing is serverless, so it costs close to nothing to run and demonstrates how managed components connect.

What it proves to a hiring manager: you can wire static hosting, serverless compute, and managed messaging into one working end-to-end app.

Guided path: take the AWS Concepts course for the core services and Understanding Cloud Computing for the fundamentals behind hosting and serverless.

• Level: Beginner
• Stack: S3 or Cloud Storage, CloudFront, API Gateway, Lambda, SES, or SNS
• Best for: Complete beginners who want a live first project

7. Build an event-driven file-processing pipeline

This project teaches the event-driven pattern that appears constantly in real cloud architectures. It is a natural step up from the contact form.

An upload to S3 or Cloud Storage triggers a Lambda or Cloud Function that processes the file, for example, resizing an image, parsing a CSV, or extracting text, then writes the result to storage and sends a notification through SNS or Pub/Sub. Give the function an IAM role scoped to only the buckets and topics it needs. Least-privilege IAM is where many beginners fall short, so getting it right is a differentiator.

What it proves to a hiring manager: you understand event-driven design and least-privilege IAM, two things that separate a considered build from a tutorial clone.

Guided path: DataCamp's AWS Step Functions tutorial and AWS Cloud Technology and Services course cover triggers, functions, and orchestration.

• Level: Intermediate
• Stack: S3 or Cloud Storage, Lambda or Cloud Functions, SNS or Pub/Sub, IAM
• Best for: Builders who have one serverless project and want to go deeper

Cloud Data and ML Projects for Cloud Data Engineer Roles

Data and ML projects are valuable if you are targeting cloud data engineering, analytics engineering, or platform roles at data-heavy companies. The architecture and code quality matter more than the size of the dataset.

8. Build a batch data pipeline into a cloud warehouse

This is the right project if you are targeting a cloud data engineer or analytics engineering role. It reworks the older cloud analytics idea into a clean end-to-end pipeline.

Ingest a public dataset, transform it with Python or SQL, load it into a cloud warehouse such as BigQuery, Amazon Redshift, or Azure Synapse, and visualize one query result. A small dataset is fine, because the point is the pipeline, not the volume. Document your schema choices and how you would schedule the pipeline to run on a cadence.

What it proves to a hiring manager: you can move data end-to-end into a warehouse, which is the backbone of cloud data roles.

Guided path: follow DataCamp's getting started with Azure Synapse tutorial and take the Introduction to GCP course for BigQuery. The Associate Data Engineer in SQL track helps you build the pipeline fundamentals.

• Level: Intermediate
• Stack: BigQuery, Redshift, or Synapse, Python or SQL, cloud storage
• Best for: Analysts and engineers targeting cloud data roles

9. Build a serverless ML inference service

This project shows you can put a model behind an API without managing servers, which is a modern expectation for applied roles. It consolidates the older serverless machine learning and chatbot ideas into one useful build.

Package a model, for image classification or text, behind API Gateway and a Lambda function or Cloud Functions, and store inputs and outputs in DynamoDB or Firestore. You can use a managed service such as Amazon Rekognition or a Hugging Face model to keep the scope tight. Note the cold-start and cost tradeoffs of serverless inference in your write-up, because that is what shows real judgment.

What it proves to a hiring manager: you understand managed compute, model serving, and the cost tradeoffs of running inference serverlessly.

Guided path: read the guide on cloud architecture for data science and machine learning, then use the AWS Step Functions tutorial to chain the processing steps.

• Level: Advanced
• Stack: API Gateway, Lambda or Cloud Functions, DynamoDB or Firestore, a model service
• Best for: Data professionals moving toward cloud and ML engineering

Observability and Security Projects

Observability and security projects are missing from most junior portfolios, which is exactly why they stand out. Our guided coverage is thinner in these two areas, so these projects lean more on official documentation than the rest of the list, and we say so honestly below.

10. Build a monitoring and alerting stack

Observability projects are taken seriously by hiring managers for cloud and SRE roles because they show you think past the moment of deployment. Most junior candidates skip this, so it is a fast way to stand out.

Deploy Prometheus to scrape metrics from an application and the underlying system, then build a Grafana dashboard with at least two alerting rules. Running it on a single VM or a local kind cluster is enough. As an alternative to a cloud provider, centralize logs in Amazon CloudWatch or Google Cloud Logging, write a query that surfaces a specific error pattern, and attach an alert. Document the thresholds and why you chose them.

What it proves to a hiring manager: you think about what happens after deployment, which is a senior signal even at a junior level.

Guided path: Use the official Prometheus and Grafana documentation for the hands-on build. DataCamp's MLOps Concepts course covers the monitoring principles (statistical and computational monitoring) that carry across to infrastructure.

• Level: Intermediate
• Stack: Prometheus, Grafana, or CloudWatch and Cloud Logging
• Best for: Candidates targeting SRE and reliability-focused cloud roles

11. Implement IAM least-privilege and secrets hardening

Security thinking separates you from candidates who only make things work. You do not need to be a security specialist to demonstrate it, and any engineer who can stand out.

Start from a deliberately over-permissioned setup, use IAM Access Analyzer on AWS or Policy Analyzer on GCP to find excess permissions, and cut them to the minimum required. Then remove any hardcoded credentials and move them into AWS Secrets Manager, Google Secret Manager, or HashiCorp Vault. Document the before state and every change you made and why.

What it proves to a hiring manager: you treat security as a default rather than an afterthought, and you can justify each permission you grant.

Guided path: Understanding Cloud Computing covers the security fundamentals, and the hands-on part uses provider documentation for IAM Access Analyzer and Secrets Manager. This is a docs-led build by design.

• Level: Intermediate
• Stack: IAM Access Analyzer, Secrets Manager or Vault, provider security tooling
• Best for: Engineers who want a differentiator most portfolios lack

What Makes a Cloud Project Stand Out

The project type matters less than the execution. Two things consistently separate a portfolio piece from a tutorial clone, and both are free to add.

• Documented decisions in the README. Explain why this service, why these IAM permissions, why this network design. A project with no documented reasoning looks like a follow-along.
• Security that is not bolted on at the end. No wildcard IAM permissions, no secrets sitting in plain environment variables, nothing public that should be private.
• Depth over count. Two or three well-executed projects across different skill areas outperform six shallow ones every time.
• Coverage of the gaps. A CI/CD pipeline for a containerized app is the automation project most junior roles expect, and a monitoring stack is the one most portfolios are missing.

Final Thoughts

For most people transitioning into cloud roles, the three-tier Terraform project is the right place to start, because infrastructure as code is a skill nearly every cloud and DevOps job lists. If you are aiming squarely at DevOps or platform work, build the GitHub Actions CI/CD pipeline first instead. From there, add one project from a skill area you have no evidence for yet, and make observability or security for that project if you can.

A few honest caveats. You build the cloud parts of these projects in a provider-free tier, not inside a learning platform, so you will need an AWS, Azure, or GCP account and should watch for small charges on services that fall outside the free tier. Treat the guided courses as the fast way to learn the concept, then do the real build yourself, so the work is genuinely yours.

If you want the concepts before you build, the Learn Cloud Computing From Scratch guide and the Understanding Cloud Computing course cover the foundations across a few hours of content.