Managed open-source responsibility matrix

Allocate application, identity, infrastructure and recovery duties with an editable RACI matrix and explicit handovers between service owners.

Last updated

In short

  • Assign one accountable owner for each decision, even when several teams perform the work.
  • Infrastructure operation and business acceptance are different responsibilities.
  • Agree boundaries for plugins, identity, incidents and exit before onboarding.
On this page (6)

Procurement and evaluation · Part of Shared responsibility

Illustrative RACI allocations across customer, operator, infrastructure supplier and upstream roles.

Download the responsibility matrix

Make ownership visible before an incident

Managed open-source software still has several owners: the business using it, the team controlling identity, the organization operating the application, the infrastructure supplier and the upstream project. A responsibility matrix turns that collection into an operating agreement. It should explain who performs work, who authorizes it and what evidence closes the task.

Use R for the people performing the work, A for the person accountable for its outcome, C for people consulted before a decision and I for people informed afterward. One accountable owner per row is a useful convention. Multiple responsible teams are possible, but their handover needs a sequence and a contact.

The downloadable CSV includes illustrative allocations, not default contractual promises. Replace roles with named teams and attach the relevant contract or procedure. Pilae’s shared-responsibility description and service agreement are reference points for a Pilae proposal; another operator may divide the work differently.

Split broad activities into decisions and execution

Broad label Separate rows that remove ambiguity Evidence of completion
Patching Assess release, approve window, apply change, validate workflow Approved change and application acceptance
Access Approve membership, synchronize account, revoke sessions, remove service tokens Identity audit and negative-access test
Backup Set retention, capture data, monitor failures, restore, accept business result Backup manifest and restore record
Incident Detect symptom, declare severity, contain, communicate, recover Timestamped incident record and owner decisions
Extension Select plugin, verify licence, review access, maintain compatibility Approved extension inventory
Exit Authorize export, deliver records, reconcile, revoke access, delete copies Signed handover and scheduled retention actions

“Operator owns backups” is incomplete when the customer decides which attachments must survive and the infrastructure supplier controls a storage snapshot. Give each dependency a row rather than hiding it under a single service label.

A practical identity handover

Consider a hypothetical organization using an external identity provider. The customer approves that an employee belongs to the finance group. Its identity team maintains the group. The application operator configures the mapping from that group to application permissions. The upstream vendor supplies the mapping capability but does not approve the employee’s access.

When the employee leaves, acceptance should include more than a successful identity synchronization. Check existing sessions, application API tokens, local emergency accounts, shared secrets and any automation the employee owned. Assign the residual checks to a named team. No matrix can enforce revocation if these paths are omitted.

Define the boundary around application changes

State whether custom code, marketplace extensions, integrations and user-written workflows are within the managed scope. A supplier may patch the base application while the customer remains responsible for an extension that changes its behavior. That is a legitimate arrangement if compatibility checks and escalation are clear.

Record supported versions and editions in the configuration inventory. A feature requiring a commercial subscription must have an owner for renewal and entitlement. Source availability does not remove licensing duties, and an open-source licence does not provide an upstream support commitment.

The change record should contain a recovery route: configuration backup, application/database restore point where needed, and the person authorized to stop rollout. A rollback may require restoring data as well as replacing an image. Ask the business owner to define how writes made during the change window will be handled.

Allocate incident and recovery decisions

Detection, response and restoration are different events. Identify who monitors the service, who can declare an incident, who can isolate it and who informs affected users. A shared messaging channel is helpful but should not be the only escalation route for a critical failure of that same channel.

A restore exercise should end with a business owner verifying a useful workflow. The operator may successfully start a database while an integration credential remains missing. NIST’s recovery guidance is a useful planning reference, but the objectives and acceptance criteria must come from your own dependencies.

Keep the matrix usable

Do a tabletop exercise before onboarding closes. Choose an expired identity certificate, a failed application upgrade and a mistaken deletion. Walk through who acts first, what access they need, who approves the next step and how the customer learns the outcome. Mark missing authority or unavailable credentials as unresolved work.

Review the matrix when a new app, region, contractor or identity system is introduced. Preserve previous versions so an incident review can determine which responsibilities were agreed at the time. The document should remain short enough for the people on call to use; detailed procedures can be linked from each row.

Bring the filled matrix to an operating-scope discussion with Pilae or another provider. Agree the remaining gaps explicitly, and use current pricing only after the scope, infrastructure and retained internal duties are understood.

Sources and further reading

Use the linked documentation to confirm the version, edition and contract that apply to your project.

Agree our operating scope

Agree who owns access, changes, incidents, recovery and the final handover for your applications.