ServiceNow Integration Hub: Evaluating Low-Code Integration Patterns for Enterprise API Orchestration

Abstract

Enterprise vendors increasingly market low-code integration platforms as a faster, lower-maintenance alternative to hand-written integration code, but published, reproducible evidence directly comparing the two on the same use case, under the same real faults, is scarce. This paper reports a controlled, four-part empirical comparison of a low-code integration pattern against a hand-coded ("code-first") pattern, implementing the identical enterprise API orchestration use case -- an HR onboarding-case workflow that looks up an employee, creates a fulfillment ticket, and sends a notification -- against a real mock enterprise backend. Because this study's sandboxed evaluation environment could not reach ServiceNow's own developer-instance provisioning domains (confirmed directly: outbound connections were rejected by the environment's egress policy), the low-code pattern was implemented and run for real using Node-RED, an open-source flow-based integration runtime architecturally equivalent to ServiceNow Integration Hub's Flow Designer (declarative node/wire composition with a JavaScript escape hatch for logic the declarative nodes cannot express); ServiceNow-specific architectural claims are drawn from ServiceNow's own current product documentation, and this substitution, along with what it does and does not license, is stated explicitly rather than left implicit. Across 320 real trials against a live mock API under six real fault conditions (transient errors, heavy errors, rate limiting, slow/timeout responses, added latency, and an unknown-employee case), the two patterns achieved statistically indistinguishable overall success rates under stochastic faults (81/100 trials each, chi-square = 0.0, p = 1.0), indicating that resilience outcomes were determined by each pattern's retry budget rather than by whether the implementation was low-code or hand-coded. The patterns diverged sharply on two other axes: under real concurrent load, the hand-coded pattern sustained 2.39 times the throughput of the low-code pattern (1,211 vs. 506 requests/second) at roughly half the p99 latency; and implementing one identical, verified-correct specification change required 44 lines touched in the hand-coded implementation versus 8 added lines of escape-hatch code plus one new node and two rewired connections in the low-code flow. We also report, as a citable finding in its own right, an undocumented internal property collision discovered during harness development, in which Node-RED's built-in HTTP request node silently reserves a message field also natural to use for custom retry-counting logic, producing an infinite retry loop until diagnosed and worked around. We conclude that the choice between low-code and code-first integration patterns in this study was not a resilience trade-off but a throughput-versus-maintainability trade-off, and discuss the scope limits of a single-use-case, single-backend, architectural-proxy study.