Computer Engineering is coming soon

We're still writing and reviewing the notes for every subject, and we'll open it when every subject is ready. Meanwhile you can practise aptitude, ask Aria about any subject, or see the branches that are ready.

Service models: IaaS, PaaS and SaaS

Clear, exam-focused notes on the three cloud service models — Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS) — their definitions, differences, when to use each, formulas and worked examples.

Drafted with Aria, reviewed by the AiCanCode.org team · Updated . How we write and check our notes. Spotted an error? Use Give Feedback at the bottom of the page.

Why it matters

Cloud service models are the ways a cloud provider packages and sells computing resources. An engineer uses these models when designing, pricing and operating systems on the cloud: choose IaaS for maximum control of virtual machines and networks, PaaS to speed application development and deployment, and SaaS to use ready applications without managing infrastructure.

Key ideas

Start from first principles: the cloud provides shared remote computing resources over a network. Define each model the first time it appears.

  • Infrastructure as a Service (IaaS) — a model in which the cloud provider supplies virtualized compute, storage and networking resources (for example virtual machines, block storage, virtual networks). The customer manages the operating system, middleware and applications. Assumptions: provider offers API/console to create/delete VMs, virtualization layer (hypervisor) isolates tenants, billing is usually by resource usage (CPU-hours, GB-month, GB transferred). Examples: Amazon EC2 and EBS, Microsoft Azure Virtual Machines, Google Compute Engine, OpenStack.

  • Platform as a Service (PaaS) — a model in which the cloud provider supplies an application platform: runtime, libraries, container or managed middleware, and often CI/CD integration. The customer deploys applications without managing OS or underlying infrastructure. Assumptions: standard runtime environments (e.g., Java, Python), some restrictions on system-level access, built-in scaling and monitoring features. Examples: Google App Engine, Heroku, Azure App Service, AWS Elastic Beanstalk, Cloud Foundry.

  • Software as a Service (SaaS) — a model in which the provider delivers a complete software application accessed over the network (usually via a web browser). The provider manages everything: infrastructure, platform, data storage, security patches and upgrades. The customer uses the application and manages only configuration and user data. Examples: Salesforce, Google Workspace, Microsoft 365, Slack.

Other key definitions (defined when first used):

  • Virtualization — the technique of creating a virtual (not physical) version of computing resources, such as a virtual machine (VM) that simulates a physical computer. It is the enabling technology for IaaS. (Typically via a hypervisor for VMs; containers provide OS-level isolation and are often used in PaaS and on IaaS.)

  • Hypervisor — software that creates and runs virtual machines. Two types: Type 1 (bare-metal) and Type 2 (hosted). IaaS providers commonly use Type 1 hypervisors.

  • Elasticity — the property by which resources automatically scale up or down to match workload demand. Elasticity differs from simple manual scaling by being automatic and usually fast.

  • Multi-tenancy — an architecture where multiple customers (tenants) share the same physical resources while keeping data and configuration logically isolated.

  • Service Level Agreement (SLA) — a contract between provider and customer specifying properties such as uptime (percentage), performance, support terms and penalties for violations.

  • Shared Responsibility Model — delineates which security, compliance, and operational responsibilities are handled by the provider and which by the customer; responsibility shifts upward from IaaS (customer manages OS and above) to PaaS (customer manages application and data) to SaaS (customer manages identity, access, configurations, and data usage).

What to draw for exam diagrams (exactly):

  • For comparing models draw a vertical stack with four labeled layers from bottom to top: "Physical Hardware" (draw as a box with servers, storage), "IaaS" (draw VMs, virtual network icons), "PaaS" (draw runtime containers, managed databases), "SaaS" (draw an application/browser icon). Add arrows from each top-layer consumer: IaaS user manages OS+app, PaaS user manages app code only, SaaS user manages configuration only.
  • For a typical IaaS architecture draw: physical host → hypervisor → VM1 (OS + app), VM2, virtual switch → virtual network → public network.

Assumptions commonly used in exam derivations: billing units are linear (cost ∝ resource consumed), SLAs express availability as percentage of total time, elasticity reacts within a defined time window.

Formulas

Availability (%) = ((Total time - Downtime) / Total time) × 100 — Total time and Downtime in same units (hours). Use when computing SLA uptime.

Utilization = (Active resource time / Provisioned resource time) × 100% — unit: percent. Use when measuring how well provisioned resources are used.

Elasticity ratio = Peak provisioned / Average provisioned — unitless. Useful to quantify how spiky a workload is; higher means more peak capacity needed.

Amortized annual cost = (CAPEX / Useful life in years) + OPEX per year — units: currency per year (e.g., INR/year). Use when comparing on-premises CAPEX+OPEX vs cloud OPEX.

Cloud cost per period = Σ (unit_price_i × usage_i) — currency per period. Sum over CPU-hours, GB-months, GB transferred etc.

Notes about these formulas: there are no physics SI units here; currency and time units must be consistent (e.g., hours, years). Verify provider billing units before using formulas. CAPEX = Capital Expenditure; OPEX = Operating Expenditure.

Worked examples

Example 1 — Cost comparison (numerical). Problem: Compare 1-year cost of on-premises vs IaaS for a small web service. Given:

  • On-premises server cost (CAPEX) = INR 300,000; useful life = 3 years.
  • On-premises yearly OPEX (power, cooling, admin) = INR 60,000/year.
  • IaaS cost estimate = INR 25 per CPU-hour, 100 CPU-hours per month; storage INR 1 per GB-month, 500 GB used. Calculate 1-year cost for both. Steps:
  1. Amortized annual CAPEX = 300,000 / 3 = INR 100,000/year.
  2. On-premises annual total = amortized CAPEX + OPEX = 100,000 + 60,000 = INR 160,000/year.
  3. IaaS compute cost per year = 25 INR/CPU-hour × 100 CPU-hours/month × 12 = 25 × 1,200 = INR 30,000/year.
  4. IaaS storage cost per year = 1 INR/GB-month × 500 GB × 12 = 1 × 6,000 = INR 6,000/year.
  5. IaaS annual total = compute + storage = 30,000 + 6,000 = INR 36,000/year. Conclusion: For this workload, IaaS at INR 36,000/year is cheaper than on-premises INR 160,000/year, assuming performance and SLA needs are met. (Assumptions: no additional licensing, network egress costs ignored.)

Example 2 — SLA availability calculation. Problem: A SaaS application had 8 hours of downtime in a 1-year period. Compute availability percent. Steps:

  1. Total time = 365 days × 24 hours = 8,760 hours.
  2. Downtime = 8 hours.
  3. Availability = ((8,760 - 8) / 8,760) × 100 = (8,752 / 8,760) × 100 ≈ 99.9087%. Answer: 99.9087% availability (often expressed as 99.91%).

Example 3 — Model-answer long question: "Which service model to choose for a start-up building a public web app with variable load?" Sample full-marks answer structure:

  • Define IaaS, PaaS, SaaS.
  • State requirements: start-up wants fast time-to-market, limited ops staff, variable load, wants to avoid OS maintenance but needs full control of app code and some custom middleware.
  • Argue PaaS is appropriate: it removes OS management, offers built-in scaling (elasticity), CI/CD integration, reduces operational cost and time-to-market. If application needs unsupported low-level customisation, use IaaS for those components and PaaS for the main app (hybrid approach).
  • Mention trade-offs: vendor lock-in risk with PaaS, limited control vs IaaS, SaaS unsuitable because custom app needed.
  • Conclude with recommended architecture: PaaS for app, managed database service (PaaS) or DBaaS, object storage, CDN for static content. Include SLA expectations.

Common mistakes

  • Ignoring network egress/bandwidth costs in cloud cost calculations.
  • Confusing elasticity (automatic) with scalability (can be manual or automatic).
  • Quoting availability as an absolute guarantee without reading SLA exclusions (maintenance windows, force majeure).
  • Assuming PaaS supports all native OS features; many PaaS runtimes restrict system access.

For your exam

Question types you will see: definitions (short answer), compare-and-contrast (IaaS vs PaaS vs SaaS), design questions (choose a model and justify), numerical cost comparisons, SLA and availability calculations, diagram-drawing (architecture stacks).

What a full-marks answer includes:

  • Precise definitions of the service models (bold the model name), clear assumptions, and a neat diagram where required.
  • For choices: list requirements, map each requirement to model features, discuss trade-offs (cost, control, maintenance, vendor lock-in), give final recommendation and alternatives.
  • For numericals: show formulas, plug numbers with units, carry units through, show final answer with correct precision.

Quick check

  1. Define IaaS in one sentence.
  2. Give the formula to compute availability percentage.
  3. Name two reasons to choose PaaS over IaaS for a new web application. Answers: (1) IaaS = cloud model that provides virtualized compute, storage and networking where customer manages OS and above. (2) Availability (%) = ((Total time - Downtime) / Total time) × 100. (3) Faster time-to-market and reduced operational overhead (no OS/middleware management); built-in scaling/CI/CD.

Finished this topic? Mark it so your progress, study plan and readiness keep up.

Stuck on something here?