Cloud Computing and Cloud Development Environments
Module 1 · The Cloud and the Frontend

Cloud Computing and Cloud Development Environments

Meet the movie app you'll grow through this course, learn what 'the cloud' actually means, how IaaS, PaaS, and SaaS divide responsibility, and why a containerized cloud dev environment plus Git version control is where every tier begins.

One App, Ten Architectures

This course follows a single application from its simplest possible form to a system with ten moving parts. The app never changes its purpose — it helps someone find movies — but every module asks the same question: what does this app need next, and what does adding it cost in complexity and risk?

The purpose is captured in a user story, a one-sentence statement of who wants what and why:

As a movie enthusiast, I want to search and browse a list of movies with details such as title, genre, and year, so that I can easily find information about movies I’m interested in.

User stories keep engineering effort pointed at value for a real person. Notice what the story doesn’t say: nothing about React, databases, or clouds. Those are implementation choices, and they’ll change many times while the story stays nearly the same. Later modules add only two more sentences — “get recommendations from my selections” and “chat to get recommendations” — and those two sentences drive most of the course’s complexity.

Version one has exactly two features:

FeatureWhatWhy
Movie list displayShows titles, genres, and release yearsGives a complete view of what’s available
SearchA text field that filters the list as you typeFinds a specific movie fast

Here is the whole architecture at this stage. It will grow a tier at a time.

GitHub repo Codespaces dev env User Web frontend React · browser
Module 1: a browser frontend, with the code living in a GitHub repository and edited in a cloud dev environment.

What “The Cloud” Actually Means

Cloud computing is renting computing resources — servers, storage, databases, networks, even whole applications — over the internet, on demand, and paying for what you use instead of buying and running hardware yourself.

Five characteristics separate genuine cloud services from “a server somewhere else”:

  • On-demand self-service — you provision resources yourself through a console or API, with no ticket to a human.
  • Broad network access — reachable over standard internet protocols from any device.
  • Resource pooling — the provider shares a large pool of hardware among many customers.
  • Rapid elasticity — capacity scales up and down quickly, sometimes automatically.
  • Measured service — usage is metered, and you pay for what you consume.

Who manages what: IaaS, PaaS, SaaS

Cloud services are usually grouped by how much of the stack the provider runs for you. The line between “provider’s job” and “your job” is called the shared responsibility model, and it matters most for security: anything on your side of the line is yours to patch, configure, and protect.

ModelYou manageProvider managesExamples you’ll meet in this course
IaaS (Infrastructure as a Service)OS, runtime, app, dataPhysical hardware, networking, virtualizationAmazon EC2 virtual servers (Module 5)
PaaS (Platform as a Service)Your app and dataEverything underneath, including OS and runtimeManaged databases like MongoDB Atlas (Module 3)
SaaS (Software as a Service)Your settings and contentThe whole applicationGitHub, Google Docs

The further right you rent, the less you control — and the less you have to secure yourself. Choosing a tier is always a trade between control and responsibility.


The Cloud Development Environment

Before any user sees the app, a developer has to write it. Traditionally that meant installing the right language version, package manager, database, and tools on your own laptop — and discovering that your laptop and your teammate’s laptop behave differently.

A cloud development environment (GitHub Codespaces is the one used throughout this course) moves the whole workspace into the cloud. You open a browser tab or editor and get a ready-to-use machine with the code, terminal, and tools already set up. Think of it as Google Docs for coding: the work lives in the cloud, and any device can open it.

What makes this work is containerization. A container packages an application together with everything it needs to run — runtime, libraries, system tools, configuration — into one isolated unit. A Codespace is a container described by a configuration file in the repository, so every person who opens the project gets an identical environment.

BenefitWhy it matters
Consistency”Works on my machine” stops being a problem — every machine is the same machine
Fast onboardingA new contributor is productive in minutes, not days
Device independenceA Chromebook or tablet can run a full development stack
IsolationExperiments can’t damage your personal computer

Port forwarding

When you start a development server inside a Codespace, it listens on a port — a numbered door on a machine that a particular program answers. The React dev server, for example, typically listens on port 3000. Because the Codespace is a remote machine, the platform forwards that port to a URL you can open in your browser.

Each forwarded port has a visibility setting. Private means only you, signed in, can reach it. Public means anyone with the URL can. You’ll see later in the course that some setups need public ports (a phone can’t sign in to your GitHub account), and that this convenience is also an exposure.


Version Control with Git and GitHub

Version control records every change to a codebase so you can see history, undo mistakes, and work in parallel without overwriting each other. Git is the version control tool; GitHub is a hosted service for Git repositories plus collaboration features. If Codespaces is Google Docs for coding, GitHub is the shared Google Drive where the documents and their full revision history live.

The core vocabulary:

  • Repository (repo) — the project folder plus its complete change history.
  • Commit — a saved snapshot of changes, with a message explaining what changed and why.
  • Branch — a parallel line of work that can later be merged back.
  • Push / pull — send your commits to the shared repo, or bring others’ commits into yours.
  • Pull request — a proposal to merge a branch, where teammates review the change before it lands.

Version control is also the foundation for everything automated later in the course. In Module 4, a push to the repository becomes the trigger that runs tests, security scans, and deployments.

⚠️ Common Pitfall: Treating the Repository as a Private Notebook

Common mistake: committing passwords, database connection strings, or API keys “just for now” because the repo feels private.

Git keeps every version forever. Deleting a secret in a later commit doesn’t remove it from history, and repositories get made public, forked, or cloned onto laptops that get lost. Secrets belong in environment variables or a secrets manager — a pattern you’ll use from Module 3 on — and a leaked secret must be rotated (replaced), not just deleted.

🧠 Knowledge Check

1. A team moves its database to a managed service where the provider handles the operating system, patching, and backups, while the team manages its data and access rules. Which service model is closest?

2. What is the main reason a cloud dev environment eliminates 'works on my machine' problems?

3. You accidentally committed a database password, then removed it in the next commit. What's the correct next step?

4. Why does the user story deliberately avoid naming technologies like React or MongoDB?


Up Next

With the environment and repository in place, the next lesson looks inside the frontend itself: how a React interface holds state, re-renders, and turns keystrokes in a search box into a filtered list.