When GLPI or Snipe-IT is the right fit for your IT team
Choose GLPI when your IT team needs tickets, problems, changes and inventory in one platform and expects to use them. GLPI is an ITSM suite distributed under GPL-3.0, and its ITIL processes sit alongside asset management, so hardware and software records feed the service desk directly. Choose Snipe-IT when the main job is knowing who holds which laptop, when assets were bought for depreciation, and how many seats of each software license remain. Snipe-IT is AGPL-3.0 and focuses on checkout, licenses, accessories and consumables such as toner, and it does not try to be a full service desk. If your team mostly needs a queue for requests and incidents, neither tool replaces a dedicated helpdesk, and you should compare against the sibling options before committing.
Three decisions should settle the choice. First, decide whether a service desk is needed now or within the next year. If it is, GLPI covers that scope in one product; if not, Snipe-IT keeps the deployment smaller. Second, estimate how much process your team will adopt. GLPI's change and problem workflows only pay off when people follow them, and a team that works from spreadsheets will struggle with a suite built around ITIL. Third, decide who will run the server. Both platforms are self-hosted and need PHP, a database and a web server, and GLPI 11.0 requires PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6, while Snipe-IT requires PHP 8.2 or later and below 8.6 with MySQL 5.7 or later or MariaDB. Confirm the version floors against the current requirements pages before you size the host, and confirm who will apply GLPI's update steps, which include backing up the config directory and reactivating plugins after an upgrade.
Before you commit, test both tools against one real workflow from your own estate, such as onboarding a laptop, assigning a license and retiring a device. Check whether LDAP and SAML login, which both platforms support, meet your identity requirements, and confirm the plugins or connectors you need for discovery and inventory. A short pilot will show whether your team needs a single platform or two focused tools, and it gives you the evidence to take to your procurement and security reviewers.
Which platform fits which IT scenario
This table maps common IT scenarios to the platform that fits each one better, and names the condition under which the other platform would be the stronger choice. Read each row against your own team's workload: ticket volume, asset count and how much relationship modeling you need.
| Scenario | Better fit and reason | Choose the other platform when |
|---|---|---|
| Small team tracking laptops, phones and software seats | Snipe-IT. It is built for checking out assets, licenses and accessories to people, tracks purchase dates for depreciation, and its self-hosted software is free under AGPL-3.0. | Your asset tracking must sit alongside formal incident and change tickets, in which case GLPI covers both in one suite. |
| IT department running incident, problem and change management | GLPI. It handles ITIL tickets, problems and changes alongside asset management, so requests and the assets they touch stay in one system. | You only need asset records and no ticketing, so Snipe-IT's narrower scope is less to deploy and maintain. |
| Team that needs CMDB-style relationships between services and hardware | GLPI, with the caveat that its asset-centric inventory is the starting point. Confirm the relationship depth you need against the GLPI documentation before committing. | You need a fully customizable CMDB data model with impact analysis. That points toward a dedicated CMDB platform such as iTop, which is outside this comparison. |
| Team that already runs a helpdesk elsewhere and wants only asset and license tracking | Snipe-IT. It can serve as the asset register without replacing the existing desk, and its LDAP and SAML login avoids a second identity store. | Your existing helpdesk cannot hold asset links and you want one system for tickets and inventory, which favors GLPI. |
| Discovery of hardware and software on endpoints | GLPI, with the GLPI Agent collecting hardware and software inventory natively since version 10. Network discovery and SNMP inventory need the separate GLPI Inventory plugin. | Your main need is manual check-out tracking rather than automated collection, where Snipe-IT's workflow is simpler to run. |
| Software license seat tracking tied to people and purchase records | Snipe-IT. License check-out to users and purchase dates for depreciation are core to its model, as described in its user documentation. | Licenses must be tied to contracts, financial records and service tickets, which GLPI's wider suite is designed to cover. |
| Consumables such as toner and components such as RAM | Snipe-IT. Its user's manual describes consumables and components as first-class items, so stock is tracked directly. | Consumables only matter as part of a service request workflow, where GLPI's ticketing may be the better home. |
| Integration with an existing directory and single sign-on | Either platform supports LDAP and SAML. Snipe-IT lists SAML providers such as Entra ID, Okta and Authentik. Confirm the GLPI login methods your directory needs in the GLPI user documentation. | Your identity provider is not on Snipe-IT's supported list, so check GLPI's authentication options first. |
How GLPI and Snipe-IT are built and what that means for operations
GLPI and Snipe-IT both run as PHP web applications on a relational database, but they differ in how much of the stack you own and how inventory reaches the system. The cards below cover the runtime, the database, the web server layout, inventory collection, Docker availability and the upgrade path, so you can estimate who patches, backs up and maintains each deployment.
PHP and database versions
GLPI's README lists PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later, while the installation docs list PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6 for GLPI 11.0. Snipe-IT requires PHP 8.2 or later and below 8.6, with MySQL 5.7 or later or MariaDB. Confirm which GLPI version you will deploy before you pick a PHP build, because the two documentation sources differ. Both platforms need a PHP upgrade plan that tracks the supported range.
MySQL and MariaDB only for GLPI
The GLPI installation docs say only MySQL and MariaDB are supported, so teams standardized on PostgreSQL will need a separate database platform for this service. Snipe-IT also runs on MySQL or MariaDB, which means one database engine can serve both if you run both. Ask your DBA to confirm the MariaDB or MySQL version floor for your GLPI release, and plan backup and restore tests against that engine rather than a generic one.
Public document root for GLPI
GLPI requires the web server document root to point to its public directory, not the installation root, with URL rewriting that routes requests through index.php on Apache, Nginx, lighttpd or IIS. Misconfigured roots expose application code and configuration files to the web. Snipe-IT instead expects Apache with mod_rewrite or IIS with URL Rewrite. Your web hardening baseline and reverse proxy rules need separate entries for each application.
GLPI Agent for inventory
The GLPI Agent collects hardware and software inventory and sends it to GLPI, and it runs on Windows, macOS and Linux. It is the successor of FusionInventory Agent and has been part of GLPI since version 10. Agent deployment, version drift across endpoints and certificate handling become operational tasks you own. Snipe-IT has no equivalent agent in the supplied facts, so endpoint data is entered or imported by your own process. Confirm the agent update mechanism for your fleet.
GLPI Inventory plugin for discovery
Network discovery and SNMP inventory need the separate GLPI Inventory plugin rather than the agent alone. Teams that need to find unmanaged switches, printers or network devices must plan an additional plugin to install, patch and reactivate after GLPI upgrades. The plugin also adds a dependency that must be checked against each GLPI release. Snipe-IT's supplied facts do not describe a discovery feature, so confirm with the vendor whether network scanning covers your use case before you assume parity.
Upgrades, backups and plugin suspension
GLPI's update procedure requires a backup of the database, the files and the config directory, including glpi.key and glpicrypt.key, followed by replacing application files and running 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. Losing the key files can make encrypted data unreadable, so store them in your backup set with restricted access. Budget a test upgrade for each major release, and confirm how Snipe-IT's upgrade steps differ for your version.
Docker images for both platforms
GLPI 12.0.0 lists an official Docker image among its distribution options, and the Snipe-IT README says a Docker image is available. Containers reduce PHP and web server drift, but they move patching responsibility to your image pipeline and volume layout. Persistent storage for uploads, attachments and config must survive container rebuilds, and the GLPI key files need the same care. Ask each project which image tags it publishes and how often they are rebuilt before you standardize on one.
Side-by-side capabilities for asset, license and helpdesk needs
This table compares how GLPI and Snipe-IT handle asset tracking, license and consumable tracking, ITIL processes, inventory, login and APIs. Read it by matching your primary need first, then checking the rows marked for confirmation with the vendor before you shortlist either product.
| Capability | GLPI | Snipe-IT |
|---|---|---|
| Core scope | ITSM suite covering tickets, problems, changes, assets, CMDB, contracts and financial management | Focused IT asset management tracking who has which device, purchase dates and software licenses |
| Asset check-out | Assets tracked in the inventory with ITIL ticket and change links; confirm check-out workflow detail with the vendor | Checks out assets, licenses, accessories and consumables such as toner to people |
| Consumables and components | Confirm consumable stock and component handling (for example RAM or drives) with Teclib' before relying on it | Consumables such as toner and components such as RAM and hard drives are documented as tracked items |
| ITIL tickets, problems and changes | Handles ITIL tickets, problems and changes as core functions | Not positioned as a ticketing or change management tool; confirm any helpdesk need separately |
| Native inventory | GLPI Agent collects hardware and software inventory since version 10; network discovery and SNMP need the GLPI Inventory plugin | Inventory is recorded against the asset record; confirm automated discovery options with the vendor |
| LDAP login | Authenticates against the internal database, then LDAP directories, IMAP and REMOTE_USER, tried in that order | LDAP sync imports and updates users and lets them log in with LDAP credentials, falling back to local accounts |
| SAML login | Confirm SAML provider support and configuration with Teclib' for your identity provider | Supports SAML with Entra ID, Google Workspace, Okta, OneLogin, JumpCloud, Shibboleth and Authentik |
| REST API and licensing | Confirm API scope with the vendor; licensed under GPL-3.0 with paid Teclib' subscriptions for added support and plugins | JSON REST API covers most web actions; licensed under AGPL-3.0, self-hosted software free per the vendor pricing page |
What the licenses and paid options cover for each platform
GLPI is distributed under the GNU General Public License version 3, according to the GLPI README on GitHub, and the self-hosted software is free to download, run and modify under those terms. Teclib', which maintains GLPI, sells separate GLPI Network subscriptions and a managed cloud service. Those are commercial services layered on top of the community software, not a different edition of the code.
- License: GPL-3.0 covers the GLPI software itself, so the software license cost is zero for self-hosting.
- Self-hosted subscriptions: According to the GLPI Network subscriptions page, self-hosted plans range from 100 euros per month (Basic, up to 10 agents and 500 assets) to 4,500 euros per month (Enterprise), and include level 3 support and GLPI Network marketplace plugins.
- Cloud options: The same subscriptions page lists GLPI Network public cloud at 19 euros per user per month and private cloud at 21 euros per user per month, with a 25-user minimum for private cloud.
- Trial: According to the GLPI project site, GLPI Network Cloud comes with a 45-day free trial.
- Separation: The community software and the subscriptions are independent, so a team can run the free release without buying a tier.
Confirm with Teclib' which plugins are limited to GLPI Network and whether a subscription changes your upgrade or support obligations before you budget for it.
Snipe-IT is licensed under AGPL-3.0, according to the license metadata of the grokability/snipe-it GitHub repository. The AGPL requires that users who interact with a modified version over a network can obtain its source, so any custom changes you make to a hosted deployment need to be reviewed against that condition. The self-hosted software is free, and the paid offering is a hosted service.
- License: AGPL-3.0 covers the application code and its network use obligations.
- Free self-hosting: According to the Snipe-IT pricing page, the self-hosted software is and always will be free.
- Hosted plans: The same pricing page lists hosted plans from $399.99 per year, which add email support, automated upgrades and server maintenance.
- What you pay for when hosted: The hosted plan buys operations and support, not extra asset features that are missing from the free release.
- Your costs when self-hosted: Your own servers, backups, patching and any support contract remain your responsibility.
Ask the vendor which hosted tier includes your required data retention, backup and recovery terms, and how a move from hosted back to self-hosted would be handled.
A license and a subscription do not cover the work of running the platform. Both products are free to self-host under their stated licenses, so the real cost sits in servers, database administration, integration work and staff time. Those costs are not in any price list quoted above, and they vary with your environment.
- Implementation: Planning, configuration, data import and integration with directories and monitoring are project costs, paid to whichever partner or staff you use.
- Operations: Patching, backups, upgrades and restore testing recur for as long as you run the platform.
- Plugins and extensions: Check which features rely on paid plugins or marketplace add-ons, since those can change the total cost.
- Support: Paid support, whether from a vendor subscription or from an outside firm such as DeployOpen, is optional and priced separately from the software.
- Recurring versus one-time: Subscriptions and hosted plans recur, while the implementation is usually a one-time project.
When you request a quote, ask for the scope of support, the upgrade policy, and the named items that are included in each tier.
What drives the running cost of each platform
Both platforms are free to self-host, so the running cost sits in infrastructure, staff time and the subscriptions you choose to add. Snipe-IT's self-hosted software is free, and its pricing page says so, with hosted plans from $399.99 per year that add email support, automated upgrades and server maintenance. GLPI's community release is also free, but a Teclib' GLPI Network subscription is a recurring fee for level 3 support and Network-only plugins, priced from 100 euros per month for the self-hosted Basic tier (up to 10 agents and 500 assets). Confirm with Teclib' or your reseller which GLPI Network features your workflow actually needs before you budget for one.
GLPI's upgrade procedure is the largest recurring staff task, and it is where its cost is most sensitive to how you plan. The installation docs require a backup of the database, the files and the config directory including glpi.key and glpicrypt.key, replacing application files and running 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 every plugin you depend on (inventory, OLA or custom forms) adds a test and re-enable step. Snipe-IT's requirements are narrower (PHP 8.2 or later and below 8.6, MySQL 5.7+ or MariaDB, and Apache or IIS), so its routine upgrades usually involve fewer moving parts. Ask your team to estimate patch and backup hours for each platform on your own hosting, since that figure will dominate the recurring cost.
One-time costs are setup, data cleanup and integration, and an external partner is priced against a written scope. Expect the largest one-time effort in moving asset records, license seats and user directories into the new system, plus configuring LDAP or SAML login and any GLPI Agent or inventory connectors. DeployOpen does not publish prices, and most engagements are fixed-scope, so a quote follows the scope agreed in writing. In the quote, ask for the deliverables and hours behind each line, which items are one-time and which are retainers, the plugin and version upgrade work, the backup and restore test, and what happens to the scope if you later add GLPI Network or a second platform. Ask for a written list of exclusions as well.
How to move from Snipe-IT to GLPI or back without losing asset history
This sequence moves asset records, users, licenses and check-out history between Snipe-IT and GLPI with a verified mapping at each stage, so both directions keep the same audit trail. It ends with a parallel run and a documented cutover that the team can reverse if needed.
Export and clean source asset data
Export assets, models, categories, users, licenses, accessories, consumables and locations from the source system using its API or built-in exports. Your IT asset manager or a platform engineer does the export, and an asset owner reviews duplicates, missing serial numbers and retired items. Done means each record has a unique asset tag, a serial number or a documented exception, and a count per category matches the source report. Snipe-IT's JSON REST API allows most actions available in its web interface, so confirm with the vendor which fields your version exposes before scripting the export.
Map statuses, locations and models
Build a mapping sheet that translates each source status label, location, manufacturer and model into the equivalent GLPI field or dropdown, including how the destination treats assets in storage, in repair and retired. Snipe-IT's model of checking out assets, licenses and accessories to people differs from GLPI's ITIL and asset relationships, so record which source concepts become GLPI assets, which become licenses or consumables and which become simple notes. Done means every source status and location has one agreed destination value, signed off by the asset owner in a written mapping table.
Load users and set up directory login
Create or synchronize users in the destination first, so ownership links resolve when assets are loaded. Configure LDAP or Active Directory on both sides where you use it: Snipe-IT's LDAP sync imports and updates users and can fall back to local accounts, and GLPI's user documentation describes trying the internal database, LDAP, IMAP and other external methods in order. Where you use SAML, confirm that the identity provider and attribute mapping are supported on the destination version. Done means a test user from each group can log in with the expected role, and no shared or generic admin account is left active.
Load assets, licenses and consumables
Import the cleaned data in small batches, starting with locations and models, then assets, then licenses and consumables. No direct import tool between these two products is confirmed in the sources for this page, so expect scripted loads through each product's API or a CSV process that your team writes and tests. Run a check after each batch comparing record counts, serial numbers and assigned users against the mapping sheet. Done means a sample of at least one asset per category matches the source on tag, serial, model, location and assignee.
Rebuild check-out history and integrations
Check-out history is the hardest part to preserve. Export the source event log where it exists and decide whether to store it as attached notes, documents or an archive, since a clean one-to-one history import should not be assumed. Then rebuild the integrations that depend on asset data, such as directory-driven onboarding, inventory agents and reporting, and test each against the destination's API or agent. For GLPI inventory, note that the GLPI Agent is the native hardware and software inventory path since GLPI 10, while network discovery needs the separate GLPI Inventory plugin. Done means every historical record you keep is searchable from its asset, and each integration has a test case with a recorded result.
Run both systems in parallel
Keep the source system read-only for reference while the destination takes new check-outs, returns and purchases for an agreed period. The asset owner and service desk log each change in both systems during this window, and a reconciliation report compares asset counts, assignments and license seats weekly. Because both products are self-hosted in your own infrastructure, plan the backup of each database and file store before the parallel run starts, following the vendor's documented backup steps. Done means the reconciliation report shows no unexplained differences across two consecutive checks.
Cut over and document the reversal path
Freeze writes to the source system, run a final delta load of changes made since the last reconciliation, and switch the directory, integrations and user instructions to the destination. Keep the source database and a verified backup for a retention period set by your records policy. Confirm with each vendor before starting: supported versions and PHP and database requirements, whether an API version or field changes after upgrade, plugin or extension compatibility, and support options for the move. Done means the source is marked read-only, the cutover log is signed by the asset owner and a tested restore from the backup has been recorded.
Where GLPI and Snipe-IT implementation projects usually run long
Timelines for both platforms slip for the same reason: the data and the process decisions arrive later than the software. In Snipe-IT, the work is mostly asset and license record quality: model numbers, status labels, purchase dates, supplier names and the link between a license seat and the person or device holding it. Snipe-IT's depreciation and checkout history only become useful once those records are clean, so a team should run a sample import, reconcile it against finance and procurement records, and agree who owns each field before the import is scaled up. In GLPI, the equivalent risk is larger because asset data feeds tickets, contracts and financial management. Before configuring anything, decide how ITIL incidents, problems and changes will flow, which categories and approval steps match your process, and which OLAs and contracts apply. Teams that configure GLPI first usually rework it after the first pilot.
Identity integration is the second common delay. Both platforms need LDAP or SAML testing with real accounts: Snipe-IT's LDAP sync imports and updates users and falls back to local accounts, and its SAML support covers providers such as Entra ID and Okta. GLPI tries its authentication sources in a set order, so a misplaced LDAP or IMAP source can lock out users or grant the wrong profile. Test group-to-role mapping, disabled-account behavior and a break-glass local administrator on a staging copy, and confirm the exact attribute mappings with your identity team. GLPI also adds its own upkeep. Its update procedure requires backing up the database, files and the glpi.key and glpicrypt.key files, and since GLPI 11.0 plugins are suspended when a new version is detected and must be reactivated after major updates. Plan a dated plugin inventory and a test upgrade for every release you intend to take.
Running both is sensible when hardware lifecycle and service management have different owners. For example, an illustrative team might keep Snipe-IT for laptop checkout, license seats and depreciation while GLPI handles tickets, changes and CMDB-style inventory for the service desk. The cost is duplicate data: the same device, user and license must be maintained in two systems, and each sync or manual update is a point where records drift. Decide which system is the source of record for each attribute before integration, document the sync method and owner, and confirm whether a bidirectional sync is needed or a one-way export is enough. If the split does not clearly pay for itself, one platform with the asset module configured to your lifecycle rules is usually easier to run.
Questions IT teams ask before choosing GLPI or Snipe-IT
Can GLPI replace Snipe-IT for asset tracking?
Yes for many teams, but the answer depends on what you track and who uses it. GLPI covers assets alongside tickets, problems, changes, contracts and a CMDB, so it can hold the asset register that Snipe-IT holds. Snipe-IT is narrower: it focuses on checkouts to people, licenses, accessories, consumables and components, with purchase dates for depreciation. If your main need is a clear check-out and check-in workflow, confirm that GLPI's asset workflows cover the same steps for your asset classes before you migrate. If you also need a service desk with ITIL processes, GLPI is the stronger single system.
Which platform needs less effort to run day to day?
Snipe-IT is the lighter system to operate because its scope is smaller. Its requirements are PHP 8.2 or later and below 8.6, MySQL 5.7 or later or MariaDB, and Apache with mod_rewrite or IIS with URL Rewrite, and a Docker image is available. GLPI has a broader surface: its README lists PHP 8.3 or later with MariaDB 10.11 or later or MySQL 8.0 or later, while the installation docs list PHP 8.2 or later for GLPI 11.0. GLPI updates also require backing up the database, files and config directory including glpi.key and glpicrypt.key, running php bin/console db:update, and reactivating plugins after major updates. Plan that routine as recurring work for either platform.
Do LDAP and SAML login work in both platforms?
Both support directory sign-in, but the details differ. Snipe-IT's LDAP sync imports and updates users from LDAP or Active Directory, lets users sign in with LDAP credentials and falls back to local accounts. Its SAML login is documented for identity providers including Entra ID, Google Workspace, Okta, OneLogin, JumpCloud, Shibboleth and Authentik. GLPI's user documentation describes authentication against the internal database, LDAP directories, IMAP mail servers and external methods such as REMOTE_USER, tried in that order. Confirm SAML support and the exact provider settings for GLPI in your version, and test group mapping and fallback accounts in a staging instance before go-live.
What does a migration need from the internal team?
A migration needs an owner who can define the data model before any import starts. Your team should export and clean asset records, user and location lists, license counts and supplier data, then decide how serial numbers, models, statuses and check-out history map between the two systems. GLPI's asset model is broader, so some Snipe-IT fields will map to different GLPI item types or custom fields. Budget internal time for reviewing mapped records, reconciling counts with finance and training the people who will check assets out. Ask any outside partner to write the field mapping and the acceptance checks into the scope before work begins.
Can our own team run this without outside help?
Often yes for Snipe-IT and for a GLPI deployment with a small scope, provided the team has Linux, web server, PHP and database skills and a tested backup routine. The harder parts are integration and change control: LDAP and SAML configuration, network discovery, reporting and upgrades of GLPI with plugins. If you lack those skills in-house, or the platform must meet an internal control baseline, outside help can cover the set-up, hardening, documentation and upgrade runbook under a fixed-scope agreement. DeployOpen plans, implements, hardens, backs up, upgrades, documents and supports self-hosted platforms inside your own infrastructure, and ongoing support is available as a retainer.
What does a consultant quote depend on?
A quote follows from the written scope, so the inputs that move it are the ones to define first. Ask for the number of asset classes and records to migrate, the identity integrations (LDAP, SAML and any plugins), whether GLPI's helpdesk, discovery or agent-based inventory is in scope, the hosting target and backup requirements, the training and documentation deliverables, and the upgrade support period. DeployOpen does not publish a price list and does not estimate fees in advance. Ask for a quote that lists each deliverable, what the client must provide, and which items are one-time versus recurring.
Do GLPI and Snipe-IT both carry AGPL or GPL licenses that affect us?
Snipe-IT is licensed under AGPL-3.0, and GLPI is distributed under the GNU General Public License version 3. Both are free to self-host, and the obligations depend on how you modify and distribute them and whether you offer modified versions to users over a network. Snipe-IT's pricing page says the self-hosted software is and always will be free, with hosted plans from $399.99 per year that add email support, automated upgrades and server maintenance. GLPI's paid route is a Teclib' GLPI Network subscription, which adds level 3 support and Network-only marketplace plugins. Have your legal or procurement team confirm the license terms against your planned use before you deploy.
How DeployOpen helps teams choose, implement or migrate
DeployOpen is a Chainscore Labs company that plans, implements, integrates, hardens, backs up and documents self-hosted open-source platforms inside the client's own infrastructure. For GLPI vs Snipe-IT, the work starts with a written scope that settles whether the team needs full ITSM, focused asset tracking, or both.
How we scope
- Confirm whether the team needs ITIL tickets, changes and problems, or asset tracking alone.
- Inventory the license, consumable and accessory records that must move into the new system.
- Agree which LDAP or SAML identity provider will handle sign-in for each platform.
- Define hosting, database and web server requirements for the environment before any build starts.
How we build
- Install the chosen platform on your infrastructure with the database and web server stack you approve.
- Configure LDAP or SAML login, user sync and fallback accounts against your directory.
- Set up inventory collection, including the GLPI Agent for GLPI, or import and sync data for Snipe-IT.
- Test the API calls and integrations your reporting and ticketing workflows depend on.
How we hand over
- Document the configuration, data mapping, admin tasks and backup and update procedures in writing.
- Provide a tested backup and restore procedure covering the database, files and encryption keys.
- Walk administrators through asset, license and ticket workflows so the team can run the system.
- Deliver a record of decisions on where each asset and ticket type lives after go-live.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers after handover.
- Plan upgrade windows for GLPI and Snipe-IT releases, including plugin checks where they apply.
- Keep a running change log so future upgrades and audits can trace each configuration decision.
- Confirm support boundaries and response expectations in the written scope before work starts.
