Every ServiceNow release brings new capabilities, but some stand out more than others. The Zurich release is one of those moments. It’s not just another incremental update; it delivers features that solve long-standing frustrations for developers, admins, and workflow designers who live inside the platform every day.

For teams responsible for automation, app development, and integrations, ServcieNow Zurich release provides both quality-of-life upgrades and brand-new functionality that aligns ServiceNow with modern software practices. Features like developer sandboxes, Build Agents, and external triggers in Flow Designer finally give ServiceNow developers tools that software engineers in other ecosystems have taken for granted for years.

Developer Sandboxes + Git: Ending the Multi-Dev Headaches

If you’ve ever worked with multiple developers on a single ServiceNow instance, you know the pain. Everyone shares the same dev environment, so changes collide constantly:

• A client script update breaks someone else’s form.

• Two people edit the same flow, and one overwrites the other’s work.

• Debugging becomes guesswork: “Was it my change, or yours, or both?”

The ServiceNow Zurich addresses this by making developer sandboxes generally available.  

“Zurich moves sandboxes from preview to general availability so every developer can build in their own isolated instance and merge via Git, avoiding conflicts.” - ServiceNow Developer Blog

What’s new in ServiceNow’s latest release?

Each developer can now spin up an isolated sandbox environment, tied to the same base development instance but separated from others. Sandboxes are integrated with Git, so devs can work on their own branches, commit changes, and merge them back into the shared dev instance.

This is a fundamental shift. Instead of fragile update sets or manual coordination, developers can adopt standard source control practices: branching, pull requests, code reviews.

How to try it?

• From your dev instance, provision a new sandbox.

• Connect it to your team’s Git repo.

• Create a new branch — e.g., feature/catalog-validation.

• Make changes (scripts, flows, forms) in your sandbox.

• Commit and push to Git.

• Merge back into the main branch when ready.

Why it matters?

• Fewer conflicts: Everyone experiments safely in isolation.

• Modern workflows: ServiceNow now aligns with Git-based practices that most developers already use.

• Faster iteration: No more waiting for someone else to finish before testing your changes.

“Developer sandboxes give each team member their own isolated environment. No more accidental overwrites. No shared-instance weirdness. Just pure focus. You make changes in your sandbox, commit to Git, and only then do your teammates see what you’ve done.”- ServiceNow Dev Sandboxes Blog

Caveats

Sandboxes are still tied to your base dev instance, so major version mismatches can cause surprises. Always test merges carefully, and make sure your Git branching strategy is agreed across the team.

Build Agents: CI/CD for ServiceNow

For years, ServiceNow deployments relied on update sets. While they worked, they were fragile, hard to track, and didn’t fit well into modern DevOps practices.

Zurich changes the game with Build Agents — external services that manage builds, tests, and deployments in a more automated, controlled way.

How it works?

Build Agents integrate ServiceNow apps and flows with CI/CD systems like Jenkins, GitHub Actions, or Azure DevOps. Instead of manually exporting and importing update sets, you configure pipelines that automatically build and deploy artifacts.

For example:

• Commit code to Git.

• CI/CD pipeline triggers a build using a Build Agent.

• The Build Agent validates and tests the app.

• If all checks pass, the app is deployed to test or prod.

Why it matters?

• Consistency: Reduces “works in dev, breaks in prod” scenarios.

• Automation: Eliminates manual promotion steps.

• Integration: Fits ServiceNow into enterprise DevOps pipelines alongside other apps.

Caveats

Build Agents are still new. They require setup and may have rough edges. Start with non-critical apps to test pipelines before applying them to business-critical workflows.

Flow Designer: External Triggers & Reusable Schedules

Flow Designer has become central to ServiceNow automation. The Zurich release makes it even more powerful by introducing new trigger options.

External triggers:

• Previously, flows were limited to internal events (record changes, schedules). The Zurich Release adds external REST/webhook triggers. You can now fire a flow in ServiceNow system when an external system sends a webhook.

Example: Nagios sends a webhook when CPU usage exceeds 90%. Flow Designer listens, enriches the alert with host metadata, and creates an incident in ITSM.

Reusable schedules:

• Instead of creating a “run nightly at 2 AM” trigger ten times for ten different flows, the Zurich Release lets you define a schedule once and reuse it everywhere. This keeps logic consistent and easier to maintain.

Saved external triggers:

• Trigger definitions (endpoint, schema, security) can now be saved and reused. This reduces duplication and ensures consistent behavior across flows.

However, the upgrade has some caveats. Here are some of them:

• Schema drift: If an external system changes its payload format, your flow may break. Keep payload versions documented.

• Domain separation: Saved triggers must be configured correctly for multi-division environments, or you risk cross-domain data leaks.

Debugging & Flow History: No More Blind Spots

One of the biggest frustrations in earlier releases was debugging flows. If a condition failed, you might get little more than “flow didn’t run.”

Additionally, ServiceNow’s Zurich release introduces detailed run history and debugging tools:

• View each execution run.

• See which conditions passed or failed.

• Trace data transformations step by step.

Let’s look at the following example so we can get a clearer picture: An onboarding flow fails because HR left the “Manager” field blank. The run history shows the condition failure immediately. Instead of hours of log digging, you know the problem in seconds.

This transparency saves developers time and builds trust with business users who often blame “ServiceNow being broken.”

H2 Conversational Flows: Automation That Feels Human

Zurich also introduces conversational subflows and actions, which let workflows engage users in natural dialogue.

Instead of static forms, a flow can now ask clarifying questions, adapt based on responses, and guide the user.

Now, picture the following scenario:

• User: “I need VPN access.”

• Flow: “Which device do you need it from?”

• User answers → flow checks policy → grants access.

For ServiceNow users, this feels far more natural. For the developers, it reduces abandoned requests and speeds resolution.

UI Builder & Mobile Enhancements

Zurich continues ServiceNow’s investment in low-code UI design.

What’s new in this part of the ServiceNow Zurich release:

• Catalog Browse component for easier service catalog layouts.

• Mobile App Builder and Mobile Card Builder are now integrated directly into Studio.

• Mobile forms support:

• Non-sequential navigation.

• Better error validation and messaging.

• Offline media uploads (photos, videos) that sync later.

One may ask - Why does it matter?

For mobile workers — field techs, nurses, delivery staff — clunky forms were a barrier to adoption. Zurich reduces those barriers by improving usability and resilience in low-connectivity scenarios.

Pro tip: Test new mobile forms in real-world conditions — low bandwidth, offline, or switching networks. That’s where the improvements really shine.

H2  Dark Mode: Because Developer Comfort Matters

It might seem small, but dark mode across dev tools was one of the most requested features. ServiceNow Developers spend hours in Studio and Flow Designer. Dark mode reduces eye strain and fatigue, making long sessions more manageable.

Heads up: If you’ve built custom widgets or UIs, test them in dark mode — not all legacy designs render correctly.

New Scoped APIs & Async Scripting

Zurich expands scripting capabilities with new scoped APIs and support for ECMAScript 2021 (ES12). Async scripting means developers can now use async/await patterns, making external API calls cleaner and non-blocking.

Here’s a sample script:

(async function() {

 let r = await new sn_ws.RESTMessageV2()

   .setEndpoint("https://api.example.com/data")

   .get();

 gs.info("Response: " + r.getBody());

})();

This unlocks modern JavaScript features and improves performance by avoiding blocking operations.

External Content Search

The ServcieNow Zurich release also extends search with external content connectors. To illustrate this, let’s look at the following scenario: An agent searches for “VPN issue.” Results now show ServiceNow KB articles and relevant documentation from Confluence or SharePoint.

This reduces context-switching, speeds up resolution, and means developers no longer need to maintain custom connectors for external content.

Process & Task Mining

Zurich strengthens process and task mining, turning operational data into actionable insights like:

• Identify bottlenecks.

• Quantify delays.

• Spot repetitive tasks ripe for automation.

A brief example: Task mining shows that 40% of onboarding tickets stall at “Laptop Provisioning.” That evidence makes it easier to justify automating asset requests.

So, instead of guessing where to automate, you act on data.  

‍

Source: ServiceNow YouTube channel

Beyond the “headline” features, Zurich also delivers improvements that are easy to overlook but highly useful:

• Now Assist: Now supports multiple LLMs (Azure OpenAI, Claude, Gemini), multilingual translation, voice input, and context-aware search.

• Performance Analyzer: Helps developers measure form load times and identify slow widgets or scripts.

• Automated Testing Framework (ATF): Gains better failure insights and a more configurable workspace for test authoring.

Together, these tools make developers more productive and applications more reliable.

Common Pitfalls & What to Watch for in the ServiceNow Zurich

• Schema drift: External payloads (like webhooks) often change without notice. Keep schemas versioned and tested.

• Domain separation: Saved external triggers must be carefully scoped, or you risk data bleeding across business units.

• Performance: Use Performance Analyzer to test mobile forms and custom UIs. Some scripts may drag in real-world conditions.

• Licensing: Not all Zurich features are available by default. Check your entitlements before planning large-scale adoption.

ZigiOps – a ServiceNow partner

Alongside ServiceNow’s own innovations, ecosystem partners like ZigiOps play a crucial role in keeping integrations reliable and future-proof. ZigiOps is a no-code integration platform and certified ServiceNow partner that connects ServiceNow with systems like Jira, Azure DevOps, Splunk, Nagios, and many others.  

A key advantage for business clients is peace of mind during ServiceNow upgrades. Whenever ServiceNow rolls out a new version — such as Zurich — ZigiOps automatically updates to support it. This ensures that all existing integrations continue to work without disruption, downtime, or costly manual fixes.

For IT teams, this means they can stay aligned with the latest ServiceNow features without the headache of rework. Instead of constantly reconfiguring integrations, they can focus on delivering value, improving service delivery, and driving innovation.

For organizations overall, the benefits are clear:

• Reduced downtime — integrations remain stable through every ServiceNow release.

• Lower costs — no need to hire consultants or rebuild connections after upgrades.

• Agility — teams can adopt new ServiceNow features immediately with confidence.

• Future readiness — IT and business leaders know their integrations will scale as ServiceNow evolves.

In short, ZigiOps ensures clients get the full value of their ServiceNow investment by keeping integrations up to date, enabling IT teams to stay ahead of change, and helping organizations accelerate their digital transformation journey.

Check out ZigiOps’ full list of ServiceNow integrations here.

Final Takeaways

The Zurich release marks a major step forward for developers and workflow builders. It enhances safety with sandboxes and debugging, accelerates delivery through Build Agents and reusable triggers, and improves the user experience with conversational flows, mobile forms, and dark mode. At the same time, it expands integration capabilities with external triggers, APIs, and content search, while process mining provides the evidence needed to make automation measurable and defensible.

Conclusion

For developers, admins, and workflow designers, Zurich is one of the most meaningful ServiceNow releases in years. It doesn’t just add features — it fixes long-standing pain points and aligns ServiceNow development with modern software practices.

If you’re upgrading, don’t just flip the switch and move on. Pilot sandboxes, test Build Agents, play with external triggers, and update your team’s standards. The more you embrace these tools, the more efficient, reliable, and enjoyable your ServiceNow development will become.

In short: Zurich is a release that respects builders. And that makes it worth exploring in depth.

Looking to connect your ServiceNow with the rest of your systems? Try ZigiOps – book a demo and start scaling your integrations