Integrating Custom Systems with ServiceNow: 4 Patterns Beyond Out-of-the-Box Spokes
Last updated: November 2026
ServiceNow integrates well with popular platforms through IntegrationHub spokes and the Store, but custom, internally built and legacy systems usually need a different approach. There are four main patterns for connecting them: REST or SOAP integration built on ServiceNow's own tools, MID Server and database-based integration, third-party connectors, and no-code integration platforms. This article explains how each pattern works, when to use it, and the trade-offs in effort, maintenance and security. It uses ZigiOps as an example of a no-code platform that can connect ServiceNow with systems that have no API.
ServiceNow is the system of record for IT service management in many enterprises. Incidents, problems, changes, requests and configuration items all flow through it. For ServiceNow to deliver its full value, it needs data from the rest of the IT landscape, and the rest of the landscape needs data from ServiceNow.
For widely used systems, this is relatively easy. IntegrationHub offers spokes for many popular platforms, and the ServiceNow Store includes many certified integrations. The challenge begins when the system on the other side is not popular, not commercial or not modern: an internally built request portal, a legacy asset database, a regional ERP or an industry-specific tool.
Why custom systems are a special case for ServiceNow
- No spoke exists. IntegrationHub spokes cover commercial products, not your internal applications.
- Interfaces vary. Custom systems may expose REST, SOAP, a database or only file exports.
- Data models differ. Custom systems rarely align with ServiceNow tables such as incident, cmdb_ci or sc_req_item.
- Bi-directional requirements. Many scenarios need updates in both directions, not just data pulled into ServiceNow.
- Network location. Custom systems are often on-premises, behind firewalls, while ServiceNow runs in the cloud.
Pattern 1: Build with ServiceNow's native integration tools
ServiceNow provides several tools for building custom integrations directly on the platform:
- REST and SOAP messages for outbound calls to external systems.
- Scripted REST APIs for exposing custom endpoints that external systems can call.
- IntegrationHub with the REST, SOAP and JDBC steps, plus Flow Designer for orchestration.
- Import sets and transform maps for loading data into tables.
- Business rules and scripts to trigger outbound updates.
When it fits: you have experienced ServiceNow developers, the custom system has a usable API, and the integration logic is moderate.
Trade-offs: integration logic lives inside ServiceNow as code and configuration, which must be maintained through upgrades. Some IntegrationHub capabilities require additional subscriptions. Bi-directional sync with loop prevention and correlation must be designed manually.
Pattern 2: MID Server and database integration
For on-premises custom systems, the ServiceNow MID Server acts as a bridge between the cloud instance and the internal network. Combined with JDBC data sources or JDBC steps, it can read from and write to databases of internal systems.
When it fits: the custom system is database-centric, sits on-premises and has no API.
Trade-offs: MID Servers must be installed, secured and maintained. Writing directly to an internal system's database can bypass its business logic, so staging tables or stored procedures are preferable. Complex bi-directional logic still needs scripting.
Pattern 3: Third-party or Store connectors
Some custom-adjacent systems, such as older versions of commercial products or niche software, may have connectors available from third parties or the ServiceNow Store.
When it fits: a connector exists for your exact system and version.
Trade-offs: coverage for truly custom systems is rare. Quality, support and depth vary by vendor, and each connector may follow a different approach to security and configuration.
Pattern 4: No-code integration platforms
External no-code integration platforms connect ServiceNow with other systems through configurable templates and mappings, running outside the ServiceNow instance. Some of these platforms also support custom systems through multiple connection methods.
When it fits: you need bi-directional sync, want to keep integration logic outside the ServiceNow instance, or need to connect systems without APIs.
Trade-offs: an additional platform to license and operate. The value depends on how well the platform supports your specific custom systems.
ZigiOps is an example of this pattern. It integrates ServiceNow with ITSM, DevOps, monitoring, CRM and cloud tools, and it can connect custom systems through an API, SOAP, a database or a library. That means a custom system does not need an API to be synchronized with ServiceNow. New connectors are typically built in about three days and then configured without code.
| Pattern | Requires API on custom system | Bi-directional sync | Skills needed | Where logic lives |
|---|---|---|---|---|
| Native ServiceNow tools | Usually yes | Possible, custom-built | ServiceNow developers | Inside the instance |
| MID Server and database | No | Possible, scripted | ServiceNow developers and DBAs | Inside the instance and MID Server |
| Third-party connectors | Depends on connector | Varies | Administrators | Varies |
| No-code integration platform | Not necessarily | Built in | Administrators | Outside the instance |
How to choose the right pattern
- Check the custom system's interfaces. An API makes Pattern 1 viable; database-only access points to Pattern 2 or 4.
- Define the direction. One-way imports are simple; bi-directional sync with comments and status favors Pattern 4.
- Consider instance health. Large amounts of integration scripting inside ServiceNow can complicate upgrades and instance performance.
- Assess skills and capacity. ServiceNow developers are in high demand. If capacity is limited, no-code options free them for platform work.
- Count the systems. One custom integration may be fine natively; ten custom integrations benefit from a consistent platform approach.
Key design decisions for any pattern
Target tables
Decide which ServiceNow tables custom system data should populate: incidents, requests, configuration items, changes or custom tables. Avoid creating custom tables when standard ones fit, as they affect licensing and reporting.
Correlation
Store the custom system's record ID in ServiceNow, and the ServiceNow sys_id or number in the custom system where possible. Correlation is essential for updates and bi-directional sync.
Field and status mapping
Map statuses, priorities, categories and assignment groups explicitly. Custom systems often have simpler or different lifecycles than ServiceNow.
Identity and assignment
Users in the custom system may not exist in ServiceNow, or may be identified differently. Decide how callers, assignees and requesters are matched.
Security
Use a dedicated integration user in ServiceNow with only the roles required, OAuth where available, and least-privilege access on the custom system side. Check whether your integration layer stores data; ZigiOps, for example, does not store the data it transfers.
Example: an internal request portal and ServiceNow
A company runs an internally built portal for facility and equipment requests, backed by a SQL database. IT-related requests should be handled in ServiceNow, while requesters continue to track progress in the portal.
- New IT requests in the portal database create requested items in ServiceNow.
- The ServiceNow number is written back to a staging table that the portal reads.
- Status changes and public comments in ServiceNow update the portal through the staging table.
- Requester comments in the portal are added to the ServiceNow record.
- When the item is closed in ServiceNow, the portal request closes automatically.
This flow can be built with any of the patterns, but the effort varies significantly. With MID Server and scripting, it requires ServiceNow development and database work. With a no-code platform such as ZigiOps, it is configured through mapping and conditions once the database connector is in place.
Common use cases for custom system integration with ServiceNow
- Internal monitoring to incidents. Home-grown health checks or batch job logs create and update ServiceNow incidents.
- Legacy asset databases to the CMDB. Assets and relationships from older tools populate configuration items, keeping the CMDB complete.
- Internal change portals to change management. Changes planned in an older approval tool are mirrored as ServiceNow change requests during a transition period.
- Industry systems to service requests. Operational requests from specialized applications become catalog items or tasks in ServiceNow.
- Internal development trackers to problem management. Defects tracked in an in-house tool are linked to ServiceNow problems so root cause and fix status are visible.
- Customer entitlement systems to case management. Contract and entitlement data from internal systems enriches cases and incidents.
Mapping custom data to ServiceNow tables
The mapping between a custom system and ServiceNow decides whether integrated data is useful in practice. The example below shows how fields from an internally built maintenance system might map to the ServiceNow incident table.
| Custom system field | ServiceNow field | Notes |
|---|---|---|
| Ticket ID | Correlation ID | Used to match records for updates |
| Title | Short description | Truncate if longer than the field limit |
| Details | Description | Plain text; strip formatting if needed |
| Equipment code | Configuration item | Lookup against the CMDB by asset tag |
| Severity (1 to 3) | Impact and urgency | Mapped through a table so priority is calculated by ServiceNow |
| Site | Location and assignment group | Site determines the local support group |
| Status | State | Custom statuses mapped to New, In Progress, On Hold, Resolved |
Letting ServiceNow calculate priority from impact and urgency, rather than writing priority directly, keeps the integration aligned with the organization's priority matrix and SLA definitions.
Testing and go-live checklist
- Test with realistic data volumes, not only a handful of records.
- Verify correlation by updating records on both sides and confirming the right counterpart changes.
- Test every status transition and confirm that mappings behave as expected.
- Simulate failures, such as the custom system being unavailable, and confirm retries and alerts work.
- Confirm that the integration user cannot access data beyond what is required.
- Check that comments, attachments and work notes respect visibility rules, so internal notes are not exposed.
- Document mappings, owners and escalation paths before go-live.
- Plan a hypercare period with daily log reviews for the first weeks.
Keeping integrations healthy through ServiceNow upgrades
ServiceNow releases two major family versions each year. Each upgrade can affect custom scripts, scoped applications and integration behavior. Integrations built with heavy in-instance scripting need regression testing every time. Integrations that run outside the instance and use standard ServiceNow APIs are generally less affected, although they should still be tested in a sub-production instance before each upgrade.
Whichever pattern you use, keep a list of integration-related artifacts in the instance, such as integration users, REST messages, scripted APIs, MID Server configurations and business rules, so upgrade testing can cover them systematically.
Frequently asked questions
Can ServiceNow integrate with systems that have no API?
Yes. Options include MID Server with JDBC for databases, SOAP messages, file imports and external integration platforms that support database, SOAP and library connectivity.
What is a ServiceNow spoke?
A spoke is a packaged set of IntegrationHub actions for a specific external system, used in Flow Designer to build integrations without writing full scripts.
Do I need IntegrationHub to integrate custom systems?
Not necessarily. ServiceNow's REST and SOAP messages, scripted REST APIs and import sets can be used without IntegrationHub, and external integration platforms connect through ServiceNow's APIs.
How do I keep custom integrations from slowing ServiceNow upgrades?
Minimize custom scripts inside the instance, document integrations, use standard tables and consider moving complex integration logic to an external platform.
What is the role of the MID Server in integrations?
The MID Server is a Java application installed inside the customer's network that lets a cloud ServiceNow instance communicate securely with on-premises systems.
Can ZigiOps integrate ServiceNow with internally built systems?
Yes. ZigiOps connects ServiceNow with internal systems through APIs, SOAP, databases or libraries, with no-code configuration and bi-directional synchronization.
Should custom system data go into standard or custom ServiceNow tables?
Use standard tables such as incident, sc_req_item, change_request or cmdb_ci whenever they fit. Standard tables work with existing reports, SLAs and workflows, and custom tables may have licensing implications.
Key takeaways
- IntegrationHub spokes cover popular products, not custom or internally built systems.
- Four patterns exist: native ServiceNow tools, MID Server and database, third-party connectors and no-code platforms.
- Choose based on the custom system's interfaces, sync direction, instance health, skills and number of integrations.
- Correlation, mapping, identity and security decisions apply to every pattern.
- Map custom data to standard ServiceNow tables and let the platform calculate priority from impact and urgency.
- ZigiOps connects ServiceNow with custom systems, even without an API, while keeping integration logic outside the instance.
