Shared fate is often read as the cloud provider taking on part of the customer's risk, but it changes how much help the customer gets, not who is accountable for the customer's half. Shared responsibility draws a line between what the provider secures and what the customer secures. Shared fate, a term Google Cloud uses for its own approach, keeps that line and adds provider effort on the customer's side of it: secure defaults, deployable blueprints, compliance guardrails and a route to cyber insurance. This guide compares the two models as concepts, explains what shared fate does and does not change in contracts and audits, and sets out what customers still own whichever label their provider uses. It is written for cloud security architects, GRC and procurement leads, and anyone negotiating or relying on a cloud agreement. The baseline model itself is covered in the Shared Responsibility Models Guide; this page goes further on shared fate.
Where providers are named, they are listed alphabetically: AWS, Google Cloud, Microsoft. Order is not a ranking.
Key takeaways
- Shared fate builds on shared responsibility, it does not replace it. Google describes shared fate as building on the shared responsibility model, and states that customers always remain responsible for their access policies and data.
- Defaults move work, not liability. A provider that blocks public storage or service account keys by default removes a common mistake, but the customer can still switch the default off, and the outcome is then the customer's.
- Insurance tie-ins are underwriting, not cover from the provider. Google's Risk Protection Program lets customers share a posture report with partner insurers; Google states it is not a licensed broker and does not issue policies.
- Contracts rarely change. Shared fate tooling sits in documentation and product settings; the binding allocation of duties is still the customer agreement, the service terms and any negotiated security schedule, so check those, not the marketing model.
- Treat provider defaults as a baseline you verify. Inventory which defaults apply to which resources and when they started, enforce them yourself with policy, and measure drift, because older accounts and resources often predate them.
The short answer
Shared responsibility answers the question "whose job is this control?" Shared fate answers a different question: "how much will the provider help me do my part well?" Under both, the provider runs the physical infrastructure and the services it operates, and the customer owns its data, its identities and access policies, and how it configures the services it uses. Shared fate adds secure-by-default settings, reference architectures deployed as code, compliance boundaries and insurance pathways, which lower the chance that the customer's half fails. It does not move accountability for that half to the provider.
So the practical choice is not between the two models. It is how far to adopt the provider's opinionated defaults and tooling, and how to record in your own control set and contracts which defaults you rely on.
Side-by-side comparison
| Dimension | Shared responsibility | Shared fate |
|---|---|---|
| Core idea | A division of tasks: provider secures the cloud, customer secures what it puts in it | The same division, plus active provider help on the customer's side, described by Google as an ongoing partnership to improve security |
| Where the line sits | Moves with the service model: most customer work in IaaS, least in SaaS | Same line; data and access policies stay with the customer in every model |
| Provider deliverables | Secure infrastructure, compliance reports, configurable security features | Also secure defaults, blueprints with recommendations enabled, compliance guardrails, posture tooling, insurance pathway |
| Default posture | Features available, customer chooses whether to enable | Selected protections on by default for new resources or organisations, customer may change them |
| Main risk addressed | Unclear ownership | Misconfiguration in the customer's half |
| Evidence for auditors | Provider SOC 2 and ISO/IEC 27001 reports for inherited controls; customer evidence for its own | Same, plus inherited defaults such as default encryption that Google says can serve as evidence of posture |
| Contract effect | Defined in the customer agreement and service terms | Usually none by itself: tooling and guidance sit outside the core agreement unless negotiated in |
Each model in depth
Shared responsibility
Threat model: the attacker targets whatever the customer has left open, because the provider's layers are hardened at scale. The realistic threats are stolen credentials, over-permissive identities, exposed storage, unpatched guest operating systems and missing logging. Architecture in words: the provider publishes a matrix per service model, the customer maps each service it uses to that matrix, names owners for its rows and enforces them with its own guardrails. Failure modes: unowned shared rows (patching, configuration, training), SaaS treated as provider-secured, and evidence collected for the provider's half but not the customer's. Controls: a per-service responsibility matrix, organisation-level preventive policy, identity governance, logging and posture management. The Shared Responsibility Matrix Template gives a ready structure.
Worked scenario: a retailer moves its order database to a managed database service. The provider patches the engine and hosts; the retailer still decides network exposure, credentials, MFA and logging. When an analyst's reused password is stolen by infostealer malware, nothing in the provider's half stops the login, because the access policy was the customer's. This is the pattern in the Snowflake breach, where attackers used stolen credentials against customer accounts that had no MFA and no network allow lists.
Shared fate
Threat model: the same attackers, with an added recognition that customers misconfigure. Google's framework page states that many cloud security breaches are the direct result of misconfiguration and that products change constantly. Shared fate aims to shrink the number of insecure states a new customer can reach by accident. Architecture in words: the customer starts from a provider blueprint deployed as infrastructure as code, with the provider's recommendations enabled by default; organisation-level constraints block risky actions; compliance packages such as Assured Workloads apply guardrails to folders holding regulated workloads; posture tooling reports drift; and the posture report can be shared with insurers. Failure modes: older organisations that predate the defaults, blueprints forked and never updated, defaults disabled to unblock a project with no compensating control, and an insurance quote read as evidence of security. Controls: keep the provider defaults under your own policy as code, track exceptions, and re-baseline when the provider changes its defaults.
Worked scenario: a fintech opens a new Google Cloud organisation. Service account key creation is blocked by default, so a developer who wants a JSON key for a CI pipeline is pushed towards workload identity federation instead. Six months later a platform team deletes the constraint to integrate a legacy tool. The provider did its part by starting secure; the decision to remove the constraint, and the long-lived key that follows, sit in the customer's half. The fix is an exception process that scopes the change to one project, records an owner and an expiry, and alerts if keys appear elsewhere. See the Cloud Workload Identity Guide.
What providers now do by default
Shared fate is Google's name, but secure by default changes reach across providers. CISA's Secure by Design programme argues that the cyber security burden falls disproportionately on consumers and small organisations, and defines secure by default as products that are secure out of the box with little or no configuration and at no extra cost. Its Secure by Design Pledge, voluntary and not legally binding, includes goals on MFA, default passwords and evidence of intrusions. Microsoft's Secure Future Initiative, launched in November 2023, states the principle that protections are enabled and enforced by default and are not optional. The table lists examples each provider documents.
| Provider | Default or provider-led control | What it does | What the customer still decides |
|---|---|---|---|
| AWS | Amazon S3 new bucket settings | All four Block Public Access settings are enabled by default, Object Ownership defaults to Bucket owner enforced with ACLs disabled, and SSE-S3 is the base level of encryption for every bucket | Bucket policies, access point policies, whether to turn Block Public Access settings off, and whether to use SSE-KMS keys it controls |
| AWS | EC2 account-level IMDS default | An account can set IMDSv2 as the default so new instances launch with tokens required; enforcement can block launches that are not IMDSv2-only | Whether to set the default and enforcement, per Region; existing instances are not reset |
| Google Cloud | Secure-by-default organisation policies | For organisations created on or after 3 May 2024, baseline constraints are enforced, including iam.managed.disableServiceAccountKeyCreation, iam.disableServiceAccountKeyUpload, iam.automaticIamGrantsForDefaultServiceAccounts, iam.allowedPolicyMemberDomains and storage.uniformBucketLevelAccess | Whether to keep, scope or delete each constraint (requires the Organization Policy Administrator role) |
| Google Cloud | Enterprise foundations blueprint and Assured Workloads | Blueprints ship with security recommendations enabled by default; Assured Workloads applies predefined control packages (for example FedRAMP Moderate and High, IL4, IL5, CJIS, EU Data Boundary) to folders | Which blueprint version to run, how to maintain the fork, which workloads go in regulated folders |
| Microsoft | Mandatory MFA for Azure and admin portals | Phase 1 requires MFA for Azure portal, Microsoft Entra admin center and Intune admin center operations; Phase 2, from 1 October 2025, extends it to Azure CLI, Azure PowerShell, IaC tools and REST API create, update and delete operations | Whether to postpone (Phase 2 postponement was offered to 1 July 2026, with Microsoft noting this adds risk), and how to secure workload identities, which these phases do not cover |
Each default applies from a date or to new resources only. That is the single most important point for a customer: the default describes the provider's starting point, not the state of your estate. Defaults and dates are as documented in November 2026. Provider hardening detail is in the AWS Security Guide, the Google Cloud Security Guide and the Microsoft Azure Security Guide.
Insurance tie-ins: what they are and are not
Google's Risk Protection Program (marked Preview as of November 2026) connects Google Cloud customers with partner cyber insurers. Its Cyber Insurance Hub, powered by Security Command Center, produces organisation-level posture reports aligned to the CIS Google Cloud Platform Foundation Benchmark, and the customer decides whether and when to send a report to the partners. As of November 2026 Google's product page names Beazley, Chubb and Munich Re as partners, states that pricing is set by the insurers, that a licensed broker is needed, that the hub only scans Google Cloud workloads, and that Google is not a licensed insurance broker and does not issue policies.
- What it changes: underwriting can use measured posture rather than a questionnaire, and a better posture may support better terms.
- What it does not change: the provider does not insure you, and the policy terms, exclusions and conditions are between you and the insurer. A report covers Google Cloud only, not your SaaS estate, endpoints or other clouds.
- What to check: whether policy conditions require you to maintain the reported posture, whether a drop in posture after binding affects a claim, and how the cover interacts with any existing cyber policy. See the Cyber Insurance Guide and the Cyber Insurance Claims Process Guide.
What shared fate changes contractually
Very little, unless you negotiate it. Responsibility models, blueprints and framework pages are guidance, and Google's shared fate page itself contains no contractual terms. The binding documents remain the provider's customer agreement, service-specific terms, data processing terms, service level agreements and any security addendum. Shared fate gives you better material to negotiate with.
| Contract area | Under a plain shared responsibility reading | What to ask for when relying on shared fate features |
|---|---|---|
| Security responsibilities | Provider model referenced or absent | A responsibility schedule per service you use, naming which provider defaults you rely on as controls |
| Change to defaults | Provider may change features and defaults | Advance notice of changes to security defaults and blueprints that affect relied-on controls |
| Incident management | Notification duties for provider-side incidents | Defined notification times, cooperation in customer-side incidents and log access; Google itself calls incident management an often overlooked area where responsibilities are not clearly defined |
| Evidence and audit | Provider third-party reports | Access to current SOC 2 and ISO/IEC 27001 reports, the complementary user entity controls, and compliance package documentation such as Assured Workloads boundaries |
| Data location and personnel access | Region choice by customer | Written commitments on data boundaries and support personnel location where compliance packages are used |
| Insurance | None | Clarity that the provider is not party to any insurance policy and what data is shared with insurers, and when |
CSF 2.0 subcategory GV.SC-05 expects supply chain security requirements to be written into contracts and other agreements, and NIST SP 800-53 SA-9 External System Services and SA-4 Acquisition Process are the control hooks. For clause wording see the Third-Party Security Contract Clauses Template, and for deciding when provider reports are enough see Right to Audit vs Assurance Reports. Regional frameworks can also set expectations: see the Singapore Shared Responsibility Framework Guide.
What customers still own
Every provider model, including shared fate, leaves these with the customer:
- Access policies and identities: who and what can do what, including service accounts, roles, keys, OAuth apps and agents. Microsoft's mandatory MFA applies to user sign-ins, and Microsoft states that managed identities and service principals are outside both phases, so workload identity security stays a customer design task. See the Cloud IAM Review Checklist.
- Data: classification, location, retention and encryption key choices. Google notes, for example, that customers with EU residency needs are responsible for keeping data in EU regions.
- Configuration after day one: blueprints start you secure; every later change is yours. See the Cloud Misconfiguration Guide.
- Choosing controls: Google's page puts identifying required controls, from regulation, internal standards and customer requirements, on the customer.
- Detection and response in your tenancy: enabling logs, reviewing them and responding. See the Cloud Incident Response Guide.
- Exit and concentration risk: deeper adoption of one provider's blueprints and packages increases dependency. See the Cloud Concentration Risk and Exit Strategy Guide.
When to lean on each
| Situation | Lean towards | Why |
|---|---|---|
| Small team, new cloud estate, one provider | Provider defaults and blueprints adopted largely as shipped | Fastest route to a sound baseline with little engineering effort |
| Large or long-lived estate with accounts older than the defaults | Your own responsibility matrix and policy as code, using provider defaults as reference | Defaults apply to new resources only; you must back-fill the rest |
| Regulated workloads (public sector, defence, criminal justice, EU sovereignty) | Provider compliance packages plus your own control mapping | Packages enforce boundaries, but the auditor still tests your controls |
| Multi-cloud | One customer-owned control baseline mapped to each provider's defaults | Defaults differ per provider; a single baseline avoids gaps between them |
| Seeking cyber insurance | Posture reporting tied to a benchmark, kept current | Underwriters price measured posture; drift after binding is your risk |
Implementing a shared fate aware control set
- Inventory defaults per provider: list each documented default and its start date or scope (new organisations, new buckets, account-level opt-in), and record which of your accounts, organisations and subscriptions predate it.
- Map defaults to your controls: in the responsibility matrix, mark which customer controls are met by a provider default, and keep the customer as owner of each row.
- Codify the defaults yourself: express them as your own organisation policies, SCPs or Azure Policy assignments so they apply to old and new resources alike. Run new policies in audit or dry-run mode first, then enforce in a pilot folder or account, then estate-wide.
- Define the exception route: scoped, owned, time-limited exceptions with a compensating control, and a documented rollback (detach or scope down the policy) if enforcement breaks production.
- Adopt blueprints deliberately: pin a version, record local changes, and schedule a review against upstream releases.
- Negotiate the contract schedule: notice of default changes, incident cooperation, evidence access and data boundary commitments.
- Connect posture to insurance and risk reporting: if you use an insurer posture report, schedule it and alert on regressions.
Detection and measurement
Monitor the events that show a default being removed or bypassed: organisation policy deletions and changes in Google Cloud audit logs, S3 Block Public Access and bucket policy changes and EC2 metadata option changes in AWS CloudTrail, and Azure Policy assignment and exemption changes in the Azure Activity log. See the Cloud Logging and Audit Trail Guide.
- Default coverage: percentage of accounts, projects and subscriptions where each relied-on default is enforced by your own policy.
- Exception count and age: open exceptions to baseline constraints, and the share past expiry.
- Pre-default estate: number of organisations, accounts and resources created before a default took effect and not yet back-filled.
- Workload identity credentials: count of long-lived service account keys and access keys, trending down.
- Posture score drift: change in benchmark-aligned posture between scheduled reports.
Common failure patterns
- Reading shared fate as shared liability: procurement records the provider as owner of a control because a default exists. Ownership stays with the customer; the default is a means.
- Assuming defaults are retroactive: new-organisation constraints and new-bucket settings do not reach older estates, which is where most exposed resources live.
- Removing a default to unblock a project: a constraint deleted at organisation level for one integration opens every project. Scope exceptions narrowly.
- Option left off: protections offered as settings protect nothing until enabled. In the Snowflake incident MFA and network policies existed as options but were not enabled on the affected accounts, and in the Capital One breach a role reachable through the metadata service could read far more data than it needed.
- Insurance quote as assurance: a posture report is a point-in-time scan of one provider, not an audit of your security programme.
Framework mapping
| Activity | NIST CSF 2.0 | NIST SP 800-53 Rev. 5 | CIS Controls v8.1 | ISO/IEC 27001:2022 Annex A |
|---|---|---|---|---|
| Allocate and record responsibilities with providers | GV.RR-02; GV.SC-05 | SA-9 External System Services | Control 15 Service Provider Management | A.5.19, A.5.20 |
| Prioritise and monitor providers, including default changes | GV.SC-04; GV.SC-07 | SR-3 Supply Chain Controls and Processes; CA-7 Continuous Monitoring | Control 15 | A.5.22 |
| Codify secure defaults as your baseline | PR.PS-01 | CM-2 Baseline Configuration; CM-6 Configuration Settings | Control 4 Secure Configuration of Enterprise Assets and Software | A.8.9 Configuration management |
| Security requirements in acquisition | GV.SC-05 | SA-4 Acquisition Process; SA-8 Security and Privacy Engineering Principles | Control 15 | A.5.23 Information security for use of cloud services |
Decision checklist
- Do we know which provider defaults apply to which of our accounts and resources, and from what date?
- Is every control that a default satisfies still owned by a named person on our side?
- Are the defaults we rely on enforced by our own policy, so they survive a provider change?
- Does our contract give notice of changes to relied-on defaults and define incident cooperation?
- If we use blueprints or compliance packages, is the version pinned and the fork reviewed?
- If we share posture with insurers, do we understand the policy conditions about maintaining it?
Practitioner checklist
- Build a per-provider register of secure defaults with scope and start dates.
- Back-fill defaults to pre-existing accounts, organisations and subscriptions with your own policy.
- Test new guardrails in audit or dry-run mode, then pilot, then enforce, with a rollback route.
- Run a time-limited, owned exception process for any removed default.
- Alert on organisation policy, Block Public Access, metadata option and policy assignment changes.
- Add a responsibility schedule and default-change notice clause to critical provider contracts.
- Review provider SOC 2 or ISO/IEC 27001 reports and implement the user entity controls they list.
Standards and references
- Google Cloud: Shared responsibilities and shared fate on Google Cloud
- Google Cloud: Secure by default organizations
- Google Cloud: Risk Protection Program
- AWS: Creating a general purpose bucket
- AWS: Configure instance metadata options for new instances
- Microsoft Learn: Mandatory multifactor authentication for Azure and admin portals
- CISA: Secure by Design
- NIST: SP 800-53 Rev. 5
Related NHI Mgmt Group resources: Shared Responsibility Models Guide · Shared Responsibility Matrix Template · Cloud Security Guide · Cloud Landing Zone Security Guide · Cyber Insurance Guide