Cloud Service and Deployment Models Questions
The foundational service models (IaaS, PaaS, SaaS, FaaS) and deployment models (public, private, and hybrid cloud) and when each is appropriate. Covers the shared-responsibility boundary, the core value proposition of cloud versus on-premises, how service-model choice shifts operational ownership, vendor lock-in risks and mitigation, and when a single-cloud, multi-cloud, or hybrid-cloud strategy is the better choice. The conceptual entry point before any provider-specific or architectural depth.
Explain what a Platform as a Service (PaaS) offering is and how it differs from IaaS and serverless. Give concrete examples of PaaS products suited to web applications and to container-based workloads, then walk through the operational trade-offs a team takes on by choosing PaaS instead of one of the other two models.
Sample Answer
Direct answer
PaaS sits between IaaS and serverless on a single spectrum of "how much of the running instance do I still manage," rather than off to the side as an unrelated third category. IaaS gives you a virtual machine and you build everything above it. PaaS gives you a managed runtime and deployment target: you push code and the platform runs it continuously. Serverless goes one step further than PaaS by removing the concept of a continuously running instance altogether, scaling to zero and billing per invocation instead.
How PaaS differs from each neighbor
Versus IaaS. On IaaS you decide the OS, patch it, install a runtime, and configure a process manager, and an instance typically stays running whether or not it's serving traffic. On PaaS you supply application code or a container image and a deployment manifest; the platform handles OS patching, runtime installation, health checks and restarts, and autoscaling policy configuration replaces manual instance management.
Versus serverless. PaaS still asks you to think in terms of how many instances and what size, even if it autoscales them for you, and instances generally stay warm between requests. Serverless removes the instance concept entirely, scales per invocation including to zero, and bills per invocation and duration rather than per provisioned hour.
Examples for the two workload shapes the question asks about
Web applications: AWS Elastic Beanstalk, Azure App Service, and Google App Engine let you push source code and get a managed, autoscaled web service with a built-in load balancer.
Container-based workloads: managed container-runtime platforms such as Google Cloud Run or AWS App Runner take a container image, giving you the middleware and dependency control of a container, while the platform still handles the OS, orchestration, and autoscaling, including scaling to zero when idle. This is why these products sit right at the boundary between PaaS and serverless.
Operational trade-offs of choosing PaaS
Instead of IaaS: you give up fine-grained OS and kernel control and the ability to install arbitrary system-level software, and you gain freedom from patch management and instance-level monitoring and alerting.
Instead of serverless: you give up the cost benefit of scaling fully to zero for spiky or idle workloads and take on slightly more capacity-planning thinking, how many instances, what size, but you gain a simpler mental model for stateful or long-running processes and typically fewer cold-start surprises (the extra delay a request hits when it wakes an idle instance or function that has to initialize before it can respond).
Worked example
A small team is choosing between the three for a customer-facing web app with steady, moderate daily traffic that also needs a custom authentication middleware wrapping every request. Raw IaaS would mean owning OS patches for no real benefit, since nothing about the workload needs kernel-level control. Pure serverless functions would technically work but would mean re-architecting the middleware into a function-per-endpoint shape, adding real engineering cost for a workload that isn't particularly spiky. A container-based PaaS product lets the team package the existing middleware into the container image unchanged, deploy it once, and let the platform handle scaling and OS management, which is the best fit given steady traffic and existing middleware investment.
Trade-offs and pitfalls
The main pitfall is picking PaaS reflexively as "the safe middle choice" without checking whether the workload is actually spiky, where serverless's per-invocation billing would save real money, or genuinely needs OS-level control, where PaaS's restrictions become a real blocker, for example a workload needing raw socket access a managed platform won't expose. A second pitfall is assuming all PaaS products are equally restrictive: a container-based PaaS product gives you a much larger slice of control over the runtime and middleware than a source-code-only PaaS product, so the choice between PaaS flavors matters almost as much as the IaaS-versus-PaaS-versus-serverless choice itself.
Explain the differences between IaaS, PaaS, and SaaS from a systems administrator's perspective. For each model, name two example services from AWS, Azure, or GCP, describe one operational responsibility that shifts as you move from IaaS toward PaaS, and note one monitoring or backup implication of that shift.
Sample Answer
Direct answer
From a systems administrator's chair, the IaaS-to-SaaS ladder isn't a technical abstraction exercise, it's a description of which daily tasks disappear or move to a different team at each step, starting with patching and ending with almost the entire job shifting from "keep the infrastructure running" to "manage user access and vendor relationships."
IaaS: the starting point
Example services: AWS Elastic Compute Cloud (EC2), Azure Virtual Machines.
The sysadmin still owns OS patch management: choosing a patch cadence, testing patches, and applying them across the fleet, exactly as with on-premises servers, just on rented hardware. The monitoring and backup implication is direct: you must build and maintain your own OS-level and application-level monitoring and backup jobs, since the provider guarantees the underlying hardware and network, not that your specific virtual machine's disk gets backed up or that a runaway process gets alerted on. A sysadmin moving from on-premises to IaaS who assumes "the cloud backs things up for me" is making the single most common early mistake in this transition.
PaaS: the first real shift
Example services: Azure App Service, Google App Engine.
OS-level patch management moves entirely to the provider. The sysadmin's job shifts from "patch the box" to "verify the platform's automatic runtime and OS updates haven't broken application compatibility," and to managing deployment configuration and scaling policy instead of server configuration. The monitoring and backup implication: infrastructure-level monitoring, is the OS healthy, is disk full, is now the provider's concern, so monitoring effort moves up the stack to application-level health checks and request and error-rate metrics. For backup, "backing up a server" stops being a meaningful task, since there's no persistent server to back up, and the real backup concern moves entirely to whatever managed database or storage the application actually uses.
SaaS: the full shift
Example services: Salesforce, Google Workspace.
There's no infrastructure left for the sysadmin to touch. Operational responsibility shifts to identity and access management, who has an account, what permissions they hold, how quickly access is revoked when someone leaves, and to vendor management, tracking the vendor's service-level agreement (SLA) commitments and uptime history. The monitoring and backup implication: "monitoring" becomes watching the vendor's status page and your own usage and license metrics rather than any system you operate, and "backup" becomes verifying, often by actually testing it rather than trusting a marketing claim, that the vendor's own data-export or retention policy actually meets your organization's recovery needs, since you generally have no independent backup mechanism of your own unless you build one on top of the vendor's export capabilities.
Worked example: a sysadmin's week, across the shift
Under IaaS, a real chunk of a sysadmin's week might go to reviewing patch reports and confirming backup jobs completed successfully across a virtual machine fleet. After a move to PaaS for the same application, that time gets reallocated to reviewing application-level error-rate dashboards and adjusting an autoscaling policy, since there's no OS layer left to patch. After a further move of an adjacent capability, internal email for example, to a SaaS product, the equivalent time goes to a quarterly access review, confirming former employees' accounts were actually deactivated, and confirming that the vendor's exported backup of mailbox data can actually be restored, since that's now the only backup lever left.
Trade-offs and pitfalls
The pitfall specific to this transition is treating it as "less work" rather than "different work." A SaaS-era sysadmin still carries real, auditable responsibility: identity governance, vendor SLA tracking, and verified export or backup capability. An organization that lets go of headcount assuming "SaaS runs itself" typically discovers the gap first during an access-related security incident or a data-recovery request that the vendor's default retention policy doesn't actually cover.
A client asks whether to host their application in public cloud, private cloud, or remain on-prem. Explain the technical, security, compliance, performance, and cost factors you would evaluate to make this recommendation. Provide examples of workloads that should remain on-prem and those that typically benefit most from public cloud.
Sample Answer
Direct answer
The decision isn't really "cloud versus on-prem" on a single axis. It's the tenancy model, shared, multi-tenant public cloud versus dedicated, single-tenant private cloud or on-premises hardware, traded against five concrete factors: technical fit, security posture, compliance obligations, performance and latency needs, and cost structure. Most real recommendations end up as a split rather than one answer for the whole company.
The five factors
Technical. Does the workload need elastic, unpredictable scaling, which favors public cloud, or a fixed, well-understood, steady capacity profile, which favors on-premises or private, where you're not paying an elasticity premium you never use?
Security. Public cloud gives a mature, continuously updated security baseline maintained by a large provider team, but multi-tenancy means your isolation guarantees rest partly on the provider's controls. On-premises or private gives full physical control at the cost of having to build and maintain that posture yourself, a real, ongoing cost most organizations underestimate.
Compliance. Some regulatory or contractual requirements, a specific data-locality mandate or a requirement that data never leave a physical facility, can only be satisfied by physical control that even a carefully chosen public cloud region can't fully replicate. Check the exact wording of the requirement rather than assuming "picked the right region" is automatically sufficient.
Performance. Workloads with extremely tight, physically bound latency requirements, such as control systems on a factory floor that must respond to local sensors in single-digit milliseconds, benefit from being physically co-located with what they control, something no public cloud region, however close, fully replicates. Most business applications don't have this constraint, and public cloud's global network is the better fit for them.
Cost. Public cloud converts a large upfront capital expenditure (CapEx) into an ongoing operating expenditure (OpEx) that scales with usage, attractive for unpredictable or fast-growing demand. On-premises or private can genuinely be cheaper per unit of compute at a large, steady, well-utilized scale, but only if the organization has both the capital to invest and the discipline to keep utilization high, since idle owned hardware is pure sunk cost in a way idle cloud capacity, at least, can be turned off.
Workloads that fit each side
Public cloud: a customer-facing web application with unpredictable, growing traffic; a globally distributed service needing points of presence close to users worldwide; short-lived development and test environments that would sit mostly idle if they were owned hardware.
On-premises or private: a factory-floor industrial control system with hard, physically local latency requirements; a workload subject to a data-locality mandate requiring data to never leave a specific facility; a very large, steady, highly utilized batch workload where owning hardware at scale genuinely beats renting it.
Trade-offs and pitfalls
The common pitfall is a "cloud-default bias," recommending public cloud reflexively because it's the current industry default, without checking the workload's actual utilization pattern. A steady, highly utilized, predictable workload is exactly the case where public cloud's elasticity premium buys nothing, and on-premises or a committed private-cloud capacity plan can be the more defensible, if less fashionable, answer. A second pitfall is treating "private cloud" and "on-premises" as identical: a private cloud can be hosted by a third party in their data center, on dedicated single-tenant infrastructure managed with cloud-like self-service tooling, which is a meaningfully different operational and cost profile from an organization running its own physical data center. The recommendation should specify which of the two it means.
Define the three primary cloud service models: Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS). For each model, give a one-paragraph definition, one concrete vendor example (AWS, Azure, or GCP), and state which layers (networking, virtualization, OS, runtime, middleware, application, data) the provider manages versus the customer. Then classify these real services and justify each: AWS EC2, GCP App Engine, Azure SQL Database, Salesforce, and Google Workspace.
Sample Answer
Direct answer
All three service models sit on one spectrum: how much of the technology stack the provider manages for you, versus how much you still manage yourself. Infrastructure as a Service (IaaS) hands you raw compute, storage and networking and you own everything from the OS up. Platform as a Service (PaaS) additionally takes over the OS, runtime and middleware (the software layer that sits between the OS and your application, such as message queues, application servers, or authentication/session handling), so you just deploy code. Software as a Service (SaaS) is a finished application: you own only your data and how you configure and use it.
The three models, one at a time
IaaS. The provider manages the physical data center, the network hardware, and the virtualization layer (the hypervisor that carves one physical server into many virtual machines). You manage the OS, runtime, middleware, application code, and data. Example: Amazon Web Services (AWS) Elastic Compute Cloud (EC2), which rents you a virtual machine and stops there. IaaS is the right default when a workload needs a specific kernel version, custom drivers, or full control of the network stack, for example lifting an existing application that depends on a particular OS build.
PaaS. The provider additionally owns the OS, runtime and middleware. You push application code (or a container image) and the platform patches, scales and load-balances it for you. Example: Google App Engine on Google Cloud Platform (GCP). PaaS fits a small team that wants to ship a web application without hiring dedicated operations staff.
SaaS. The provider owns everything, including the application itself. You own only your data and its configuration: which users exist, what they can see, how records are structured. Example: Salesforce. SaaS is the right choice for a standard business capability, such as a customer relationship management (CRM) system, where building your own would create no advantage.
| Layer | IaaS | PaaS | SaaS |
|---|---|---|---|
| Networking | Provider | Provider | Provider |
| Virtualization | Provider | Provider | Provider |
| Operating system | Customer | Provider | Provider |
| Runtime | Customer | Provider | Provider |
| Middleware | Customer | Provider | Provider |
| Application | Customer | Customer | Provider |
| Data | Customer | Customer | Customer |
Data never fully moves to the provider's column. You always decide who is allowed to see it and whether it is used correctly, even when the provider secures every layer beneath it.
Worked example: classifying five real services
- AWS EC2 = IaaS. It hands you a virtual machine. You choose and patch the OS, install a runtime, and own everything above the hypervisor.
- GCP App Engine = PaaS. You deploy application code; the platform owns the OS, the language runtime, and automatic scaling. You never log into a server.
- Azure SQL Database = PaaS, not IaaS, even though "it's a database" makes it sound like infrastructure. Microsoft manages the OS and the database engine's patching and high availability; you manage schema, queries and data. Contrast this with running SQL Server on an Azure virtual machine, which would be IaaS, because you would own the OS and the engine installation yourself.
- Salesforce = SaaS. A finished CRM application. You configure objects, fields and workflows and own your customer records, but Salesforce owns the application code, runtime and infrastructure underneath.
- Google Workspace = SaaS. Gmail, Docs and Drive are ready-to-use applications. Your real responsibility is your data and access configuration: who is in your organization and what they can share externally.
The same ladder shows up on an ML (machine learning) team's bill. A GPU-backed virtual machine running a custom training loop is IaaS: you install the framework, the drivers, and manage the OS yourself. A managed training job that takes your training script and returns a model artifact sits in the PaaS band: the provider owns the cluster orchestration and worker scaling (coordinating many machines to run the job together, and adding or removing machines as the workload changes), you own the training code, data and the resulting model. A managed model-serving endpoint is the same band: you supply the model, the platform owns the runtime and autoscaling of the inference containers (the running, ready-to-answer copies of your packaged model that handle prediction requests).
Trade-offs and pitfalls
The most common misclassification is calling a managed database IaaS "because it holds data like a database server would." The test is not what the service does, it's which layers you still touch: if you never patch an OS or install the database engine, it is PaaS regardless of the product name. A second pitfall is assuming SaaS means zero responsibility; you are always responsible for who has access and how it is configured, and a breach caused by an over-permissioned admin account is still your incident even though the vendor wrote no bad code. Finally, don't treat the three models as a single company-wide choice: most real organizations run all three at once (EC2 for a legacy system, App Engine for a new service, Workspace for email), and the interesting decision is made per workload, not once.
Define vendor lock-in in the context of cloud platforms. List five common lock-in vectors (APIs, managed services, data formats, tooling, identity) and propose practical mitigation techniques for each vector that a cloud architect might implement during evaluation and design.
Sample Answer
Direct answer
Vendor lock-in is the cost, in effort, time and money, of switching away from a provider once you have adopted its services, and it grows precisely where you have taken on the most provider-specific convenience. Five common vectors are proprietary application programming interfaces (APIs), managed services with no equivalent elsewhere, provider-specific data formats, provider-specific tooling, and identity. A cloud architect can mitigate each of these during evaluation and design, before the dependency is load-bearing, at a fraction of the cost of untangling it later.
The five vectors and their mitigations
APIs. Calling a provider's proprietary API surface directly throughout the application ties every call site to that vendor. Mitigation: introduce a thin abstraction layer, an internal client wrapping the provider's software development kit, so a future swap touches one module instead of every call site. Where a genuinely portable standard already exists, prefer it over a proprietary equivalent even when the proprietary option is marginally more convenient today.
Managed services with no equivalent elsewhere. Adopting a highly specific proprietary service means there is no "just switch providers" path, only "rebuild it." Mitigation: at design time, evaluate whether an open-source or multi-cloud-available alternative meets the need at an acceptable extra operational cost, and treat the proprietary option as a deliberate, documented trade rather than a default.
Data formats. Exporting data only in a provider-specific format, or having no bulk-export path at all, means migration starts with a data-transformation project before anything else can move. Mitigation: build and periodically test a bulk-export path to an open format (CSV, Parquet, or a standard SQL dump) as part of normal operations, not as a one-time migration afterthought, so it stays trustworthy.
Tooling. Building deployment automation entirely around a provider's proprietary infrastructure-as-code or continuous integration and continuous delivery (CI/CD) product makes the pipeline itself a migration cost. Mitigation: prefer a portable infrastructure-as-code tool such as Terraform over a provider-only equivalent for anything you might need to reproduce elsewhere, and keep build and deploy logic in provider-agnostic tooling where practical.
Identity. Wiring every application's authentication and authorization directly to a provider's identity and access management (IAM) system makes identity itself hard to unwind, since every permission and integration would need recreating. Mitigation: front identity with a standard protocol such as OpenID Connect (OIDC) so the provider's identity system sits behind a portable interface, and keep an inventory of every place a provider-specific role or permission is referenced.
Trade-offs and pitfalls
Every mitigation above has a real, upfront cost, and sometimes worse day-one ergonomics, in exchange for optionality you may never use. The practical stance is to spend mitigation effort proportional to how core and how hard to replace a dependency is, not apply every mitigation to every service uniformly. A low-stakes utility service can reasonably be adopted with zero abstraction; a system-of-record data store deserves the full treatment. The pitfall is doing the opposite: abstracting the trivial dependency for the sake of tidiness while leaving the genuinely core, hard-to-replace one wired in directly because "it was easier to ship that way."
Unlock Full Question Bank
Get access to all 17 Cloud Service and Deployment Models interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.