Change authorization and approval

Auditors test whether every change to a financially significant system was requested, approved by the business and IT, and traceable to production. This page explains what passes and what it costs to meet.

On this page

Change authorization and approval under SOX ITGC: what auditors need to see

If you are preparing for a SOX 404 audit, the question auditors will ask about change authorization is simple: for each change that reached production in an in-scope application, interface, database or infrastructure component, can you show a documented request and approval from both the business and IT before the change went live? The control is only as strong as its traceability. Auditors select a sample of changes from the period under review, then trace each one from the production deployment back to a request, to the approvals recorded before deployment, and to the change that was actually deployed. Management owns this control and its evidence. An implementation partner or consultant can help design the workflow and assemble evidence, but only the external auditor tests and opines on it.

The risk behind the control is named in PCAOB AS 2110, which lists unauthorized changes to systems or programs as an IT risk to internal control over financial reporting. The stakes are higher than they look because of AS 2201. Under that standard, effective general controls over program changes are a condition for relying on a benchmark of an automated application control rather than retesting it every year. If the change control fails, the auditor may have to retest the automated controls that depend on the changed logic, which increases testing and can turn an ITGC deficiency into a wider issue. Before the audit, confirm with your external auditor how they plan to rely on automated controls for each in-scope system, since that determines how much change evidence they need.

Three patterns make this control hard to pass. The first is changes that bypass the ticket entirely, often a database script or a configuration edit made directly in production. The second is approvals recorded after deployment, which auditors treat as no approval at all for the sample. The third is an approval that does not match what shipped, such as a ticket approved for one release that was combined with unrelated fixes. To address these, check whether your change tool records approval timestamps automatically, whether the approved scope is tied to specific build or release identifiers, and whether production access is limited so that changes cannot land without a ticket. Open-source tools such as GLPI, which provides ITIL-based change management, can hold the request and approval record, but you should confirm that the approval workflow can enforce these steps in your environment.

Which changes and systems fall inside SOX change authorization scope

Scope starts with the top-down risk assessment, which identifies the applications, data and infrastructure that affect financial reporting. Each component below changes how many changes need approval and what evidence the auditor will request, so decide them explicitly and document the reasoning.

In-scope applications and key reports

Start with the financially significant applications that produce or process figures in the financial statements, such as general ledger, subledgers, consolidation and close tools. Include the key reports and spreadsheets generated from them that management relies on. Every change to these applications, including vendor patches and version upgrades, falls inside authorization scope, so the volume of approvals is driven largely by how many applications are named. Auditors will ask for the change request, the approval record and the release record for a sample of changes. Confirm the scope list against the risk assessment each year.

Interfaces that move financial data

Interfaces carry transactions between systems, such as payroll feeds, payment files, bank connections and intercompany transfers. A change to a field mapping, file format or schedule can silently alter balances even when the source and target applications are unchanged. Decide whether each interface is in scope based on whether it affects completeness and accuracy of financial data. Auditors commonly ask for the approved interface specification, the change ticket and evidence that the change was tested against live-format data.

Databases and tables holding financial records

Direct changes to databases, including schema updates, stored procedures and data corrections run by scripts, can alter financial records without passing through the application. Scope the database platforms that host in-scope applications and the tables that store balances, journal entries and master data. Scripted or manual data fixes are a frequent gap, so each one needs a request, an approver and a record of what changed. Expect auditors to compare database change logs with approved tickets.

Operating systems and network devices

Infrastructure such as operating systems, middleware, firewalls and load balancers supports the in-scope applications. Changes here, including patches, kernel updates and rule changes, can disable controls or alter access paths even when the application code is untouched. Decide which platforms are in scope based on their role in supporting financial processing, and document the rationale. Auditors typically look for change records covering patches and privileged configuration changes on those platforms.

Configuration and parameter changes

Settings such as tolerance thresholds, tax rates, approval limits, account mappings and calculation parameters can change reported results without any code change. Treat parameter tables that drive automated calculations, matching or approval workflows as in scope when they affect financial reporting. Changes to these items often bypass formal release processes, so they need their own request and approval path. Auditors will ask for the before and after values, the approver and evidence that the change was reviewed.

Third-party and cloud-hosted components

Vendor-managed SaaS applications, cloud platforms and managed services may apply changes on their own schedule. Management still needs to know which provider changes affect financial processing, how they are notified and whether the company approves them or relies on the provider's controls. Obtain the provider's change history, release notes and any independent report covering its controls, and confirm which items remain your responsibility. Ask the provider and your auditor what evidence will be accepted before the audit period begins.

How an assessor tests change authorization and approval

This table walks through the steps an external auditor typically takes to test change authorization under SOX ITGC, from understanding the process to confirming that the approved change is the one deployed. Read each row as a test step, the evidence it produces and the findings that most often appear when that step fails.

Test stepWhat the auditor doesEvidence requestedCommon findings
Understand the change processInterviews change managers, developers and application owners, and walks a change from request to production to confirm how the process actually works.Walkthrough notes, process narrative, a sample change followed end to end.Staff describe a process that differs from the written policy, or informal channels bypass the ticket system.
Inspect the written policy and approver listReads the change management policy and checks that it names who may approve each type of change and what authority each approver holds.Approved change policy, approval matrix, current approver list with role descriptions.Policy is outdated, approver list includes departed staff, or approval authority is not defined by change type.
Select a sample from the complete populationObtains the full population of in-scope changes for the period, confirms its completeness, and selects items using a documented method.System-generated change report with date range, record counts and report parameters.Population omits emergency or out-of-ticket changes, or the report is not checked for completeness.
Include changes found outside the ticket systemCompares production change evidence, such as deployment logs or file integrity records, against the ticket population to find changes that never had a request.Deployment logs, release records, reconciliation of production changes to tickets.Production changes exist with no matching ticket, which means the population was incomplete.
Trace each sampled change to request and approvalsFor each sampled change, inspects the request, the business approval and the IT approval, and confirms each is dated before deployment.Change ticket with request, business approval and IT approval timestamps, and deployment record.Approvals missing, dated after deployment, or recorded in a form the approver cannot be shown to have made.
Re-perform the authority checkCompares each approver against the approval matrix to confirm that the person held the authority required for that change type and risk level.Approval matrix in effect on the change date, approver role records.Approver lacked authority for the change type, or the matrix changed after the change was approved.
Confirm the approved change matches the deployed changeCompares the approved scope, version or build identifier with what was actually deployed to production.Approved change package, build or version identifiers, production deployment evidence.Deployed version differs from the approved version, or additional changes were bundled into the release.
Evaluate exceptions and retroactive approvalsIdentifies any approval given after deployment and assesses whether the control operated as designed for that change and whether it was reported as an exception.Exception log, emergency change records, follow-up approvals with dates.Retroactive approvals recorded as routine approvals, with no exception logged or assessed.

How to implement change authorization and approval step by step

This sequence takes an organization from an undefined change process to one where every change to a financially significant system has a documented request, an authorized approver and a traceable record that an auditor can sample. Each step produces a artifact that holds up when the external auditor selects changes to trace.

  1. Define the in-scope change population

    Start by listing the financially significant applications, interfaces, databases, operating environments and infrastructure that feed ICFR, using the scoping output from your SOX ITGC risk assessment. For each system, record who owns it, which environments count as production, and which configuration and infrastructure components can change its behavior. Done means you hold a signed system inventory that the change process explicitly covers, so no in-scope change can fall outside the population an auditor will sample from.

  2. Write the change policy

    Draft a change management policy that defines what counts as a change, what must be requested, which change types exist (standard, normal and emergency), and the minimum content of each request. The policy should state that no in-scope change reaches production without a documented business and IT approval, and it should name the owner who maintains the document. Management approves the policy in writing. The output is a signed, versioned policy that auditors can read alongside the evidence it governs.

  3. Configure a single system of record for change requests

    Select one ticketing or change system as the only place where changes are requested, approved and closed. Configure required fields such as description, business justification, affected systems, risk rating, test reference, requester, approver, implementation date and closure note, so that a request cannot be submitted incomplete. Open-source options such as GLPI, which includes ITIL-based change handling, can serve this purpose, but confirm with the vendor that the workflow, field validation and audit history meet your design. The output is a configured workflow with mandatory fields and a retained history of status changes.

  4. Define the approval authority matrix

    Document who may approve each change type and risk level, using job roles rather than names where possible. Set the rule that requesters cannot approve their own changes, and that approvers must hold business authority over the affected process and technical authority over the affected system. In most designs, no one approves a change they themselves built or deployed. Ask your auditor to confirm the matrix is acceptable for your environment. The output is an approver matrix, reviewed and signed by the control owner, with a list of current approvers and their delegations.

  5. Enforce the approval gate in the deployment path

    Make approval a technical prerequisite rather than a procedural hope. For source code and configuration held in version control, use protected branches to restrict which roles can push or merge, block direct pushes to production branches, and keep force pushes disabled unless explicitly allowed, as GitLab Community Edition supports. For infrastructure and application deployments, link each deployment job to an approved change identifier so that unapproved builds do not run. Confirm with your platform team which deployment tools can enforce this in your environment. The output is a documented configuration showing that the deployment path cannot proceed without a recorded approval.

  6. Run a population completeness check

    Before the auditor selects a sample, reconcile the change population to the source. Extract all production changes for the period from the deployment records, configuration logs and system change history, then match each one to an approved ticket. Investigate every mismatch, because an unmatched change is either an unauthorized change or a recording gap, and both need to be resolved and documented. Auditors rely on the completeness of the population before they sample, so this check should produce a completeness report that states the source queries, the record counts and the reconciliation results.

  7. Train requesters and approvers and retain the authority matrix

    Brief requesters on what a complete request contains and approvers on what they are attesting to when they approve, including the check that the test evidence exists and the change matches the request. Record attendance and keep the training materials under version control. Retain the approver matrix, delegation records and any changes to them, so the auditor can confirm that the person who approved a sampled change held authority at the time. The output is training records, a retained authority matrix history and a short attestation from each approver group that they understand their role.

Open-source tools that produce change approval evidence

Four open-source tools can each produce part of the change approval trail auditors sample: request intake, the approval record, segregation at the code repository, and review evidence. None of them makes an approval effective by itself, so the control design and the approval rules still come from the organization.

GLPI change records

GLPI's Assistance module, licensed under GPL-3.0-or-later, lets teams create and follow tickets, problems and changes using ITIL-style practices, with plannings, statistics and a Kanban view. Change records can serve as the approval system of record if you configure required fields for the requester, the business owner's approval, the IT approver, the test evidence reference and the implementation date. Confirm that the approval fields cannot be edited after approval without an audit trail.

Zammad request intake

Zammad, licensed under AGPL-3.0-only, is a web-based helpdesk that brings requests from email, chat, telephone and social media into one ticket system. It fits change request intake well, giving you a dated record of who asked for a change and what was described. It may need configuration, such as dedicated states and approval workflows, before it can act as a change approval record, so confirm that fit before relying on it for sampling.

GitLab protected branches

GitLab Community Edition, licensed under MIT, supports protected branches that restrict which roles can push or merge. Setting push access to no one blocks direct pushes to production branches, and keeping force pushes disabled preserves the commit history an auditor inspects. Together these settings separate the people who request and approve a change from the people who merge and deploy it. Verify that the settings apply to the branches that feed financially significant systems.

Semgrep review evidence

Semgrep Community Edition, licensed under LGPL-2.1-only, scans code in languages including Java, Python, Go, JavaScript and Terraform, and can run in CI/CD to scan repositories continuously. Scan results attached to a change show that a defined review step ran before merge, which supports the approval record. A passing scan does not replace management's approval, and the scan rules and any suppressed findings should be documented and approved.

Which evidence passes a change approval test

What change policy and approver matrix do auditors expect to see?

Auditors expect a signed change management policy and an approver authority matrix that names who may approve which types of change, for which applications and environments. The matrix should show business owners approving changes that affect financial logic or reporting, and IT approvers approving technical risk. Auditors check that the approvers named in the matrix were in role during the audit period and that the signatures and version dates are recorded. Keep the policy under version control, review it at least annually, and retain each approved version. Between audits, confirm that the matrix matches current staff and access roles, because an approver who has left or changed duties is a common finding. Ask your team to confirm the review cadence in your own change policy, since no external standard fixes it.

What must a change ticket show to pass a sample test?

A change ticket passes when it shows the request, a business approval, an IT approval and timestamps that place each step before deployment. Auditors trace a sampled change from the deployment back to the ticket and check that the description states what changed, why and which system was affected. The business approval should come from someone authorized in the matrix, and the IT approval should occur before the change reaches production. Ticket fields that are editable after approval, or approvals recorded in a comment without a named approver, weaken the evidence. Tools such as GLPI, which follows ITIL-based change practices, or Zammad, a ticketing system, can hold this record, but your team should confirm how each tool logs approval history and whether that history can be altered.

How do auditors link a ticket to the deployment record?

Auditors look for a traceable link between the approved ticket and the deployment that put the change into production. The usual link is a change identifier carried in the commit message, merge request, pipeline run or release record, so the reviewer can follow one identifier from approval to deployment. Auditors then check that the deployed code or configuration matches the approved change and that no additional changes were included. If the link is manual, such as a spreadsheet cross-reference, expect more sampling and more questions. Keep deployment logs with timestamps and the identity of the person or service account that executed them. Confirm with your engineering leads that every production deployment path, including scripts run by operators, writes to the same record.

Which branch protection settings and exports prove deployment gates work?

Auditors want configuration evidence showing that only approved roles can push or merge to production branches and that direct pushes are blocked. In GitLab Community Edition, protected branches let maintainers restrict which roles can push or merge, block direct pushes by setting push access to no one, and keep force pushes disabled unless explicitly allowed. Export or capture these settings, and retain dated copies, because the auditor tests the configuration as it existed during the period, not as it stands today. Monthly exports of the protected branch settings, deployment environment approval rules and runner permissions help show the control operated throughout the year. Semgrep Community Edition can run in CI/CD pipelines to scan code, which supports review but is not itself an approval gate, so describe its role accurately. Confirm the exact settings your platform version supports before relying on them.

What is a population report, and why does the auditor ask for one?

A population report lists every change to in-scope applications, interfaces, databases and infrastructure over the audit period. The auditor needs it to select a sample and to confirm the sample is complete, because a sample drawn from an incomplete list proves little. The report should be generated from the system of record, such as the ticketing or deployment system, and carry a date, filter criteria and a count. Auditors often re-perform the filter to check completeness, so document the query logic. Before each sample request, reconcile the population against deployment logs to catch changes that bypassed the ticket process. Ask your auditor to confirm the population parameters early, since disputes over completeness are costly late in the cycle.

How should emergency and out-of-process changes be recorded?

Emergency and out-of-process changes must be recorded as exceptions, with the reason, the approver, the access used and the time of the fix. Auditors check that the exception was logged promptly, that someone with authority approved it either before or immediately after deployment, and that a retrospective review followed. Each exception should link to a ticket and to the deployment record, and the population report should flag it so it can be sampled separately. Keep a register of all exceptions for the period, even when the count is low, because an absent register invites the question of whether emergency access was used silently. Coordinate this with your emergency change procedure and confirm the review timing your own policy sets.

What does a periodic reconciliation review need to show?

A periodic review shows that someone independent of the change process compared production deployments with approved tickets and resolved any differences. The review should list the deployments in the period, match each to an approved change, and record each unmatched item with its investigation and outcome. Auditors look for evidence that the reviewer had enough access to see production activity, that the review occurred at a set frequency and that the reviewer signed and dated the result. Many teams run this monthly and retain the reconciliation worksheet with the source extracts. Your team should confirm which reviewer role fits its segregation of duties and whether the review can be performed by a person who did not approve the changes being reviewed.

What change authorization and approval costs to meet

This table breaks down the cost components of running change authorization for in-scope systems, separating one-time setup from recurring upkeep and showing who is paid for each. Read it to see where spend comes from and which levers reduce it. No figures are given here, so use the quote checklist in the final row to compare proposals on equal terms.

Cost componentOne-time or recurringWhat drives it upHow to keep it down
Ticketing or change management tooling licensesRecurring (commercial) or none (open source license)Number of named users, approver roles and integrations with source control and CMDBEvaluate self-hosted GLPI or GitLab Community Edition to remove license fees, then budget for hosting and support staff
Engineering time to configure approval workflows and deployment gatesOne-time, with periodic reworkNumber of change types, separate approval paths for applications, databases and infrastructure, and manual stepsLimit workflow templates to a few standard change categories and build gates into the existing pipeline
Policy and change authority matrix draftingOne-time, with annual reviewNumber of business units, systems and delegated approvers, and the depth of segregation-of-duties rulesDraft one matrix per financially significant system family and reuse the same approver definitions across them
Training for requesters and approversRecurring, mainly at onboarding and role changeStaff turnover, number of approvers and spread across time zones or business unitsUse short role-based guides and record completion within the ticketing tool
Evidence upkeep, including population reports and periodic reconciliationsRecurring, every period end and before fieldworkChange volume, number of systems in scope and reliance on manual spreadsheetsGenerate population reports from the ticketing and source control systems and reconcile them on a fixed schedule
External implementation support under a fixed-scope written agreementOne-time for build, optional recurring for support or retainerNumber of systems, integrations, custom workflows and the time needed for knowledge transferAgree scope, deliverables and exclusions in writing before work starts and keep the handover plan in the same document
Auditor sampling and testing effortRecurring, each audit cycleNumber of in-scope changes sampled, number of exceptions and the need for re-performanceKeep approvals complete and timestamped before deployment so samples trace cleanly without follow-up requests
Management time to review exceptions and respond to auditor questionsRecurring, during audit fieldworkNumber of unapproved or late changes and missing approval evidenceReview the population for gaps each period rather than at year end

Who owns change approval, who can help, and what the auditor may do

Management owns change authorization. Your organization must write the change management policy, decide which systems and changes are in scope, and define who has authority to approve what. Business owners approve that a change meets their requirements and that the financial impact is understood, while IT approves the technical risk and the deployment plan. Auditors will ask whether these people had the authority and the information to approve, so the approvals must be made by named individuals who are accountable for the outcome.

  • Policy ownership: A written policy sets which changes need a request, which need business approval, and which need both, and it is reviewed on a set schedule.
  • Approver authority matrix: A matrix maps each in-scope application, interface, database and infrastructure component to the approvers who may authorize changes to it, including backups for absences.
  • Business and IT approvals: Each change ticket records the business and technical approval before work reaches production, with dates and the approver's identity.
  • Evidence retention: Management keeps the request, approval and related records in a system that cannot be silently edited, so a sample can be traced later.
  • Periodic review: Management reviews the approver matrix when roles change and checks that approvals were given by people with the right authority.

Confirm with your auditor which changes they consider in scope and how they expect the approver matrix to be documented before you finalize it.

Where change approval controls usually fail and how to close each gap

Change approval controls rarely fail in the approval step itself. They fail at the edges: people who can bypass the gate, approvals that arrive too late or describe the wrong version, changes that never reach the ticket system, and exceptions nobody reviews. Each card below names one gap and a fix that an auditor can test.

Direct production access bypasses the ticket

When engineers or administrators can write to production directly, a change can reach a financial system without any request or approval. The fix is to restrict production write access to the deployment pipeline or a small set of named service accounts, and to block direct pushes to the branches that feed production. Check who holds production credentials and whether that list matches the people who are allowed to deploy.

Approvals recorded after deployment

An approval dated after the change went live shows that someone signed off on a fact, not a gate. Auditors compare the approval timestamp with the deployment timestamp, so the sequence has to be enforced by the workflow rather than by good intentions. Require the approval state to exist before the pipeline or change record allows deployment, and make the record immutable once the change is closed.

Approved version differs from deployed version

A ticket may approve build 1.4.2 while production runs a build that was rebuilt, patched or cherry-picked afterward. The approval then covers something that was never deployed. Tie the approval to a specific commit hash or artifact identifier, and confirm that the deployed artifact matches the one in the ticket. Ask for a sample where you compare the approved identifier with what is running in production.

Changes arriving outside the system of record

Requests made by email, chat, phone or direct database edits never appear in the change population, so no one tests whether they were approved. The population the auditor samples is only as complete as the intake channels feeding it. Route every request into one ticketing queue, and run a periodic reconciliation that compares production change logs, deployment records and database audit trails against approved tickets.

Approvers without authority or independence

An approval means little if the approver lacks authority over the system or is the developer who wrote the change. Define approver roles by application and change type, and require business ownership plus IT sign-off where both apply. Block self-approval in the tool, and keep the approver list under review so it reflects current roles and leavers.

Exceptions never tracked or reviewed

Emergency fixes and out-of-process changes are often logged informally, then never revisited. Auditors look for each exception, its approval after the fact and evidence of review. Create a distinct exception category in the change system, require retrospective approval within a defined window set by your own policy, and have a manager review the list on a fixed schedule with the review retained as evidence.

Common questions about SOX change authorization and approval

How much effort does change authorization take to set up and run?

Setup is mostly a one-time design effort, and running it is a recurring workload that scales with the number of changes. The setup work covers defining which applications, interfaces, databases and infrastructure are in SOX scope, writing a change procedure that names who requests, who approves and what the approval must contain, and configuring a ticket system to enforce that path. The recurring work is the daily handling of requests, approvals and evidence retention. Effort rises with the number of in-scope systems, the volume of changes, the number of approvers involved and how many systems still rely on manual approvals. Ask any provider to break the quote into design, configuration, evidence procedures and ongoing support so you can see which parts recur.

Can our team set up change authorization without outside help?

Often yes, if the team has someone who understands both the financial systems and the change process, and the organization is willing to own the design. The organization owns its controls. Outside help is usually most useful for preparing the ticket workflow, mapping in-scope systems, drafting procedures that match how the business actually approves work, and organizing evidence so it is easy to sample. An implementation partner prepares systems and evidence, but only the independent external auditor tests the control and reaches a conclusion. Ask any firm to state in writing which tasks it will perform, which remain with your staff and what documentation you will own at the end.

How long does this work take, and what makes it take longer?

The timeline depends less on the approval tooling than on how many systems are in scope and how well existing approval practices are documented. Work usually runs longer when approval rules are informal, when several business units approve changes differently, when interfaces and databases are not inventoried, or when the ticket system must be integrated with source control or deployment tools. Each of those adds discovery, decision-making and testing time before the control can run reliably. Before you agree on a schedule, ask the provider to state the assumptions behind it, including the number of systems, the approval owners involved and whether the controls must operate for a full period before the audit.

What do business and IT staff need to contribute?

Business owners need to confirm which changes affect financial results, define who can approve them and state what evidence they need before approving. IT staff need to document the change request, the technical impact, the test results and the deployment record. Both groups need to agree that approvals must happen before deployment, not after. The time commitment is largest during design, when owners review the in-scope list and approval matrix, and smaller during operation, when approvers respond to requests. Confirm with the provider who will act as the business approver, who will sign off on the design and how often those people are expected to attend working sessions.

Must emergency changes follow the same approval path?

Emergency changes should follow a defined path, but that path does not have to be identical to the standard one. The usual approach restricts who can make an emergency change, requires an approval from a named owner, usually obtained before the change where practical, and requires a documented review after the fact. The auditor will want to see that the emergency route cannot be used to skip approval entirely. Emergency handling is a sibling topic with its own control design, so ask any provider how it will connect emergency changes to the same ticketing record and whether the review process is written into the procedure.

Is a self-hosted open-source ticket system acceptable evidence?

A self-hosted ticket system can produce acceptable evidence if it records requests, approvals, timestamps and linked changes in a way the auditor can inspect and the organization can protect. GLPI's Assistance module, for example, supports tickets, problems and changes following ITIL practices, with plannings, statistics and a Kanban view, and Zammad is a web-based helpdesk that consolidates requests into one ticket system. Source control can add a second layer. GitLab Community Edition supports protected branches that restrict who can push or merge, block direct pushes and keep force pushes disabled unless explicitly allowed. The tool is not the control. You must confirm that approvals are enforced in the workflow, that records cannot be silently edited and that access to the system is itself controlled. Verify each capability against the version you deploy.

What does the external auditor need from management for this control?

The external auditor needs management to show that the control is designed effectively and operates consistently throughout the period. Under PCAOB AS 2201, operating effectiveness testing combines inquiry of personnel, observation of operations, inspection of documentation and re-performance of the control. In practice, that means a documented change procedure, a complete population of in-scope changes, a ticket for each change showing the request, the approval and the approval date before deployment, and a way to trace those tickets to production. Management should also be ready to explain how the population was generated. Ask providers whether they will prepare evidence packs for sampling and how they will handle changes that bypassed the workflow.

How DeployOpen works on this

DeployOpen plans and implements the self-hosted open-source tools that carry change requests, approvals and repository controls for in-scope systems, inside your own infrastructure. We prepare the workflow and the evidence trail, while your organization keeps ownership of the control, the approvers and the decisions.

How we scope

  • Agree in writing which applications, interfaces, databases and infrastructure components fall under the change approval workflow.
  • Confirm which change types require business and IT approval, and which teams hold each approval role.
  • Document the change request fields, approval thresholds and retention period that the written scope covers.

How we build

  • Configure the ticketing workflow so each change request records the requester, description, risk, approvers and approval timestamps.
  • Set repository and branch restrictions so changes can only reach protected branches through an approved merge path.
  • Connect change requests to code commits and deployment records so an auditor can trace a sampled change end to end.

How we hand over

  • Deliver a written procedure describing the approval steps, roles, exceptions and how evidence is retained.
  • Provide sample change records and an evidence index that maps each approval step to where the artifact is stored.
  • Walk your control owners and internal audit through the workflow so they can run and explain it without us.

How we support

  • Offer ongoing support and upgrades for the platforms as a retainer, scoped in writing separately from the initial engagement.
  • Review workflow changes and access to approval roles on a schedule you agree, so the control keeps matching its documentation.
  • Coordinate with your external auditor on evidence requests. DeployOpen prepares evidence but does not issue audit opinions or attestations.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.