Choose the route through the guide
Use one representative application as the thread through the assessment. Select a real service or application whose owners can identify its normal source, pipeline, artifact and deployment path. The Foundation, Authorize and Verify work applies to that selected workflow: record its owners and actual delivery path, inspect the identities and credentials that carry out the work, then configure and observe the relevant scanner profiles, application tests and DAP reviews on ordinary changes.
The worked permission and runtime exercises deliberately use separate private practice projects. They let you make temporary branches, test a denial, register a runner and run local containers without changing the selected application's production path. Carry their result back to the selected workflow as a concrete implementation question:
| Work in this guide | Where it runs | Result to carry forward |
|---|---|---|
| Policy ownership and access checks | practice-application and security-policy |
The effective application and policy identities, plus the permitted and prohibited repository actions. |
| Local isolated task | A trusted local Docker host | The task image, mounts, privileges, network routes and resource limits the service owner would need to reproduce for the real task. |
| Dedicated runner | Its own private runner project | The observed runner configuration and job result, followed by a decision about whether the selected application's actual jobs and DAP flows are eligible only for that trusted runner. |
| Scanner profiles, application-test alignment and DAP review | The selected application | The exact source revision, jobs, reports, review output, exclusions and remaining admission gaps. |
| Release and connected response | A separate private release project and local Docker runtime | The approved artifact identity, release decision and recovery record. Connect these to the selected application's production release path only after its release and response owners implement the corresponding controls there. |
Completing the exercises doesn't establish an earned-autonomy level for the selected workflow. The service owner still needs to show that every prerequisite for the chosen level holds on the actual authoring, verification, runner, release and response paths. These procedures don't connect the Verify results to a gate that an untrusted application Maintainer can't bypass. Keep that requirement open when recording the workflow's supported authority.
Before you begin
The examples use GitLab.com Ultimate and three separate identities: a trusted group Owner, an application Maintainer and an independent reviewer. The Owner creates the namespace and manages access. Use the application identity when checking what an application author can do; an Owner session has broader permissions and would give a misleading result. Release and connected response add a service-account release operator; the same service-account identity receives a fresh token for recovery after the affected token is revoked. A standalone release can instead use an authorized human deployer and ends with the release chapter's rollback and cleanup.
For the command-line procedures, start by getting the example files and setting the absolute GSS_GUIDE_CHECKOUT path. Keep that variable when moving between project clones so commands continue to address the intended guide assets. Before creating resources, prepare the tools and credentials for the procedures you plan to follow:
- For the command-line procedures: Bash,
glab,jq, Git,curl, Python 3,sha256sumorshasum, and a trusted credential store. If you download a source archive instead of cloning the guide repository, use a matching extraction tool such asunzip. The release and response tools require Python 3.12 or later and OpenSSL 3, available aspython3andopenssl. - Separate authenticated GitLab sessions for the Owner, application Maintainer and independent reviewer, plus the service-account credential used by the release and connected-response walkthrough. Confirm the effective user before each set of consequential requests.
- For the local task, dedicated runner and release runtime: a trusted Linux ARM64 Docker environment. The local task and release commands use Docker Desktop's
desktop-linuxcontext. The dedicated runner has its own context selection and ARM64 Runner/helper images. The release build and job-token exercise use a GitLab-hosted Linux AMD64 runner with thesaas-linux-small-amd64tag; keep those image and runner requirements separate from the local runtime. - The exact pinned Python runtime used by the local isolated-task and release examples. Follow Prepare the Python runtime before either walkthrough; the repository contains the image reference and acquisition instructions rather than the image itself.
Keep two locations distinct throughout the guide: GSS_GUIDE_CHECKOUT is the guide and example asset root, while each authenticated application or release clone is a separate project checkout. Commands that change application source run from the intended project checkout. Commands that load example programs or drivers use absolute paths below GSS_GUIDE_CHECKOUT.
For scanner onboarding, choose a representative application with supported source files, dependency inputs and working CI/CD. Use an ordinary application change to check scanner activity. The permission and execution exercises use a private practice scope so their temporary branches, role checks and runtime changes don't interfere with a production workflow. Keep production credentials out of those exercises.
For an existing service, first identify its application project, default branch, policy project, runner, artifact registry and deployment environments. Record the settings you intend to change before changing them. Keep secrets in the credential store you already use; the record needs credential names, owners, scopes and expiry, not secret values.
Create the isolated project scope
Keep application code and policy administration in separate projects so their permissions can be managed independently. Create the following layout as the trusted group Owner:
- Open the intended parent group and select New subgroup. Create a private subgroup named
security-practice. Choose another unused name if it already exists. GitLab's subgroup instructions describe the creation and inheritance behavior. - Within it, create a private subgroup named
applicationsand a private blank project namedpractice-applicationin that subgroup. Initialize the project with a README. Use the blank-project creation flow and check the displayed namespace before creating it. - If you're also preparing policy ownership, create a separate private project directly under
security-practice. Use the display name Practice - security policy project and the project slugsecurity-policy. This places it outside theapplicationssubgroup. Initialize it with a README; policy configuration comes after ownership is established. - In each project's Manage > Members, inspect the Source of inherited and shared membership. Repeat at both subgroups and the parent group. A private subgroup still inherits access and other settings from its ancestors.
- Review inherited CI/CD variables, available runners and effective policies with their owners before running the sample. A new private project isn't automatically isolated from those resources. If the parent supplies production credentials or unsuitable execution access, choose an authorized namespace without those dependencies before continuing.
The resulting layout is:
<your-group>/security-practice/
├── security-policy/
└── applications/
└── practice-application/
Use names that fit your namespace and keep the resulting paths and project IDs handy for the commands below. Confirm that both subgroups and both projects are private, with the application project under applications. If an existing project already has a policy link, keep it in place while you review its purpose with the owner. Following this example layout is not a reason to replace it.
Assign and inspect the application role
Open practice-application and select Manage > Members > Invite members. Add the application test identity directly to that project with the Maintainer role. Add the independent reviewer as a Developer in this practice project so they can inspect the source and pipeline results. Review any separate restrictions on artifact access with the project owner. The project membership documentation explains how direct, inherited and shared grants combine.
Keep the application identity out of the governing groups and out of any role that can write to security-policy. If an existing ancestor membership grants more authority, changing the direct project role won't remove it. Resolve that grant with its owner or select a distinct test identity before treating a denial as meaningful.
Record the intended access and compare it with every membership source shown in GitLab:
| Identity | Application project | Policy project | Governing groups |
|---|---|---|---|
| Trusted namespace Owner | Setup and recovery | Policy administration | Owner |
| Application test identity | Direct Maintainer | No write access | No membership granting policy administration |
| Independent reviewer | Developer for source, job and artifact inspection | Only if separately authorized | No broader authority assumed |
In the application identity's session, open the application repository and make a harmless README change on a new branch. Confirm the commit and actor in the Owner session. This confirms that the application account can do ordinary work. The permission checks that follow must also show that it cannot change governing policy or make prohibited writes to the target.
Record the delivery path
With the projects and identities in place, trace a change through the service. Start with the result someone asked for, then identify the repositories, pipelines, artifacts, environments and external systems involved. Include the people who review, release and support the software.
Follow a recent instance of the work rather than relying only on intended architecture. Begin with the request and trace the actual path through source, build, verification, artifact storage, deployment, and operation. Include human, service, and agent identities. Record where work crosses into another project, group, runner environment, registry, cloud account, or third-party service. Those transitions often reveal authority that isn't visible in the application repository.
Then compare the path with the security information the team actually receives. Identify which scanners or other checks examine the change, when they run, what they cover, and where someone sees their results. A configured scanner doesn't establish coverage. A job can be skipped, scan the wrong artifact, or produce no usable report while the pipeline remains green. In the group, start at Secure > Security configuration > Scanners and inspect each project's profile and coverage. Check any existing CI/CD configuration or policy that also supplies scanning, then inspect the pipeline for the actual change. The security inventory supplies the group view; a configured profile and a completed scan answer different questions.
A small starting record is usually enough:
| Question | What to record |
|---|---|
| What work is being delegated? | The requested result, normal trigger, and consequential actions |
| What can the workflow reach? | Projects, files, tools, credentials, networks, registries, and environments |
| Who owns the outcome? | Service owner, workflow owner, security contact, and recovery authority |
| What protects the path today? | Reviews, scans, execution controls, release controls, and response procedures |
| What remains uncertain? | Missing owners, unobserved paths, unclear permissions, and incomplete records |
Give missing information an owner. If the team can't identify which artifact reached an environment, start with the available source and pipeline records and work with the release owner to connect them to the deployment. Resolve that missing connection before delegating release decisions to the workflow.
First address any gap that undermines a prerequisite for the workflow's current authority or prevents the team from stopping harm. Resolve those gaps before expanding what the workflow can do. Otherwise, begin with the action that could have the greatest impact. Agree who will make the change and how you'll check it: useful work should still succeed, and the action you meant to prevent should be refused. Use what you learn to choose the next improvement.
The Standard applies to each workflow according to its authority and impact. A code-writing workflow and a credential-response workflow can use the same security principles without using the same controls. Keep their assessments separate enough that success in one doesn't quietly justify more autonomy in the other.