In an era where digital systems span cloud, on-premise, and hybrid ecosystems, the pressure on IT teams to deliver seamless, reliable, and scalable integrations has never been higher. It’s not enough to just connect data sources — the real challenge lies in transforming that data to meet the structure, logic, and context required by each connected system.

This is where ZigiOps Expressions come in. Designed to provide fine-grained control over data formatting, transformation, and filtering — all without writing code — expressions are one of the most powerful features in ZigiOps’ integration toolkit.

What Are Expressions in Integrations and Why Do They Matter?

In IT integrations, "expressions" refer to dynamic logic statements that define how data should be filtered, transformed, or conditionally manipulated between systems. They’re a no-code abstraction of script logic — providing powerful data-handling capabilities without requiring a developer's touch.

Expressions matter because systems across the enterprise ecosystem almost always differ in:

• Data structure (arrays vs. objects)

• Field naming conventions

• Value formats (timestamps, text casing, enums)

• Business logic for when data should be updated, ignored, masked, or rerouted

An agile, no-code data integration platform like ZigiOps uses expressions to ensure that data flowing from source to target is valid, clean, secure, and contextually correct — whether you’re syncing incidents from ServiceNow to Jira, sending alerts from Dynatrace to OpsBridge, or replicating assets across CMDBs.

Why They're Crucial in Modern Integrations:

• Avoid Data Breakage: Prevent mismatches and failed writes due to schema misalignment

• Support Data Governance: Enforce masking, normalization, or time-based rules

• Reduce Noise: Avoid syncing irrelevant or duplicate data

• Enable Context-Aware Integrations: Make decisions based on field values or states

‍

In short, expressions let you build smart integrations instead of dumb pipelines.

Expressions in ZigiOps: A Practical and Visual Approach

Unlike scripting-heavy iPaaS tools, ZigiOps provides a fully visual environment for working with expressions. You define logic by selecting from predefined transformation types and inserting simple parameters — no scripting, just declarative configuration.

ZigiOps expressions are built directly into the Source and Target tabs, which define where data comes from, how it’s processed, and how it’s delivered.

Let’s break down the expression-driven features starting with the Source tab.

Source Tab: Controlling What Data Gets In

The Source tab is the entry point for any integration action in ZigiOps. It defines the system you're pulling data from, the types of records you're collecting, and the logic for how that data is selected, enriched, or filtered.

Source vs. Target Tabs

The Source tab defines how and what data is collected from the source system, while the Target tab manages how that data is delivered to the destination system.

This division of responsibility enforces clean data flow logic, reduces mapping complexity, and enables more scalable, modular integration design.

Filter Section

The Filter section allows users to define conditions for what data gets collected. The most common filter is based on time — e.g., collecting only newly created or recently updated records using timestamp logic.

For example:
created_date > {lasttime}

This ensures that you’re not fetching the entire data set on every run. It significantly reduces load on source systems, improves performance, and enables near-real-time sync behavior when paired with polling actions.

Related Filters

Related Filters allow you to fetch child or associated records alongside the main object. Typical use cases include fetching comments, attachments, or sub-tasks linked to a primary incident or change request.

For example:
Sync all incident records with any new comments or attachments added since the last sync.

Related filters are essential in workflows that involve user interaction tracking, audit trails, or context-rich updates. They help avoid fragmented data states across systems.

Expressions Section

Expressions in the Source tab allow you to modify the data after it has been retrieved but before it’s passed to the target system. These transformations can be reused in mappings and filters and allow for precise, granular control over the content and format of each record.

This is where real power and flexibility come in: you’re not just syncing raw data — you’re preparing it for purpose-specific use in the next system.

ZigiOps Expression Types: Technical Breakdown and Use Cases

ZigiOps expressions allow users to shape and manage data with precision during integrations — all in a no-code, visual environment. Each expression type serves a distinct purpose, helping you ensure data accuracy, compliance, and usability across connected systems.

Pattern (Regex Extraction)

What it does: Extracts specific values from unstructured text using regular expressions.

Why it's useful: Many data sources include complex or messy strings like log messages or alerts. When only part of the data (such as an IP address, user ID, or token) is relevant for the integration, regex lets you isolate exactly what you need.

NB! Feel free to read more on this subject in our detailed article.

Use Case: You need to pull out all IP addresses from a log description to route incidents by source system.

Example:
Extract all IPv4 addresses from a description field

• Source: {description}

• Pattern: \b(?:\d{1,3}\.){3}\d{1,3}\b
  → Captures only the IPs for further processing, filtering out unnecessary noise.

Extract from Array

What it does: Selects a specific item from an array based on its index (starting from 0).

Why it's useful: Tools like Jira, Zendesk, or GitHub often store multiple values in a single array field. If the target system expects only one value, or you want to prioritize a particular entry, this expression helps extract just what’s needed.

Use Case: Syncing Jira issues, where you only want to transfer the first label assigned to an issue.

Example:
Get the first label from the array

• Source: {labels}

• Index: 0
  → Ensures consistency when only one tag should be passed downstream.

Build Array

What it does: Combines two or more separate scalar fields into a single array structure.

Why it's useful: Some target systems require array-type fields, even if the original data comes in separate values. This helps format the data appropriately for downstream consumption.

Use Case: You want to populate a tags field using the values of both the category and impact fields.

Example:
Build an array from multiple inputs

• Source Fields: {category}, {impact}

• Separator: ,
  → Resulting array might look like: ["network", "high"].

To Lower Case / To Upper Case

What it does: Converts text values entirely to lowercase or uppercase.

Why it's useful: Case mismatches between systems (e.g., usernames, email addresses, or identifiers) can cause integration failures or inconsistencies. Normalizing text ensures clean comparisons and reliable mappings.

Use Case: Standardize usernames before passing them to a downstream system that requires lowercase formats.

Example:
Convert email to lowercase

• Source: {user_email}
  → Transforms "John.Doe@Example.com" into "john.doe@example.com" for consistency.

First N Characters / Last N Characters

What it does: Truncates a string to include only the first or last N characters.

Why it's useful: Some fields in target systems have character limits, or you may only need part of a longer string (such as a prefix, suffix, or code).

Use Case: Shorten a long error message so it fits within a 100-character field in the target system.

Example:
Send only the beginning of a message

• Source: {error_message}

• First 100 Characters
  → Ensures compatibility with target field limits and improves readability.

Replace Text

What it does: Replaces one specific substring with another.

Why it's useful: Helps clean up or sanitize data, replace known tokens or names, or align text with target system conventions.

Use Case: An internal comment contains an employee name that needs to be anonymized before being sent to a customer-facing tool.

Example:
Replace sensitive name with generic label

• Source: {comment}

• Replace: "John Doe"

• With: "Customer"
  → Ensures privacy compliance and professional tone in external communications.

Replace Pattern (Regex)

What it does: Finds and replaces all substrings that match a regular expression pattern.

Why it's useful: Powerful for redacting or cleaning sensitive information such as IP addresses, email addresses, or credentials embedded in logs.

Use Case: Sanitize logs before sending them to a system with strict compliance rules by masking all IPs.

Example:
Mask all IP addresses in a field

• Source: {log_details}

• Pattern: \b(?:\d{1,3}\.){3}\d{1,3}\b

• Replace With: xxx.xxx.xxx.xxx
  → Ensures that no sensitive network information is exposed during data transfer.

Date and Time Format

What it does: Converts a timestamp into a desired date/time format, including time zone or locale adjustments.

Why it's useful: Timestamps are often unreadable or inconsistently formatted across systems. This expression ensures clarity and formatting compatibility.

Use Case: Reformat a created date for human-friendly display in a comment or notification.

Example:
Format a creation timestamp

• Source: {created_on}

• Format: MM/dd/yyyy HH:mm:ss
  → Transforms "2025-07-03T14:22:00Z" into "07/03/2025 14:22:00".

Last Time

What it does: Records and updates the timestamp of the last successful integration run.

Why it's useful: Essential for incremental data syncs — helps ensure that only newly created or updated records are pulled on the next run, reducing API load and avoiding duplicates.

Use Case: Polling ServiceNow for new incidents every 15 minutes. You want to retrieve only records created since the last successful sync.

Example:
Filter records using last sync time

• Expression Name: {last_created_time}

• Filter: created_date > {last_created_time}
  → This logic ensures near real-time data sync without overloading the source system or repeating previous data.

NB! Check our detailed guide on ZigiOps Last Time expression and how to use them.

Target Tab: Structuring the Output

The Target tab defines how data collected from the source is structured, mapped, and delivered to the destination system. This is where field values are set — either directly from source fields, or from expressions.

Field Map Overview

Field mappings define the relationships between source data and target fields. You can use direct values, expressions, or hardcoded strings.

Examples:

• summary = {short_description}

• summary = {number}: {short_description}

• priority = 3 (hardcoded)

ZigiOps also supports nested and reference mappings — useful when dealing with complex fields like assignees, related objects, or nested JSONs.

Conditional Mappings

Conditional logic lets you map different values based on the state of a field. Ideal for aligning lifecycle states or for fields that only apply in specific scenarios.

Use Case:
Map states across tools:

java

CopyEdit

if status = "To Do" → 1  

if status = "In Progress" → 2  

if status = "Resolved" → 3  

Or:
Only map resolution notes if status = Resolved

Action Control (Reference Mapping Behavior)

Specify whether a reference field should link to an existing object (“Set”) or create a new one (“Create”).

Use Case:

• Set → Assign an existing group/user

• Create → Add a new comment or attachment to the target object

Respond Field Map: Closing the Loop

In bidirectional integrations, it’s often necessary to report back to the source system after an action completes. That’s what Respond Field Maps do — they allow values from the target system to be written back to the source system.

Respond Field Maps let you write back confirmation, URLs, or status data once the target system processes an action.

Example:
After Jira issue creation, update the ServiceNow incident with a comment like:
"Jira issue created: https://jira.com/browse/XYZ-123"

This ensures end-to-end visibility and audit trails for integrated workflows.

Best Practices and Operational Recommendations

Expressions in ZigiOps are essential tools that enable powerful, fine-grained control over data transformation, filtering, and mapping between systems. When used correctly, they help IT teams automate complex integration workflows with precision and efficiency. However, improper or inconsistent use can result in failed syncs, duplicated data, or business rule violations. This section outlines recommended best practices and key pitfalls to avoid, providing guidance for building reliable, scalable integrations with ZigiOps.

Best Practices

• Use “Last Time” expressions to avoid data duplication
  Incorporating the “Last Time” pattern in filters ensures that only new or updated records are retrieved from the source system. This is especially important in recurring or scheduled integrations, where reprocessing historical data could lead to duplication, unnecessary API calls, or target system errors. The “Last Time” value updates dynamically after each successful action execution, providing a robust mechanism for incremental data collection.

• Reuse expressions wherever possible for consistency and maintainability
  Centralizing commonly used expressions—such as date format conversions, masking patterns, or array manipulation—simplifies maintenance and enhances consistency across multiple actions. If the same transformation is needed in several field mappings, referencing a shared expression helps ensure that any updates propagate uniformly across integrations.

• Document complex patterns and logic for team transparency
  Regex expressions and advanced transformations can be difficult to interpret at a glance. To improve team collaboration and reduce onboarding time, maintain internal documentation that explains the purpose, logic, and expected behavior of key expressions. This becomes critical during troubleshooting or when expressions must be updated in response to system changes.

• Validate new expressions in test or staging environments
  Always test the impact of new or updated expressions in a non-production context before deploying them live. This helps prevent data integrity issues, especially in high-traffic systems or critical integrations. By verifying that expressions produce the expected output in controlled test scenarios, teams reduce the risk of data corruption or logic faults in production environments.

‍

Pitfalls to Avoid

• Neglecting to assign expression outputs in mappings
  Creating an expression alone does not apply its logic. It must be explicitly referenced in a field mapping or respond mapping to influence data transfer. Forgetting to assign the output leads to unchanged or empty target values and can result in missed data or failed integrations.

• Overly broad regex patterns that extract unintended data
  Regular expressions that lack precision—such as those using greedy quantifiers like .*—can match more than intended, corrupting data or extracting irrelevant content. To ensure accurate transformations, constrain patterns using anchors (^, $), word boundaries (\b), and non-greedy modifiers (*?) where appropriate.

• Improper handling of array indexes in dynamic fields
  When working with the "Extract from Array" expression, it’s crucial to remember that indexing begins at 0. Using the wrong index can pull incorrect values or cause runtime errors. In addition, if the array content varies dynamically across records, the expression logic must be resilient to changes in order and length.

• Hardcoding values where conditional logic is more appropriate
  Using static, hardcoded values in mappings may work in simple cases, but this approach limits adaptability and creates brittle integrations. Conditional mappings allow fields to be populated dynamically based on source data conditions, enabling integrations to adapt to different record states or data contexts more intelligently.

Final Thoughts: Integrations With Intelligence, Not Just Connectivity

ZigiOps Expressions aren’t just a feature — they represent a philosophical shift in how integrations are built. Rather than just wiring APIs together, ZigiOps encourages IT teams to design intelligent, resilient, and context-aware data flows.

Expressions empower teams to:

• Align schema mismatches

• Automate decision logic

• Enforce business rules

• Protect data integrity

And all of this, with zero custom code.

In the hands of the right team, ZigiOps Expressions can replace hundreds of lines of brittle script logic — with reusable, maintainable, visually configurable components.

Book a demo with our tech experts or simply start your free trial and upscale your IT performance.