OBLYTECH Logo
OBLYTECH Logo
ServiceNow Upgrade Readiness: Security and Access Design

ServiceNow Upgrade Readiness: Security and Access Design

Role Model for Upgrade and Release Management

Upgrade and release activities require careful role separation. Platform engineers who test upgrades in staging should not have production access. A separate release approval authority (platform manager or change advisory board) should authorize production deployments. Implementation teams should not have access to modify production configurations after their implementation is complete. This separation prevents unauthorized changes and ensures oversight of critical platform modifications.

Typical roles include: platform engineer (builds and tests in non-production), technical lead (reviews technical readiness), release manager (coordinates deployment window), change authority (approves production changes), and support staff (handles rollback if needed). Define these roles and ensure users are assigned correctly based on their responsibilities and skills.

Least Privilege for Pre-Release and Release Activities

Apply least privilege: grant only the minimum permissions needed. Platform engineers need access to staging and development environments but should not have production access until specifically authorized for a deployment. Restrict their production access to the specific change window and to the specific tables or modules being changed. A platform engineer implementing a change in the incident module should not have access to the change management module.

Release managers need to trigger deployments but should not modify code or configuration. They should execute deployment scripts and monitor progress, not edit the content being deployed. This prevents accidental or unauthorized changes during the release process.

Application owners need to validate that their application works after the upgrade but should not have access to modify upgrade packages. Create read-only application-specific dashboards so owners can verify their systems without having modification rights.

Segregation of Duties in Upgrade Workflows

Separate the roles of: code author (platform engineer develops the change), reviewer (technical peer reviews before deployment), approver (change authority approves the deployment), executor (release manager runs the deployment script), and validator (application owner verifies functionality post-deployment). Ideally, no single person should hold all these roles, as this creates conflict of interest and removes oversight.

In smaller organizations, some roles may be combined, but the principle of segregation should be maintained where possible. At minimum, the person who writes the change should not be the person who approves it for production. Code review by a technical peer catches mistakes and provides a check on quality.

Audit Evidence and Change Tracking

Confirm that auditing is turned on for the tables and records the upgrade changes, since the Audit table keeps history for audited records. Track: who authored each change, who reviewed it, who approved it, when deployment occurred, and what systems were affected. This audit trail records who changed each audited field and the old and new values, which gives evidence if issues occur post-deployment. On its own it does not show that the approval steps were followed.

Maintain deployment logs showing exactly what was changed during each release. If a production problem occurs after an upgrade, the deployment log helps identify what changes might have caused it. Archive deployment logs for as long as your reference and compliance requirements set.

Approval Workflows and Checklist

Design approval workflows that enforce segregation of duties. When a change package is created, the workflow should route to: technical reviewer (verify design quality), change authority (approve production deployment), and release manager (permission to execute). Each approval step should require explicit sign-off. Do not allow changes to bypass approval workflows.

Create pre-deployment checklists. Before production deployment, verify: test results are documented, rollback procedures are prepared, maintenance window is scheduled, change documentation is complete, and stakeholders are notified. A pre-deployment checklist catches missing preparation and reduces risk of problems during deployment.

Access Control for Staging and Production

Use role-based access control to enforce environment separation. Users should have access to staging environments for testing but restricted access to production, granted only during planned deployments. After the deployment window closes, revoke production access. This reduces the risk of unauthorized changes and accidental modifications in production.

For production deployment, grant just-in-time access: provide access only during the scheduled deployment window, for the specific change being deployed. If the deployment is scheduled for 2:00 AM to 4:00 AM, grant access at 1:50 AM and revoke at 4:10 AM. This limits exposure if credentials are compromised.

Monitoring and Validation After Release

Establish monitoring and validation procedures post-deployment. Application owners should verify their systems work correctly. Support teams should monitor incident rates and error logs for unusual activity. Define what metrics will be reviewed and who will review them. If performance degrades after an upgrade, you want to detect it within minutes, not hours.

Maintain rollback procedures and test them. If critical issues are discovered post-deployment and cannot be quickly resolved, can you rollback the change? Rollback procedures should be documented, tested, and approved in advance.

Compliance and External Audit

Upgrade and release processes are often audited in regulated industries. Auditors want to see evidence that changes were reviewed, approved, and tested before production deployment. Maintain documentation and audit trails meeting regulatory requirements. Include: change requests, approval chains, test results, and deployment logs in your compliance evidence.

Establish regular review cycles to verify that upgrade procedures are being followed. Quarterly reviews of deployment records should validate that approval workflows were executed, that access was appropriately controlled, and that changes are documented.

The clone is where the data risk starts

Upgrade rehearsal normally means copying production into a sub-production instance and running the new release against it. That copy is the most exposed object in the whole project. It holds live personal data, integration records, and configuration that reveals how the business works, and it usually sits in an environment where more people have access than production would ever allow. Before the first clone is requested, decide what the copy may contain, who may see it, and when it will be destroyed. Those three decisions belong to the security owner, not to the technical team that happens to run the clone.

Masking is a common answer for personal data. Replace names, contact details and identifiers with realistic but false values in the fields that testers do not need to see in full. Keep the structure and volume intact, because a test that passes on empty tables tells you little about production. The masking rules should be written down, reviewed by the data owner and applied before anyone outside the upgrade team logs in.

Environment Who holds administrator rights Data the copy may hold Exit condition
Rehearsal clone Named platform engineers, time-limited Masked personal data, live configuration Upgrade rehearsal signed off and the clone is refreshed or retired
Test instance for business validation Business testers in standard roles, no administrator rights Masked data with representative volumes User acceptance testing closed in the test log
Production cutover Operations and release staff, for the window only Live data, handled under production controls Access removed when the window closes and the stability review begins
Post-upgrade production Standing roles returned to their normal state Live data under normal controls Access review completed for the upgrade team

Temporary elevated access during the window

Cutover work often needs rights that nobody needs the rest of the year: rights to stop scheduled jobs, to run upgrade scripts, to change system properties and to read logs across modules. Grant those rights through a time-limited role, with the start and end dates set to the change window. The grant covers only the period between the start and end times on the time-limited role record, so a forgotten elevated role is avoided by setting the end date when the grant is approved. Time-limited roles are supported for a short list of platform roles, such as admin, and for assignments that end no more than five days after they start, so confirm the role you need is on that list. Keep the grant recorded against the change.

Use named individuals rather than shared administrator accounts. A shared account makes it impossible to say who ran a particular script, and it undermines the evidence that the upgrade followed its approved steps. If an automated process must run under a service identity during cutover, give that identity the narrowest scope that works and document it.

Integration credentials after the upgrade

Integration accounts are an access path that is often forgotten. An upgrade can change how credentials are stored, validated or passed to external systems, and a connection that worked in the clone may fail in production for reasons that look like a network fault. Inventory every integration user, its roles and its authentication method before the upgrade. After cutover, confirm each one still authenticates, and rotate any credential that was copied into a document, a ticket or a test script during the project.

  1. Confirm that the masking rules were applied before any tester logged in to the copy.
  2. List every administrator and elevated role needed for the window, with a named holder and a fixed end time.
  3. Record each integration user, its roles and its authentication method.
  4. Run a short credential check against each external system during the first hours after cutover.
  5. Remove the temporary roles at the end of the window and record the removal against the change.
  6. Run an access review of the upgrade team’s permissions within the stabilization period and close any gaps it finds.

What to do when access is not clean at the end

If a temporary role was not removed, treat it as a security event rather than a housekeeping item. Pull the logs for the period, check what the account did while it held the role, and decide with the security owner whether any other step is needed. Explaining the gap afterwards is far easier when the investigation has already been done and written down.

Questions about access during an upgrade

Can testers use a clone that still contains real customer records?

Only where the data owner has explicitly approved that use and the access is restricted to the people who need it. The default answer is no, and the masked copy is the working environment. Real records in a test environment widen the audit scope and make a breach more likely.

Should upgrade engineers keep their elevated access for the next release?

Not as a standing right. Re-grant it for each release under its own change record. Standing access for people who rotate between projects is a situation auditors often question.

How do we show an auditor that the upgrade access was controlled?

Keep the approved change, the list of elevated grants with their start and end times, the masking sign-off, the integration credential check and the access review. Those records together show control rather than assertion.

Does the same model apply to a minor patch?

The principle does, the paperwork can be lighter. A patch that touches no integration accounts and no personal data may need only the elevated grant and its removal. Decide that explicitly rather than assuming it.

Approvals for each step are easier to follow alongside the roles and decision rights page.

Security and access design for an upgrade also means testing the access model the upgrade changes

Securing who can run an upgrade is only half of the design. The other half is proving that what each user can see and do after the upgrade is the same as before, except where you chose to change it. Plan a dedicated access regression pass, separate from functional testing.

The reason is simple. An upgrade can bring new roles, new access rules and changed defaults, and it can flag customised records that now differ from the vendor version. Functional testers usually log in with a broad role, so a rule that quietly blocks a narrow role, or opens something it should not, passes unnoticed.

Build the persona list before the rehearsal

Pick one real user for each distinct access pattern: a requester with no special role, a fulfiller in each major module, a manager who approves, a report viewer, an integration account, and an administrator. Write down what each persona must be able to do and what each must be blocked from doing.

Run the pass in two directions

  • Positive checks: each persona completes its core tasks, such as raising a request, working a queue or approving a change.
  • Negative checks: each persona tries records, lists and reports it should not reach, and the result is a refusal, not an empty screen that hides a data leak elsewhere.

Impersonating a user can be quicker than logging in as them, but use it only under the same masked-data and logging rules as the rest of the rehearsal, and record who impersonated whom. Confirm that glide.sys.log_impersonation is set to true first, because when it is not set to true, user-impersonating events are not logged.

Compare before and after, then decide on each difference

Capture the results on the pre-upgrade clone and repeat them on the upgraded one. Every difference gets one of three outcomes: accept it as intended, fix the customisation, or raise it with the security owner. Typically the differences that matter involve skipped customised records, such as business rules and scripts, and scheduled or integration identities that depended on a role that has since changed.

Keep this record with the testing evidence. The sign-off steps belong in the upgrade testing and acceptance checklist, the wider role design sits in instance security and access control, and any access fixes that travel between instances should follow the process in update sets and release management.

Check the affected roles and rules on your own instance and release.

Break-glass access when a cutover fails and the planned roles are not enough

When a cutover step fails partway through and the fix needs a right that the time-limited role does not carry, the team needs a break-glass route agreed before the window opens. Break-glass access is a pre-approved, sealed path to elevated rights that nobody uses in normal work, and every use of it is reviewed afterwards. Ad hoc grants made mid-failure can leave behind administrators nobody can account for.

Decide three things in advance. The first is which named people hold the break-glass credential and which second person must agree before it is used. The second is where the credential is stored, so that retrieving it leaves a record. The third is what the reviewer checks afterwards: the stated reason, the actions taken and the time the access ended. Keep the break-glass identity separate from named administrator accounts so its activity is easy to isolate. Every use must fall inside the change window, so define that boundary first.

Situation during cutover Route Evidence afterwards
A planned step needs a right outside the change Amend the change record and re-grant the time-limited role Updated change record and grant log
A failed step blocks the cutover and no other route exists Break-glass credential, agreed by the release manager and a second approver Session log, stated reason, end time
Evidence of misuse or an access left open Handle as a security event, not as a change task Investigation record held by the security owner

The third row follows the same route as any other access event, set out in security incident response.

Test the break-glass path before the rehearsal, not during cutover. A credential that has never been used can fail because it expired, its password was reset, or a policy locked it. Run a dry sign-in on the clone and confirm the session appears in the logs the reviewer reads. Rotate the credential after the window whether or not it was used, so no copy survives in a runbook or a chat thread.

Keep the break-glass role narrow. It should reach only the tables, scripts and properties needed to stop or reverse the failed step, not every module the upgrade touches. A wide role usually means the rollback plan was not specific enough. Without a tested way back, work through the troubleshooting guide for update sets and release management and fix the rollback before the next release, not during it.

Frequently asked questions

Should patches and hot fixes follow the same approval process as planned upgrades?

Critical security patches should be expedited but still approved. Create an expedited approval workflow (minutes instead of days) for security fixes. Document the emergency approval in the change record. Regular feature updates should follow the standard multi-week process.

How long should we retain deployment logs and audit evidence?

Retain for the period your reference and compliance requirements set, longer if regulatory requirements apply. Deployment logs are valuable for troubleshooting issues that appear weeks or months after a change. Old logs help answer 'what changed on date X?' when investigating problems.

Can we automate deployment to production without manual approval?

Automated deployment pipelines improve speed but still require human approval gates. Automate testing and validation; require a human to authorize production deployment. A fully automated deployment with no approval creates risk and removes oversight.

Talk to Oblytech

Planning, running or fixing a ServiceNow programme? Tell us where you are and we will suggest a sensible next step.

Contact us