- 01
Market
Saudi Arabia
- 02
Written for
CIO, Head of Digital
- 03
Decision
Extend and integrate an installed ServiceNow instance without endangering its upgrades
- 04
Languages
EN · AR
Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The governing question
The route a demand takes before it becomes ServiceNow code
Most requests that arrive as "customise the platform" should leave as something else. This is the sequence a demand passes through before anyone writes a script, and each gate exists to protect the upgrade path.
A flow with four gates — can configuration do it, does it earn a scoped app, build inside the boundary, prove it against the next release — and a branch for demands that are refused and recorded.
- 01
Can configuration do it
The platform’s own forms, rules and flows cover more than teams assume. What configuration can express, configuration should — it survives every upgrade by definition.
- 02
Does it earn a scoped app
Genuinely custom logic goes into a scoped application with its own namespace, so the platform can upgrade underneath it without collision.
- 03
Build inside the boundary
The app uses the platform’s published APIs and extension points, never a modification to code ServiceNow ships and will ship again differently.
- 04
Prove it against the next release
Automated tests run against the upgrade preview, so a collision is found in a sub-production instance rather than the morning after go-live.
Refuse and record
Some demands should not be built — they replicate what the platform already does, or they encode one team’s habit as everyone’s constraint. Saying no, with the reason recorded, is part of the governance rather than a failure of it.
The debt curve
How a ServiceNow instance becomes too customised to upgrade
No single customisation sinks an instance. The damage is cumulative: a script edit here to change how an approval routes, a modified business rule there because a director wanted a different field mandatory, each one reasonable, each one made in the global scope because it was quicker that day. Two years later the upgrade assessment lists hundreds of skipped changes, nobody can say which customisations still earn their keep, and the platform the organisation bought so it would not maintain software has become software it maintains.
The economics of customisation are honest if you count both sides. A customisation pays when it encodes something genuinely yours — a regulated approval chain, a workflow your market requires — and it costs every upgrade for as long as it lives. A customisation that merely restores a habit from the old tool pays nothing and costs the same. The review that separates the two is worth more than most new development, because retiring a dead customisation is the cheapest upgrade insurance there is.
Beyond the instance
The connections that decide whether ServiceNow reflects reality
An instance that people update by hand drifts from the truth within weeks. These are the integrations that keep it honest, and the governance that keeps its citizen developers from undoing the discipline.
Monitoring that opens the ticket itself
Alert and event sources feed the instance directly, so an incident record exists the moment the system misbehaves — correlated and deduplicated, not re-typed by whoever noticed first.
Identity as the platform’s gatekeeper
Sign-in, roles and group membership flow from the identity provider, so access to the instance follows the joiner-mover-leaver process instead of accumulating until an audit finds it.
A CMDB fed by discovery, not by memory
The configuration records that route incidents and assess change risk are populated from automated discovery and the systems that deploy infrastructure, because a hand-maintained CMDB is confidently wrong.
Citizen development inside a fence
Low-code building by business teams is a strength until it writes to shared tables unreviewed. A fence — dedicated scopes, reviewed promotion to production, an inventory of what exists — keeps the speed without inheriting the sprawl.
Our role
What we build on ServiceNow and what your platform owner keeps
- 01
Custom work that upgrades survive
We build scoped applications against the platform’s published interfaces, so what we deliver rides an upgrade rather than blocking one — and we say plainly when a request should be configuration or should not be built.
- 02
The estate wired in
We connect monitoring, identity and the systems around the instance so records open, update and close from events rather than from typing, and access follows your identity source of truth.
- 03
A governance your teams can run
We leave the demand gates, the scoped-app conventions and the upgrade test pack with your platform team, because a discipline only a supplier can operate is not a discipline.
Which processes ServiceNow should carry, and how far it bends to yours before yours bend to it, are your platform owner’s calls; we make sure whichever way each call goes, the instance still upgrades on schedule.
Common questions
What buyers ask
Should we customise ServiceNow or change our process to fit it?+
Start from the platform’s way and make it prove itself wrong. ServiceNow’s out-of-the-box processes encode common practice across thousands of organisations, and most divergence from them is habit rather than requirement. The exceptions worth building are the ones that are genuinely yours — a regulatory approval chain, a market-specific workflow — and those go into scoped applications, not global changes. The test we apply to every request is whether the difference produces a business outcome or merely preserves a familiarity; only the first justifies carrying the cost at every future upgrade.
Our ServiceNow upgrades keep slipping because of customisations. Is that fixable?+
Yes, and the fix is an audit before it is a rebuild. The first step is an inventory: every modification to the global scope, who made it, and whether anything still depends on it — in most instances a meaningful share turns out to be dead, and retiring those is free upgrade capacity. What remains is triaged: some moves back to configuration the platform has since grown, some is rebuilt as scoped applications, and a small core is accepted as permanent and covered by automated tests against each upgrade preview. The instance does not have to be reimplemented; it has to be paid down deliberately, one customisation at a time.
Business teams are building their own apps on our ServiceNow instance. Should we stop them?+
Govern them rather than stop them. Citizen development is genuine capacity — business teams automate what IT never would have reached — and shutting it down usually drives it into spreadsheets and shadow tools instead. What it needs is a fence: dedicated scopes so a departmental app cannot alter shared tables, a reviewed promotion path so nothing reaches production unexamined, and an inventory so the platform owner always knows what exists and who owns it. Inside that fence, speed; outside it, the same discipline any change to a shared platform deserves.
In this cluster
Next step
Review your instance with us
A review of your instance that lists every customisation, names which ones endanger the next upgrade, and proposes the scoped-app or configuration route for each.
