When ServiceNow or GLPI is the better fit for your ITSM estate
If your ServiceNow renewal, licensing change or data residency rule is forcing a decision, the short answer is this: ServiceNow fits when you rely on its platform breadth and vendor-run cloud, and GLPI fits when your service desk is mostly ITIL incident, problem, change, SLA, asset and CMDB work that you want to run on your own infrastructure. ServiceNow earns its cost when HR, security and operations workflows already run on the same platform and are tied to its application logic, because moving those pieces is a larger project than moving the service desk itself. GLPI covers the core ITIL processes and asset inventory under GPL-3.0 with no license fee, and it is the stronger choice when you want the service desk, inventory and data stored on servers you control.
Be careful with the word "equivalent". GLPI does not replace ServiceNow's application platform, its low-code development model or its breadth across adjacent products. Confirm with your own architects which ServiceNow capabilities your teams build against directly, such as custom applications, integrations and portal logic, and whether GLPI's plugins or the rebuilt equivalents cover them. The gaps that matter most are usually the ones your staff only discover after the first cutover. Ask Teclib' or a implementation partner to walk through each gap in writing before you commit.
The decision turns on two questions. First, which ServiceNow modules are in use: if the estate is limited to incident, problem, change, service level and asset management, the comparison is narrow and GLPI can be assessed on those modules alone. If HR service delivery, security operations or large-scale discovery run on ServiceNow, the decision needs a wider scope. Second, how much customization those modules carry: heavily scripted workflows, custom tables and bespoke catalog items take the most effort to rebuild, while standard configurations move more easily. Inventory both before you ask for a quote, so that any proposal is priced against the work you actually have.
Which scenarios favor each option
This table compares ServiceNow and self-hosted GLPI across common decision scenarios, showing which option usually fits better and why. Read each row as a starting point, then confirm the operational details against your own environment, data rules and scope before deciding.
| Scenario | Better fit | Reason |
|---|---|---|
| Data must stay in-country | GLPI on your own infrastructure | You choose the data center and hosting location, so residency is set by your own architecture rather than a vendor region. |
| Air-gapped network with no internet path | GLPI, or Private Stack if you can operate it | Private Stack still needs a customer or partner to run the full tier stack, while GLPI runs fully offline once installed. |
| Heavy custom workflows built on the platform | ServiceNow | ServiceNow's workflow and app platform is broader than GLPI, so confirm each custom flow has a GLPI equivalent before committing. |
| Service catalog built on the platform | ServiceNow, unless catalog needs are modest | Catalog depth and approvals sit deeper in ServiceNow, so map each catalog item to GLPI forms and rebuild gaps by hand. |
| Small team that wants ITIL basics | GLPI | Incident, problem, change, asset and service level modules cover core ITIL practice without a large platform to administer. |
| Large CMDB with many CI classes and relationships | Confirm in a pilot | GLPI covers configuration management, but the depth of CI modeling should be tested against your current ServiceNow data model. |
| Team with PHP and MariaDB or MySQL skills | GLPI | Requirements are documented PHP and MySQL or MariaDB, which matches typical open-source operations skills. |
Who operates what under each model
On ServiceNow's cloud offering, ServiceNow runs the hosting, the application tiers, the database and the platform upgrades. Your team owns the configuration of the instance, including workflows, catalog items, assignment rules, integrations and the data you put in it. Your responsibilities are mostly administrative and functional rather than infrastructural, and the trade-off is that you accept ServiceNow's hosting location, maintenance windows and upgrade schedule.
- Hosting and infrastructure: ServiceNow operates the servers, network and database layers, so your team does not patch operating systems or tune database engines.
- Upgrades: ServiceNow delivers platform releases to the instance on its own schedule, and your team tests customizations against them.
- Configuration and data: Your administrators own workflows, business rules, SLAs, CMDB design and data quality.
- Integrations: Your team builds and maintains connections to identity providers, monitoring and other systems.
- Exit and export: Your team plans how records and attachments leave the platform if you change providers.
Confirm with your ServiceNow account team which hosting regions and data residency commitments apply to your subscription, and which parts of the instance your contract makes your responsibility.
Under Private Stack, the customer or a partner runs the infrastructure inside its own data center, while ServiceNow supplies the application software, upgrade packages, deployment guidance and support. The load balancer, application server and database tiers become your operational responsibility, so the platform team must size hardware, patch the stack and keep the database healthy. ServiceNow's launch material says customers starting a deployment go through their account team and should expect to buy a workshop covering architecture planning, hardware sizing, database selection and operational readiness.
- Load balancer and application tiers: Your team or partner installs, configures and operates these tiers and handles capacity growth.
- Database tier: Your team selects, runs, backs up and patches the database that the platform depends on.
- Application software and upgrades: ServiceNow supplies the packages, and your team applies them to your environment.
- Support and deployment guidance: ServiceNow supports the software, but infrastructure faults in your tiers typically sit with your operators.
- Readiness work: The architecture and sizing workshop is a project cost to plan for before go-live.
Ask ServiceNow in writing which tiers it supports from its side, what the workshop covers and what it costs, and who is accountable for each layer during a production incident.
Self-hosted GLPI puts the application, web server and database entirely under your control. GLPI is GPL-3.0 software, so there is no vendor operating the platform for you unless you contract one. Your team owns the operating system, PHP runtime, database, web server, backups, upgrades and the security of the instance. The GLPI documentation sets the baseline: GLPI 12.0.0 requires PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later, while the GLPI 11.0 installation docs list PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6. Only MySQL and MariaDB are supported as databases.
- Runtime and database: Your team installs PHP 8.3 or later and MariaDB 10.11 or later, or MySQL 8.0 or later, and keeps them supported.
- Web server configuration: The document root must point to GLPI's public directory rather than the installation root, with URL rewriting routing requests through
index.phpon Apache, Nginx, lighttpd or IIS. - Upgrades: Your team backs up the database, files and the config directory including
glpi.keyandglpicrypt.key, replaces the application files and runsphp bin/console db:update. Plugins are suspended after a new version is detected and must be reactivated after major updates. - Security and availability: Your team owns hardening, TLS, backups, monitoring and recovery, and any high availability design.
- Optional vendor support: Teclib' offers GLPI Network subscriptions if you want contracted support, but that is an addition to your own operations.
Before committing, confirm which PHP and database versions your target GLPI release supports and who on your team is accountable for each layer.
Data location, identity and compliance implications
Moving from ServiceNow to GLPI changes where ticket, asset and personal data sits, who signs users in, and which evidence your assessors will ask for. The cards below cover the hosting choice, the login order GLPI applies, and the operational records you need to hand over. Each one should be settled before data migration starts.
Choose where the data lives
ServiceNow cloud keeps your records in ServiceNow's hosted environment, while GLPI can run in your own data center or cloud account, or on GLPI Network's public or private cloud run by Teclib'. Each option moves residency, backup ownership and sub-processor questions to a different party. Ask Teclib' in writing where GLPI Network hosts data, who can access it, and how exports and deletions are handled, then compare that with your current ServiceNow data processing terms.
Self-hosting moves operations to you
A self-hosted GLPI install puts the web server, PHP runtime, MariaDB or MySQL database, backups and patching inside your boundary, so your team owns every control that ServiceNow previously ran for you. Document which teams patch the operating system, the database and GLPI itself, and how encryption at rest and in transit is configured. Assessors will expect this responsibility split to be written down.
Mind the authentication order
GLPI tries authentication sources in a fixed order: the internal database first, then LDAP directories, then IMAP mail servers, then external methods such as REMOTE_USER. An account that exists locally can therefore be authenticated without your directory, so local accounts for administrators should be limited and reviewed. Test each source with a non-admin account before cutover, and confirm which directory attributes map to GLPI profiles and groups.
Protect the GLPI keys
GLPI relies on the glpi.key and glpicrypt.key files in its config directory, and losing them can make stored secrets unreadable after a restore. Include them in every backup, store copies separately from the database dump, and record who can read them. Your key management and access logging controls should cover these files the same way they cover other production secrets.
Gather administrative evidence
GLPI 12.0.0 adds a view of active user sessions with the ability to revoke them, and step-up authentication for certain administrative actions. Use these features to produce evidence of privileged access, session review and change approval, then export the audit log and profile assignments at regular intervals. Export ServiceNow access reports before decommissioning so the history of who held administrative rights is preserved.
Assessors attest, DeployOpen prepares
DeployOpen can plan the control set, configure logging and access settings, and assemble the evidence pack that your compliance team reviews. Independent auditors and certification bodies issue any attestation or certification, and the outcome depends on your own environment and records. Ask your auditor early which control frameworks apply to ticket and asset data, and confirm which evidence they accept before the scope is fixed.
What drives the cost of each option
This table breaks down what each path costs by component, separating one-time work from recurring charges. Read it as a list of who gets paid for what, then use the quote requests in the last row to compare like with like. ServiceNow pricing is not published here, so the ServiceNow column names what to ask for rather than a figure.
| Cost component | ServiceNow cloud or Private Stack | Self-hosted GLPI |
|---|---|---|
| Software license | Subscription quoted by the ServiceNow account team. Private Stack still requires a subscription for the application software and upgrades. | No license fee. GLPI is GPL-3.0 software. Optional GLPI Network or self-hosted subscriptions are extra. |
| Optional vendor support | Included in the subscription terms, so confirm support levels in writing before comparing. | Optional. GLPI Network self-hosted tiers run from 100 euros per month (Basic) to 4,500 euros per month (Enterprise), per the GLPI Network subscriptions page. |
| Hosted option pricing | Cloud subscription, quoted by ServiceNow. | GLPI Network public cloud costs 19 euros per user per month and private cloud 21 euros per user per month with a 25-user minimum, per the GLPI Network subscriptions page. |
| Infrastructure | Private Stack: you own and run the load balancer, application server and database tiers, so hardware or cloud capacity is your cost. | Web server, PHP runtime and MariaDB or MySQL on your servers or cloud accounts. Sizing scales with users, assets and agent count. |
| Initial planning and sizing | Private Stack requires a ServiceNow workshop covering architecture, hardware sizing, database selection and operational readiness. Ask for its price and scope in writing. | No vendor workshop is required. Architecture, sizing and hardening are your team's work or an implementation partner's scoped work. |
| Migration and data work | Export effort, mapping of incidents, problems, changes and CIs, and rebuilding workflows and catalog items. Usually the largest one-time item. | Extraction, mapping to GLPI, CSV or script loading, and manual rebuild of workflows and SLAs. Same categories, different tooling. |
| Staff time to operate | Lower for cloud. Private Stack moves patching and tier operations to your team. | Ongoing upgrades, plugin reactivation after major updates, backups of database and config keys, and monitoring. Budget for this recurring time. |
| Agent and inventory tooling | Discovery or agent tooling is part of ServiceNow's licensed offering. Confirm which modules are included. | GLPI Agent is free to deploy and runs on Windows, macOS and Linux. Costs are the time to roll it out and keep it current. |
| Quote request checklist | Subscription scope by module, Private Stack workshop fee, infrastructure assumptions, support tier, renewal uplift and exit or data export terms. | Written scope, sizing assumptions, support tier if any, hosting model, migration effort, and who performs upgrades and backups. |
Where ServiceNow's platform breadth has no GLPI equivalent
The point to settle first is that GLPI covers ITSM, asset and CMDB work, but ServiceNow is also a development platform and a suite of adjacent products. Several of those areas have no direct GLPI counterpart: custom application development on the ServiceNow platform, the depth of its workflow designer, HR service delivery, security operations, and the marketplace of third-party applications that install on top of the instance. If your organization runs any of these, GLPI will not replace them and you will need a separate decision for each.
The condition that matters is whether those capabilities are live in production or only licensed. Ask your ServiceNow administrator to list every application in the instance and every custom table, scripted business rule, flow and catalog item that business units depend on, then tag each one as core ITSM, custom build, HR, security operations, or third-party app. Pull the list from the instance rather than from the contract, since subscriptions and actual usage often differ. Also record which integrations push data in or pull data out, because each one becomes a migration or rebuild item.
Once the inventory is complete, sort each item into one of three outcomes: rebuilt in GLPI, replaced by another tool, or retired. Custom applications built on the platform usually need a new home, whether that is a separate open-source application stack or a retained ServiceNow instance for those workloads. Confirm with the vendor and with your own team which GLPI plugins or extensions cover each remaining need, and treat any gap as a scoped decision with an owner, rather than assuming the service desk will absorb it.
What a move from ServiceNow to GLPI involves
The sequence turns ServiceNow records, workflows and CMDB data into a GLPI instance your team operates, validated against live use before ServiceNow is switched off. Each step closes with a check, so cutover is a decision rather than a deadline.
Inventory modules, customizations and integrations
Your team lists which ServiceNow applications are in use, such as incident, problem, change, service level, asset and CMDB, and which custom tables, business rules, flows, catalog items and integrations feed or depend on them. Platform owners and service managers confirm which items are still needed. The output is a signed-off register that marks each item as migrate as data, rebuild in GLPI, replace with another tool, or retire. Anything with no owner stays out of scope until someone claims it.
Export data within ServiceNow limits
The ServiceNow administrator extracts incidents, problems, changes, configuration items, assets, contracts and users in batches that stay within the export limits of the ServiceNow release in use, since default list exports carry record caps. Attachments need a separate extraction path, so the team plans for them as their own workstream. The check is a row count per table that matches the source, with exported files stored under access control in your own environment.
Map records to GLPI item types
Engineers and service managers map ServiceNow fields to GLPI equivalents: incident and problem tickets, change records, service level definitions, computers, software, peripherals and configuration items to GLPI asset types or custom asset definitions, plus users, groups, locations and statuses. They record which states, priorities and categories collapse or split, because GLPI's ticket model differs from ServiceNow's task tables. The check is a signed mapping document that names every field and its transformation, reviewed by the service desk leads.
Rebuild workflows and service catalog by hand
Workflows, approval paths, service catalog items, forms and notification logic do not transfer as data, so the team rebuilds them in GLPI using its ticket templates, validation rules, business rules, SLM and OLA definitions and approval features. Plugins that the organization depends on are selected, tested and documented at this stage. Because GLPI suspends plugins after a new version is detected and requires reactivation after major updates, the runbook records each plugin, its source and the reactivation step. The check is a list of rebuilt processes each approved by its process owner.
Install and harden the GLPI instance
The platform team installs GLPI in your infrastructure, choosing a supported PHP and MariaDB or MySQL combination from the current prerequisites, and points the web server's document root at GLPI's public directory with URL rewriting enabled. Hardening covers TLS, database access, file permissions, backups of the config directory including the glpi.key and glpicrypt.key files, and authentication sources such as LDAP or SSO. The check is a documented build that a second engineer can reproduce, plus a tested restore of the database and files.
Load and validate migrated data
Engineers load the mapped data into a staging instance, then compare counts, sample records, relationships between tickets and assets, and SLA calculations against the ServiceNow export. Data owners review a defined sample of open and recently closed items, and each discrepancy is logged with a fix or an accepted exception. The check is a reconciliation report signed by the service owner, showing which record classes passed, which were corrected and which were consciously left behind.
Run parallel operations and train staff
The service desk works in GLPI while ServiceNow stays available as read-only reference for an agreed period, and new discovery feeds, such as GLPI Agent inventory, are compared against the existing records. Agents, approvers and requesters are trained on the rebuilt processes, and the team logs defects and process gaps. The check is a set of exit criteria, agreed in advance, such as no open severity issues in the parallel period, that the service owner signs off.
Cut over and retire ServiceNow access
After the exit criteria are met, the team freezes changes in ServiceNow, runs a final incremental extract, loads it into GLPI, switches the intake channels and integrations, and disables ServiceNow user access. Records are retained according to your records policy, and the decommissioning evidence is filed with the change record. The check is a completed cutover checklist and a confirmed inventory of live integrations, with each one repointed or retired.
Questions buyers ask before switching from ServiceNow to GLPI
What drives the cost of moving from ServiceNow to GLPI?
The main cost drivers are the people doing the work, the hosting you run, and any support you buy, because GLPI itself has no license fee under GPL-3.0. Your one-time costs cover assessment, data extraction, mapping, configuration, testing and cutover, and whoever does that work (your staff, a consultant or a partner) is paid for it. Recurring costs cover servers or cloud capacity, database and PHP maintenance, backups, and staff time for upgrades. If you want vendor support, GLPI Network publishes self-hosted subscriptions starting at 100 euros per month for the Basic tier, which is a useful reference point when you compare against your ServiceNow renewal. Ask any provider for a quote that separates implementation, hosting, support and ongoing operations.
How long does a ServiceNow to GLPI migration take?
No duration is fixed by the product, so the timeline depends on the scope you agree in writing. The biggest factors are how many workflows, service catalog items, approval paths and custom fields you must rebuild, how clean your CMDB and asset data are, how many integrations feed or read from ServiceNow, and how many people must test and sign off. Parallel running and a planned cutover window also add time. Ask any implementation partner for a fixed-scope plan with milestones, and confirm the assumptions behind it, such as the data volume and the number of business processes in scope.
What does our team need to provide during a GLPI migration?
Your team needs to own the decisions that GLPI cannot make for you. These include the ITIL process design for incidents, problems, changes and service levels, the asset and CI classes you will keep, the approval rules for changes, and the user and group structure used for authentication. Your team also needs access to the ServiceNow instance for exports, a named owner for data quality decisions, and testers from service desk, change management and asset management. Engineers will need to provision the web server, PHP, the database and backup storage in your environment, and someone must be accountable for the security settings and access reviews afterwards.
Can an internal IT team migrate from ServiceNow to GLPI without outside help?
Yes, a capable internal team can do it, provided it has the skills and time. GLPI is installed on a standard stack of PHP and MySQL or MariaDB, and its documentation covers the setup. The harder parts are the data work and the process design: extracting records, mapping ServiceNow tables to GLPI item types, rebuilding workflows by hand, and validating results against real tickets. Be honest about capacity, since this work competes with day-to-day operations. Many teams bring in an outside partner for specific pieces, such as hardening, backup design or cutover support, and keep the process design in-house. Decide which parts you own before you start.
How does the GLPI update procedure work?
The GLPI update procedure starts with backups, followed by application file replacement and a database update. According to the installation docs, you back up the database, the files and the config directory, including the glpi.key and glpicrypt.key files, then replace the application files and run php bin/console db:update. Since GLPI 11.0, plugins are suspended when a new version is detected and must be reactivated after major updates, so plan time to test each plugin. Keep the encryption key files safe, because losing them can make stored encrypted data unreadable. Test upgrades in a staging copy first, and check the release notes for each version before you move production.
Is ServiceNow Private Stack a better fit than self-hosted GLPI?
Private Stack suits organizations that must keep the ServiceNow platform itself and accept running its infrastructure tiers. According to ServiceNow's launch post, you or a partner own and operate the load balancer, application server and database tiers, while ServiceNow supplies the application software, upgrade packages and deployment guidance. Customers start through their account team and should expect to buy a workshop covering architecture, hardware sizing, database selection and operational readiness. GLPI fits better when you want to drop the ServiceNow licensing model entirely and run an open-source stack with a GPL-3.0 license. Compare both options on operations, upgrades, licensing and exit terms, and confirm current Private Stack pricing and requirements with ServiceNow.
Which GLPI capabilities need extra work to match ServiceNow?
GLPI covers ITIL-style incident, problem, change and service level management, asset inventory, configuration management, a knowledge base and contract management. Gaps appear where ServiceNow's platform breadth is used, including custom application development on its low-code platform, orchestration across other IT operations products, and many pre-built integrations. Plan extra work for:
- Workflows and approval logic that exist only in ServiceNow flows
- Service catalog items with custom forms
- Integrations with monitoring, identity and HR systems
- Reports and dashboards that rely on ServiceNow-specific tables
Map each ServiceNow feature you use to a GLPI feature or a custom build before you commit to a timeline.
How does GLPI authentication connect to our directory?
GLPI tries authentication sources in a fixed order: the internal database first, then LDAP directories, then IMAP mail servers, and then other external methods such as REMOTE_USER. This means local accounts are checked before directory accounts, which matters for administrator access and for account cleanup. Confirm which accounts must still log in during a directory outage, and decide whether any local accounts should be removed after cutover. Review the authentication settings with your identity team before go-live, and test group mapping for each role your service desk uses.
What to confirm with GLPI and ServiceNow before you commit
Before you commit to either path, get the current licensing for each ServiceNow ITSM module in writing from your account team, and ask which modules your contract covers today: incident, problem, change, service level management, asset and CMDB. Ask also for the export limits that apply to your instance and whether any scheduled export set or REST extraction you depend on is included in your entitlement. These answers set the scope of your migration and the cost of leaving, so do not rely on a list price or a previous quote.
On the GLPI side, test your own change approval and service level rules against the release you plan to run, not against the feature list. Build a short test case for a standard change with two approval steps, an emergency change and an incident that breaches a response target, then confirm that GLPI handles each one or that you need a plugin or a custom rule. Check that the version you select supports your database and PHP versions: the GLPI README on the main branch and the installation docs state different minimums for GLPI 11.0, so use the requirements of the exact release you intend to deploy. Confirm that only MySQL and MariaDB are in your plan, since the docs say no other database is supported.
Last, ask Teclib' in writing what support it offers for a self-hosted GLPI installation, including response targets, hours, escalation and whether plugin issues are covered. The GLPI Network subscriptions page lists self-hosted tiers with level 3 support, but you should confirm what each tier includes for your environment and whether a tier limits agent or asset counts. Ask DeployOpen for a written scope that covers who owns the backups of glpi.key and glpicrypt.key, who runs the update procedure, and how plugins are reactivated after a major upgrade.
How DeployOpen helps you evaluate, implement and migrate GLPI
DeployOpen is a Chainscore Labs company that plans, implements, integrates, hardens, backs up and documents self-hosted open-source platforms inside your own infrastructure. For a ServiceNow vs GLPI decision, we start with the written scope of which ITSM modules, asset sources and integrations matter to your service desk, then build and hand over only what that scope covers.
How we scope
- We map your incident, problem, change, service level and CMDB processes to GLPI features and list the gaps in writing.
- We inventory which ServiceNow workflows, catalog items and integrations must be rebuilt, replaced or retired.
- Engagements are fixed-scope, so deliverables, timelines and responsibilities are agreed in writing before any work starts.
How we build
- We size the database, PHP and web server tiers in your environment, confirming supported versions with the GLPI installation documentation.
- We configure authentication sources such as LDAP or IMAP, roles, ITIL ticket templates, SLAs and approval flows to match your scope.
- We test imports, inventory collection through GLPI Agent and the update path, documenting results against your acceptance criteria.
How we hand over
- You receive configuration records, runbooks for backups of the database, files and glpi.key and glpicrypt.key, and the update procedure.
- We document the data mapping from ServiceNow exports, including which records were migrated, reconciled or deliberately left behind.
- We train your administrators on daily operations and walk through the upgrade steps, including reactivating plugins after major updates.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer, scoped separately from the original project.
- We can coordinate with Teclib' support contracts where you choose to buy them, so responsibilities are clear on both sides.
- Before any compliance assessment, we prepare the controls and evidence you need. Independent auditors issue the actual assessment outcome.
