The shared responsibility model is the framework that defines which security and operational duties belong to the cloud provider and which remain with the customer. In cloud fundamentals, it is usually summarized as the provider being responsible for security of the cloud, meaning the physical facilities, hardware and core virtualization layer, while the customer is responsible for security in the cloud, meaning data, identities, configurations and workloads.
The boundary is not fixed. It shifts with the service model: the more a customer consumes as a managed service, the more the provider handles, but data, identity and access decisions always stay with the customer. Misreading where that line sits is one of the most common root causes of cloud security incidents.
How the responsibility boundary is drawn
The boundary follows the technology stack. Each layer, from the data center floor to the application data, is operated by exactly one party or explicitly shared, and the party that controls a layer is accountable for securing it.
Providers publish their own versions of the model, and Amazon Web Services, Microsoft Azure and Google Cloud describe it with slightly different wording. The principle is consistent: the provider cannot see or govern how a customer configures access, so it cannot be responsible for those choices.
The following table shows the layers of a typical stack and who generally owns each one.
| Layer | Examples | Typical owner |
|---|---|---|
| Physical infrastructure | Data centers, power, cooling, hardware | Provider |
| Virtualization layer | Hypervisor, host operating system | Provider |
| Network controls | Firewall rules, security groups, routing | Customer, on provider tools |
| Guest operating system | Patching, hardening, agents | Customer in IaaS |
| Identity and access | Users, roles, keys, MFA | Customer |
| Data | Classification, encryption choices, backups | Customer |
Responsibilities across IaaS, PaaS and SaaS
The service model is the main variable that moves the line. In IaaS the customer manages almost everything above the hypervisor; in PaaS the provider also runs the operating system and runtime; in SaaS the customer mostly manages users, data and settings.
| Responsibility | IaaS | PaaS | SaaS |
|---|---|---|---|
| Physical and host security | Provider | Provider | Provider |
| Operating system patching | Customer | Provider | Provider |
| Runtime and middleware | Customer | Provider | Provider |
| Application code | Customer | Customer | Provider |
| Application configuration | Customer | Customer | Shared |
| Identity and access management | Customer | Customer | Customer |
| Data protection and classification | Customer | Customer | Customer |
Serverless functions and managed containers sit between IaaS and PaaS. The provider patches the host, yet the customer still owns function permissions, secrets handling and dependency vulnerabilities in its own code packages.
Shared and inherited controls
Some controls are inherited completely from the provider, some are shared, and some are customer-specific. This classification matters most during audits, where a customer may rely on the provider’s attestations for inherited controls but must prove its own controls independently.
| Control category | Example | Evidence the customer needs |
|---|---|---|
| Inherited | Physical access to data centers | Provider audit reports such as SOC 2 or ISO/IEC 27001 |
| Shared | Patch management, awareness training | Provider report plus own records for its layers |
| Customer-specific | Data classification, IAM policies | Own policies, logs and configuration reviews |
A shared control such as configuration management illustrates the split well. The provider maintains the configuration of its infrastructure, while the customer configures its own virtual machines, databases and storage. Both halves must work for the control to be effective.
Where customers most often fail
Most publicly reported cloud breaches trace back to the customer side of the line, not to provider infrastructure. The usual pattern is a configuration the provider made possible but did not make the default, or a default the customer changed without understanding the consequence.
| Gap | Typical consequence | Preventive measure |
|---|---|---|
| Public storage buckets | Exposure of files to the internet | Block public access at account level |
| Overly broad IAM roles | Lateral movement after one compromise | Least privilege and periodic access review |
| Leaked access keys | Account takeover or crypto mining | Short-lived credentials and secret scanning |
| Unpatched IaaS servers | Exploitation of known vulnerabilities | Automated patching and image pipelines |
| No backups of SaaS data | Permanent loss after deletion or ransomware | Independent backup with retention |
The SaaS backup gap deserves emphasis. A provider guarantees service availability and durability of its platform, but it typically does not guarantee recovery from a customer’s own accidental deletion or a malicious insider. Data protection remains a customer duty even in fully managed software.
Applying the model in practice
Organizations turn the model into action by building a responsibility matrix for each service they use. The matrix lists every relevant control, marks it as provider, customer or shared, and names an internal owner for each customer duty.
- Read the provider documentation for each specific service, because responsibilities differ even within one platform.
- Map controls to your compliance framework, such as PCI DSS or GDPR obligations, and record which ones are inherited.
- Use provider guardrails, including policy engines and configuration scanners, to enforce customer-side duties automatically.
- Revisit the matrix during cloud migration or when moving a workload between service models, since the line moves with it.
- Clarify multi-cloud and hybrid cloud boundaries, where each provider draws the line differently.
A frequent misconception is that compliance certification of the provider makes the customer compliant. Provider certifications cover only the provider’s layers; the customer still has to demonstrate its own controls for the workloads it runs.
The idea in brief
Renting space in the cloud is a bit like renting an apartment. The landlord keeps the building safe. That means the roof, the walls, the main door and the wiring. The tenant still locks the apartment door and decides who gets a key.
The shared responsibility model writes down that split for cloud services. The provider protects its buildings, machines and core software. The customer protects its own data, accounts and settings. If a tenant leaves the door open, the landlord is not at fault, and the same is true in the cloud.
A practical scenario
A mid-sized insurance company moves its claims portal to the cloud. The web tier runs on IaaS virtual machines, the database on a managed PaaS service, and staff email on a SaaS suite. During planning, the security team builds a responsibility matrix with 64 controls across the three services.
The matrix reveals that the team had assumed the database provider handled backups for point-in-time recovery beyond seven days. In fact, the default retention was seven days, and longer retention was a customer setting. The team also learns that operating system patching for the web tier is entirely its own job and adds an automated weekly patch pipeline.
Six months later, an analyst accidentally deletes a claims table. Because the team had extended retention to 35 days and enabled deletion protection, the data is restored within two hours. The auditor later accepts the provider’s ISO/IEC 27001 report for physical controls and reviews the company’s own evidence for the rest.