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.
Serverless functions are often described as a form of PaaS. Explain whether serverless (e.g., AWS Lambda, Azure Functions, GCP Cloud Functions) is best classified as PaaS, something between PaaS and SaaS, or a distinct model. Discuss responsibilities for runtime, scaling, and application code management.
Sample Answer
Direct answer
Serverless functions, also called Function as a Service (FaaS: AWS Lambda, Azure Functions, Google Cloud Run functions, the platform formerly known as Cloud Functions), are best understood as a further point along the PaaS spectrum rather than a wholesale new category or a step toward SaaS. The provider takes over everything PaaS already took over (OS, runtime, middleware) plus two things classic PaaS still leaves you: capacity planning and idle cost. What makes serverless feel distinct is a difference of granularity and billing, not a different responsibility layer.
Why not SaaS, and why "further along PaaS"
SaaS gives you a finished application. Serverless gives you a place to run your application code, so it fails the core SaaS test immediately: does the provider own the application logic? No, you still write the function.
PaaS gives you a managed runtime you deploy a service into and typically leave running continuously; you still think in terms of "how many instances" and pay for a provisioned server whether or not it's handling a request. Serverless removes the instance concept from your mental model entirely: the platform decides how many copies of your function to run, scales all the way to zero when idle, and bills per invocation and execution duration rather than per hour of a running server. That is a difference in degree along the same "who manages what" ladder PaaS is already on, not a new category.
The three responsibilities the question names
- Runtime: entirely the provider's. It picks the execution environment, patches the language runtime, and you only choose a supported version and keep your code compatible with it.
- Scaling: entirely the provider's, and automatic. It scales per invocation, including to zero, and the levers you get are reserved concurrency (a cap that both guarantees and limits how many copies of your function can run at once, useful for protecting a downstream dependency like a database connection pool, at no extra charge) and, on some platforms, provisioned concurrency (an additional-cost option that keeps a guaranteed number of copies pre-initialized and ready, so a request doesn't have to wait for a fresh one to start) to reduce cold starts.
- Application code: yours, same as PaaS. You still own business logic, dependencies, and any bugs in your function.
Worked example
Contrast two workloads. An internal admin dashboard that gets hit sporadically all day is a natural PaaS fit: a provisioned instance sits warm between requests, and you pay for that idle time regardless of traffic. An event-driven job that resizes an uploaded image whenever one lands in storage is a natural serverless fit: the function runs for, say, a few hundred milliseconds per image and you pay only for that time, at the cost of a cold-start penalty the first time an idle function wakes up to handle a request.
Trade-offs and pitfalls
Serverless trades away two things PaaS still gives you. First, statelessness: nothing reliably persists in memory between invocations, so any state the workload needs has to live in an external database or cache. Second, a hard maximum execution duration, which makes serverless a poor fit for long-running or streaming work. The common pitfall is treating "serverless" as free of operational burden entirely; in practice you trade server-patching burden for observability burden, since tracing a request across many short-lived, independently scaling function instances is genuinely harder to reason about than reading one long-lived process's logs.
Compare IaaS, PaaS and serverless computing models. For each model describe who is responsible for infrastructure management, typical use cases, scaling characteristics, operational overhead and cost considerations. Finally, recommend which model you'd choose for a microservices-based SaaS MVP and explain why.
Sample Answer
Direct answer
For a microservices-based Software as a Service (SaaS) Minimum Viable Product (MVP), the smallest version of a product built to test whether it's worth building further, serverless is usually the strongest starting point of the three models, specifically because an early MVP's traffic is low and unpredictable, and serverless is the only one of the three that lets infrastructure cost track that near-zero, uncertain usage instead of a provisioned baseline.
Comparing the three models
| IaaS | PaaS | Serverless | |
|---|---|---|---|
| Infrastructure management | You own OS, runtime, middleware | Provider owns OS, runtime, middleware; you own app and deploy config | Provider owns everything except your function code |
| Typical use case | Custom OS or kernel needs, legacy lift-and-shift, specialized compute | Standard web services and APIs where a team wants to focus on code, not servers | Event-driven, bursty, or intermittent workloads; individual microservice endpoints |
| Scaling | Manual or self-configured autoscaling of instances | Platform-managed autoscaling, still instance-shaped | Automatic, per invocation, scales to zero when idle |
| Operational overhead | Highest: patching, capacity planning, monitoring the OS layer | Medium: app-level monitoring and deploy config, no OS-level work | Lowest on infrastructure, but distributed tracing (following one request as it hops across many separate function calls, to see where time or errors occurred) becomes its own overhead |
| Cost model | Pay for provisioned capacity whether used or not, unless carefully right-sized | Usually a provisioned-tier cost plus some usage-based extras | Pay per invocation and execution time; near-zero cost at near-zero usage |
Recommendation for the microservices MVP
Serverless functions per microservice endpoint, for two reasons specific to an MVP. First, cost tracks actual, likely very low, usage instead of paying for provisioned capacity nobody's using yet. Second, the natural unit of a microservice, a small, independently deployable piece of functionality, maps cleanly onto a function's natural unit, one thing, triggered by one event or request, so the architecture and the billing and scaling model reinforce each other instead of fighting.
Worked example
Contrast the three models for one specific microservice in the MVP: send a welcome email on signup. On IaaS, that's a small, always-on virtual machine, patched and paid for around the clock to occasionally handle a handful of signups a day, wasteful at MVP scale. On PaaS, it's a small, always-on managed instance, better than IaaS operationally but still billed close to continuously even when signups are rare. On serverless, it's a function triggered directly by the signup event, running for perhaps a few hundred milliseconds, costing essentially nothing when there are no signups. That is the correct cost shape for a product that might get five signups a day during early testing and needs to be able to jump to five hundred without a re-architecture.
Trade-offs and pitfalls
The honest caveat on this recommendation is that "serverless-first for an MVP" stops being obviously correct once the product finds traction and specific services develop steady, high, predictable traffic, since a steadily busy function can end up costing more per unit of work than an equivalent always-on PaaS or IaaS instance. The practical move once that happens is to migrate the specific hot service, not the whole system, to a more provisioned model, while keeping genuinely spiky or rare services on serverless. A separate pitfall is assuming "microservices" implies "serverless" as a package deal; microservices is really about how you decompose the system, and it works fine with any of the three service models per service, so the service-model choice should still be made per microservice based on its own traffic shape, not inherited automatically from the architecture style.
Compare single-cloud, multi-cloud, and hybrid-cloud strategies. For each approach: define it, list three business or technical scenarios where it is the preferred choice, and explain the primary trade-offs in cost, complexity, operations, and vendor risk. Then argue the other side: describe a scenario where multi-cloud looks attractive but is not actually worth the added complexity.
Sample Answer
Direct answer
Single-cloud means running the whole estate on one public provider. Multi-cloud means deliberately running production workloads across two or more public providers. Hybrid means splitting workloads between a private environment, on-premises or a dedicated private cloud, and one or more public clouds, usually with real integration between the two. These describe different axes (how many providers, versus what type of environment), and conflating "multi-cloud" with "hybrid" in casual conversation is itself a common interview trip-up worth naming directly.
The three strategies
Single-cloud. Preferred when: a small team has no dedicated platform engineers and operational simplicity matters more than negotiating leverage; a workload depends heavily on one provider's deeply integrated managed services, where reimplementing that integration elsewhere would erase most of the benefit; or volume-discount pricing from fully committing to one vendor materially outweighs diversification. Trade-offs: lowest complexity and lowest operational cost (one identity system, one network model, one team to train), but the highest single-vendor risk, since a pricing change, regional outage, or provider incident affects 100 percent of the footprint.
Multi-cloud. Preferred when: there is a genuine best-of-breed need, using one provider's specialized service for one workload and a different provider's for another, driven by real capability differences; a regulatory or customer-contract requirement explicitly bars single-vendor concentration; or resilience against a provider-level outage is worth the ongoing tax for a small number of genuinely critical services. Trade-offs: the highest complexity and operational cost of the three, duplicate identity, networking, observability and skills investment across two ecosystems, plus the cost and latency of any cross-cloud data movement, but the lowest single-vendor dependency risk.
Hybrid. Preferred when: a phased migration off legacy on-premises infrastructure needs a transitional state rather than an instant cutover; "cloud bursting" keeps a steady baseline on-premises and bursts to public cloud only for demand spikes, such as seasonal retail traffic; or a data-residency or latency-sensitive requirement keeps specific data or equipment on-premises, such as factory-floor control systems, while everything else runs in public cloud. Trade-offs: moderate-to-high complexity from integrating two fundamentally different environments with consistent identity and networking; cost sits between the other two depending on the size of the on-premises footprint; vendor risk is lower than single-cloud for the public-cloud portion, but you also now carry on-premises operational risk (hardware refresh cycles, physical capacity planning) that a pure public-cloud strategy would have eliminated.
| Complexity | Operational cost | Vendor risk | |
|---|---|---|---|
| Single-cloud | Lowest | Lowest | Highest |
| Multi-cloud | Highest | Highest | Lowest |
| Hybrid | Medium to high | Medium, depends on on-premises footprint | Medium |
Arguing the other side: when multi-cloud isn't worth it
A mid-sized team decides to run its core application redundantly across two public providers purely to avoid lock-in and gain negotiating leverage, with no regulatory driver and no measured history of a provider outage actually hurting them. In practice this doubles the identity, networking, CI/CD and observability surface the team maintains, and because engineers now need competence in two ecosystems, hiring and onboarding get harder too. The negotiating-leverage benefit is largely theoretical unless spend is large enough that a vendor actually cares about losing the account, and the resilience benefit is often illusory as well, since running two clouds through a thin, lowest-common-denominator abstraction tends to produce an application that gets neither provider's differentiated capabilities while still paying the full operational tax of two ecosystems. The more honest call here is single-cloud with strong internal portability discipline rather than pre-emptively paying the multi-cloud tax for a risk that hasn't materialized.
Trade-offs and pitfalls
The recurring pitfall in interview answers is conflating hybrid with multi-cloud: hybrid is about environment type (private plus public), multi-cloud is about provider count (two or more public providers). You can be both at once, a private data center integrated with two different public clouds, and naming that combination unprompted is a good signal of real fluency with the terms.
Describe a concise, repeatable approach to produce a high-level Total Cost of Ownership (TCO) estimate for moving a core application to a public cloud for a 3-year horizon. Which cost categories do you include (cloud, networking, staff, licensing, migration), and how would you handle uncertainty and sensitivity analysis?
Sample Answer
Direct answer
A repeatable Total Cost of Ownership (TCO) approach for a 3-year cloud migration is: fix a small set of cost categories, build a low, base, and high estimate per category per year rather than a single number, sum to a 3-year total, and present the range together with the one or two assumptions that actually drive it, instead of a single, falsely precise figure.
Cost categories
- Cloud: compute and storage run rate.
- Networking: data-transfer and egress cost, easy to under-budget because it scales with usage in a way that's less visible than compute.
- Staff: both steady-state operations after migration and the migration labor itself, which is usually front-loaded into year one and often underestimated.
- Licensing: existing software licenses that may be retired or kept during a transition period, plus any new cloud-native tooling now paid for separately.
- Migration: one-time cost of assessment, refactoring, data transfer, and a dual-run period where both the old and new environments are paid for simultaneously.
Handling uncertainty and sensitivity
Treat each category as a range, not a point estimate, and weight the range asymmetrically toward the high side for anything without direct historical data, since migrations of this shape run over more often than under. Rather than sensitivity-testing every category equally, identify the one or two most likely to actually swing the total, usually the one-time migration cost and the ongoing infrastructure run rate, and spend the analysis effort there.
Worked example
For a hypothetical mid-sized application migration (illustrative figures, not derived from any real deal), assume a steady-state post-migration run rate of $180k a year in cloud compute and storage plus $20k a year in networking, $90k a year in steady-state operations staff, and $40k a year in licensing. Year one additionally carries a $120k one-time migration cost and elevated staff cost of $150k, migration labor plus ramping operations, while cloud and networking only reach about half the steady-state rate as workloads cut over gradually through the year.
| Category | Year 1 | Year 2 | Year 3 |
|---|---|---|---|
| Migration (one-time) | $120k | $0 | $0 |
| Cloud (compute, storage) | $90k | $180k | $180k |
| Networking (data transfer, egress) | $10k | $20k | $20k |
| Staff (operations + migration labor) | $150k | $90k | $90k |
| Licensing | $40k | $40k | $40k |
| Year total | $410k | $330k | $330k |
Base-case 3-year TCO: $410k + $330k + $330k = $1,070k (about $1.07 million).
For sensitivity, apply a downside of minus 10 percent to the one-time migration cost and minus 15 percent to the combined cloud-and-networking line (the two most estimate-sensitive items), and an asymmetric upside of plus 30 percent to migration and plus 15 percent to cloud-and-networking, reflecting that migrations more often overrun than underrun.
Low case: migration $120k times 0.9 is $108k; cloud-and-networking $100k times 0.85 is $85k in year one and $200k times 0.85 is $170k in years two and three. Year 1 low = 108 + 85 + 150 + 40 = $383k; Year 2 and Year 3 low = 170 + 90 + 40 = $300k each. 3-year low = 383 + 300 + 300 = $983k.
High case: migration $120k times 1.3 is $156k; cloud-and-networking times 1.15 is $115k in year one and $230k in years two and three. Year 1 high = 156 + 115 + 150 + 40 = $461k; Year 2 and Year 3 high = 230 + 90 + 40 = $360k each. 3-year high = 461 + 360 + 360 = $1,181k.
The presented range is roughly $983k to $1,181k around a base case of $1,070k, about plus or minus 10 percent, and the two line items that drive nearly all of the spread are the migration cost and the cloud-and-networking run rate.
Trade-offs and pitfalls
The most common mistake is budgeting only the recurring run rate and forgetting the one-time migration and dual-run overlap cost, which routinely turns out to be one of the largest single-year line items. A second mistake is ignoring networking, since data-transfer and egress cost is often billed separately and can quietly become a meaningful recurring cost that a "compute and storage" estimate alone misses. A third is presenting a single-point TCO number as if it were precise; a 3-year infrastructure estimate carries enough real uncertainty, demand growth, price changes, migration scope creep, that a range with named drivers is both more honest and more useful for a budget decision than false precision.
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 15 Cloud Service and Deployment Models interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.