Prepare and test your skills
Prepare and test your skills
Administrative isolation and resource grouping is the practice of using the Google Cloud resource hierarchy to separate teams, environments, and costs while keeping central control. The hierarchy flows from the organization (opens in a new tab) at the root through folders to projects, and Resource Manager (opens in a new tab) manages how resources are grouped and where policies are inherited from. Folders provide delegated administration for groups of projects, while projects provide strong isolation for workloads, environments, and billing.
The organization is the root node of the hierarchy and represents the company that owns all cloud resources. All resources that belong to an organization are grouped under the organization resource, which provides central visibility and control over every project, folder, and service resource. With an organization resource, projects belong to the organization rather than to individual employees, so resources remain available when employees leave and rogue projects can be centrally viewed. Use a single organization node whenever possible to avoid management overhead, and do not copy the corporate chart directly into the hierarchy. Focus instead on business needs and operations in Google Cloud, including who is responsible for resources, compliance needs, and future mergers, acquisitions, and spin-offs.
Multiple organization nodes are considered only for specific situations:
Folders are optional grouping mechanisms within an organization that organize projects into logical groups such as departments, teams, business units, or environments. A folder can contain projects, other folders, or a combination of both, but a given folder or project has exactly one parent. Policies set on a folder cascade to all child folders and projects, so different teams can manage their own branch without managing each project individually. For example, granting a user the Folder Admin role or Compute Instance Admin role on a folder automatically applies that role to all projects within that folder.
Folder structure enforces separation of concerns between teams with different expertise and access needs. An enterprise example uses three top-level folders where the Network Team folder hosts virtual private clouds (VPCs), the Cluster Team folder hosts clusters per environment, and the Tenants folder hosts tenant non-cluster resources with one subfolder per tenant. Each branch can then use subfolders for development, staging, and production so environment-specific organization policies apply only to that branch. Folder limits shape this design because a parent folder can contain up to 300 direct child folders, folders can be nested up to 10 levels deep, and folder display names must be unique within the same level of the hierarchy.
Projects are the base-level containers for resources, and every resource such as a Compute Engine virtual machine, Cloud Storage bucket, Pub/Sub topic, or database belongs to exactly one project. Projects are used to enable application programming interfaces (APIs), manage billing, and collaborate with team members, which makes the project the primary method for segregating resources in Google Cloud. Separate projects isolate production from staging and development, isolate teams from each other, and isolate billing responsibility because billing is assigned at the project level. Moving a project into a different folder or organization changes which parent policies the project inherits from.
Dedicated projects limit blast radius for configuration, security, and capacity. Some IAM configuration is per-project, so placing different clusters in different projects ensures that a misconfiguration in one project will not affect all clusters at once and allows progressive rollout of changes. By default, workloads running in different projects are far more segregated than workloads in the same project, so a compromised or misbehaving workload in one cluster has limited impact on other clusters. Quotas are also established and enforced per-project, so spreading clusters across projects prevents a single autoscaled workload from exhausting an entire environment's limits.
Inheritance in Google Cloud flows from parent resources to child resources, and child resources inherit access and configuration controls from their folders and organization. Organization policies are inherited by descendants but can be superseded by policies defined at a lower level, which allows broad guidelines with targeted exceptions. Allow policies are inherited by descendants and are additive at lower levels, while deny policies are applied before allow policies and can restrict permissions at the organization, folder, and project level. Hierarchical firewall policies also inherit implicitly through the hierarchy, so traffic can be allowed or denied at any level or delegated to a lower level for decision.
Shared operational controls depend on the hierarchy for scope and aggregation:
Exam tip: Billing is assigned at the project level, not the folder level; use billing reports grouped by project hierarchy to see aggregated folder costs.
A grouping pattern is the choice of what sits at the top of the folder hierarchy to drive policies and access, and most organizations use a hybrid approach starting with the design that most affects policies and access. The three common patterns differ by whether environments, regions or subsidiaries, or product ownership require the strongest autonomy. Keep bootstrapping resources and common services in separate folders, with the bootstrap folder for infrastructure-as-code (IaC) deployment placed directly below the organization node. Place shared services either at the top for cross-environment services like monitoring or lower for per-environment shared services like secrets.
| Pattern | Top-level grouping | Choose when |
|---|---|---|
| Hierarchy based on application environments | Development, testing, and production folders | Environments need different policies, centralized security must enforce production controls consistently, and IAM roles differ by environment |
| Hierarchy based on regions or subsidiaries | Subsidiary, holding group, and regional folders such as APAC, EMEA, and Americas | Regions or subsidiaries operate independently with different processes, offerings, and regulatory standards |
| Hierarchy based on accountability framework | Product or module folders such as ecommerce, logistics and warehousing, and reconciliation and billing | Product owners own the full lifecycle independently and workloads share few common policies |
Per-environment folders remain useful even when projects provide isolation because low-risk policies can still apply to all production clusters regardless of project. Smaller organizations with looser service level objectives may simplify by keeping all per-environment clusters in a single project, in which case per-environment folders are unnecessary. Use standardized naming conventions throughout the hierarchy so projects, folders, and applications remain consistently identifiable as the design evolves.
Organization Policy Enforcement and Guardrails is the use of the Organization Policy Service to set central rules that control how Google Cloud resources can be configured. An organization policy is a set of restrictions called constraints that apply to a resource and to all descendants of that resource in the hierarchy. While Identity and Access Management (IAM) answers who can take an action, Organization Policy answers what can be done, such as where resources can be created or whether public Internet Protocol (IP) addresses are allowed. Resource Manager (opens in a new tab) provides the hierarchy of organization, folders, and projects that Organization Policy relies on to enforce those rules.
Resource Manager defines the scope of where resources live, and Organization Policy defines restrictions on how those resources can be configured. A policy attached at a higher level flows down to everything below it, so one rule can create a consistent guardrail across many projects at once. This separation lets architects manage structure in one place and manage compliance rules in another, while both work together through inheritance.
Where a policy attaches in the hierarchy determines which resources must follow it. An organization policy can be enforced at the organization, folder, or project level, and the organization policy administrator controls those policies. The attachment point becomes the enforcement boundary for that guardrail.
Attach broad compliance rules at the organization for full coverage, attach department or environment rules at the folder to cover a group of projects at once, and attach narrow rules at the project for a single workload. Moving a project into a different folder or organization changes which parent policies it inherits.
Policy inheritance is the default behavior where descendants automatically inherit the organization policies enforced on their ancestors. If a policy is enforced on a folder, Google Cloud enforces the policy on all projects in that folder and on the resources inside those projects. Inheritance flows from the organization to folders to projects to resources, so a single organization-level constraint can maintain consistent compliance across all sub-resources.
A policy defined at a lower level can supersede a policy inherited from above, which allows controlled exceptions. Architects use this pattern to set a guideline for the whole organization or for a large folder, such as a production environment, while still allowing a specific folder or project to be stricter or to allow a justified exception. Because inheritance follows the hierarchy, changing the hierarchy changes enforcement, and policy changes do not apply retroactively to resources that already exist.
Exam tip: IAM controls who can act, while Organization Policy controls what configuration is allowed — even an authorized user cannot create a configuration that a constraint blocks.
Common guardrails are built-in managed constraints that enforce security, data residency, and service-use rules without custom code. These constraints are applied at the organization or folder level to prevent risky configurations before resources are created. They are especially useful for centralized teams that must prove consistent controls for audits and regulations.
gcp.resourceLocations constraint limits creation and storage of data to approved regions to meet data residency and compliance needs.iam.allowedPolicyMemberDomains, limits IAM policies to principals from approved Cloud Identity or Google Workspace customer IDs to block external accounts.gcp.restrictServiceUsage constraint limits which Google Cloud services can be used, such as allowing only a small approved list in a production or highly sensitive folder.Choose an organization-level guardrail when the rule must hold everywhere, such as approved regions, and choose a folder-level guardrail when only a department, environment, or region needs the restriction. Production folders typically carry stricter constraints than development and testing folders, where teams need more flexibility.
Custom constraints (opens in a new tab) provide granular, customizable control over specific fields when built-in managed constraints are not precise enough. A custom constraint is created for a specific Google Cloud resource type and then used inside an organization policy at the organization, folder, or project level. Like managed constraints, custom constraints are inherited by descendants unless a lower-level policy changes the evaluation.
Custom constraints support governance patterns that depend on naming and structure. For example, a custom constraint on project creation can require that project IDs in a staging folder start with staging-, and a custom constraint on folders and projects can deny updates when the parent is a secure folder or organization. These rules help enforce naming standards and protect secure branches of the hierarchy from accidental mutation.
Hierarchical Structure and IAM Inheritance is the system where Google Cloud resources are organized from broad to specific and access granted above automatically flows below. The Organization resource sits at the top as the root, folders group related work in the middle, and projects hold actual service resources at the bottom. This parent-child chain provides central visibility while letting administrators attach access and configuration policies once and have them apply to everything underneath.
Google Cloud resources are organized like a file system where every resource except the top has exactly one parent. Resource Manager (opens in a new tab) manages this hierarchy and controls how resources are grouped and where policies are inherited from.
A tree diagram of the Google Cloud resource hierarchy: an organization node at the root contains folders, folders contain projects, and projects contain service resources such as VMs and storage buckets. Policies and IAM roles granted at any level flow down and are inherited by all descendants.
Ownership binds the lifecycle of a resource to its immediate parent. Projects belong to the organization rather than to the employee who created them, so projects remain active and secure when employees leave and rogue or shadow projects can be centrally viewed and managed.
The Organization resource is the apex parent to all folder and project resources and the central point for inheritance. Access control policies and organization policies applied at the Organization resource are inherited by every descendant folder, project, and service resource. A Google Workspace or Cloud Identity account is required to use an Organization resource, and new projects created by managed users must belong to an organization by default.
Granting a role at the organization level avoids repeating the same grant on every project. For example, granting the Network Admin role to the networking team at the organization level lets that team manage all networks in all projects, instead of granting the role project by project. The initial allow policy for a new organization grants the Project Creator and Billing Account Creator roles to the entire domain, and the effective policy for any resource results from policies applied directly to it plus policies inherited from its ancestors.
The Folder resource (opens in a new tab) is an optional layer that functions as a sub-organization for delegation and isolation between projects. Folders can contain projects, other folders, or a combination of both, which lets a first-level folder represent a department, with subfolders for teams and then applications. Folders require an Organization resource, and folder display names must be unique within the same level of the hierarchy.
Folder structure has firm limits that shape enterprise design. Folders can be nested up to 10 levels deep, and a parent folder can contain up to 300 direct child folders, which can each contain additional folders or projects to scale beyond 300 tenants. Like organizations and projects, folders act as inheritance points for allow, deny, and organization policies, so IAM roles granted on a folder are inherited by all folders and projects inside it. For example, if a user is granted Compute Instance Admin on a folder, that user has that role for all projects in that folder.
The Project resource is the required container for using Google Cloud services, managing APIs, enabling billing, and adding collaborators. Organization and folder resources can contain multiple projects, and projects are the primary method for segregating resources such as production versus staging or one team versus another. Separating clusters or workloads into different projects improves workload security by default, limits the blast radius of a misconfiguration or compromised workload, and isolates resource quotas so one autoscaled workload does not exhaust an entire environment.
Each project has a unique project ID, an automatically assigned read-only project number, a mutable display name, a lifecycle state such as ACTIVE or DELETE_REQUESTED, and labels for filtering. Moving a project changes what it inherits, because the allow and deny policy hierarchy follows the resource hierarchy. For example, moving a project into an Organization resource updates its policies to inherit from that organization, and moving it between folders changes which folder policies apply.
IAM inheritance is the rule that allow policies flow down the hierarchy and combine, while deny rules can override them. The IAM model has four core concepts: a principal who can act, a role that is a collection of permissions, a permission that allows a specific operation, and an IAM allow policy that binds principals to a role on a resource. Principals include Google Accounts for users, service accounts for workloads, Google Groups, and Google Workspace or Cloud Identity accounts, and a principal cannot perform any action that is not permitted.
Allow policies set on organizations, folders, and projects are inherited by descendants, and lower-level allow grants are additive to what was inherited from above. Organization policies are also inherited but can be superseded by a policy defined at a lower level to allow exceptions. Deny policies can be set at the organization, folder, and project levels, are evaluated before allow policies, and can supersede allow policies to restrict permissions even when an allow exists below.
Exam tip: Allow policies add together down the hierarchy, but a deny policy applied above wins and is checked before any allow.
Designing for least privilege means granting broad access high in the hierarchy only for central needs and granting narrow access lower where work actually happens. Central teams receive organization or top-folder roles for consistent enforcement, while department heads, network teams, or cluster teams receive Folder Admin or specialized roles scoped to their own folders so users in one department can only access resources within that folder. Using Google Groups for these assignments makes it efficient to add or remove users without editing every policy, and per-environment folders let low-risk policies or aggregated log sinks apply to all production projects at once.
Best practice is to use a single organization node to avoid management overhead, except when testing major IAM changes, running a sandbox without the same organization policies, or separating sub-companies that may be sold off. Keep bootstrap resources for infrastructure-as-code and shared services such as monitoring in separate folders directly below the organization when they are common across environments. Place shared services lower, below application or environment folders, when each environment needs its own instance such as separate production and non-production secrets projects with different allow policies.
Identity and Access Management (IAM) controls who can take an action, while Organization Policy controls what configuration is allowed through constraints that apply to a resource and to all descendants of that resource in the hierarchy. Even an authorized user cannot create a configuration that a constraint blocks, and organization policy changes do not apply retroactively to resources that already exist.
Use projects as the base-level containers where every resource belongs to exactly one project to isolate production from staging and development, isolate teams from each other, and isolate billing responsibility because billing is assigned at the project level. Use folders as optional grouping mechanisms to organize projects by department, team, environment, or region so policies set on a folder cascade to all child folders and projects for delegated administration.
Allow policies set on organizations, folders, and projects are inherited by descendants and lower-level allow grants are additive to what was inherited from above. Deny policies can be set at the organization, folder, and project levels, are evaluated before allow policies, and can override an allow to restrict permissions even when an allow exists below.
Use a single organization node whenever possible to avoid management overhead and to provide central visibility and control over every project, folder, and service resource. Consider multiple organization nodes only to test major changes to Identity and Access Management (IAM) levels or resource hierarchy, to experiment in a sandbox environment without the same organization policies, or when sub-companies are likely to be sold off or run as completely separate entities.
An enterprise organization with multiple distinct business units is designing its Google Cloud landing zone. The organization must meet the following requirements:
Which resource hierarchy and networking design strategy should you implement?
Create an App Hub host project for each business unit to discover resources, and assign Cloud Armor security policies at the project level to isolate development from production traffic.
Create a single project per business unit containing multiple VPC networks for each environment, and use VPC Network Peering to connect all environment VPCs back to an on-premises transit hub.
Deploy all business units into a single flat organization-level Shared VPC host project and assign Compute Network Admin roles to business unit leads in that host project.
Organize the resource hierarchy with top-level folders for each business unit containing subfolders for each lifecycle environment, place workload projects within these subfolders, and deploy a dedicated Shared VPC network for each environment.
Last updated