Shared responsibility model

On this page 7

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.

LayerExamplesTypical owner
Physical infrastructureData centers, power, cooling, hardwareProvider
Virtualization layerHypervisor, host operating systemProvider
Network controlsFirewall rules, security groups, routingCustomer, on provider tools
Guest operating systemPatching, hardening, agentsCustomer in IaaS
Identity and accessUsers, roles, keys, MFACustomer
DataClassification, encryption choices, backupsCustomer
Layers of the stack and typical owners

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.

ResponsibilityIaaSPaaSSaaS
Physical and host securityProviderProviderProvider
Operating system patchingCustomerProviderProvider
Runtime and middlewareCustomerProviderProvider
Application codeCustomerCustomerProvider
Application configurationCustomerCustomerShared
Identity and access managementCustomerCustomerCustomer
Data protection and classificationCustomerCustomerCustomer
Who manages what by service model

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 categoryExampleEvidence the customer needs
InheritedPhysical access to data centersProvider audit reports such as SOC 2 or ISO/IEC 27001
SharedPatch management, awareness trainingProvider report plus own records for its layers
Customer-specificData classification, IAM policiesOwn policies, logs and configuration reviews
Control categories in practice

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.

GapTypical consequencePreventive measure
Public storage bucketsExposure of files to the internetBlock public access at account level
Overly broad IAM rolesLateral movement after one compromiseLeast privilege and periodic access review
Leaked access keysAccount takeover or crypto miningShort-lived credentials and secret scanning
Unpatched IaaS serversExploitation of known vulnerabilitiesAutomated patching and image pipelines
No backups of SaaS dataPermanent loss after deletion or ransomwareIndependent backup with retention
Common customer-side gaps

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.