Extract, Transform, Load (ETL): The Core of Integration

To integrate two systems successfully, data needs to be transferred between them. This process is executed through ETL — Extract, Transform, and Load, which represents the three fundamental phases of any integration:

• Extract: Retrieving data from the source system.

• Transform: Modifying or converting the data to a format compatible with the target system.

• Load: Sending the data to the target system.

The Transform phase is typically more technical, involving format translation (e.g., converting JSON to XML) and structural adjustments to ensure compatibility between the two systems.

In ZigiOps, all transformations are handled behind the scenes. Users are not required to manually manage or configure them. Therefore, the UI focuses primarily on the Extract and Load stages, where users define what data to pull and where to send it.

ETL in Practice with ZigiOps

Once you configure the systems and entities you want to integrate, each operation in ZigiOps includes:

• Source Tab: Represents the Extract phase — defines what data is collected and under what conditions.

• Field Map Tab: Represents the Load phase — defines what data is sent to which fields in the target system.

What Is Field Mapping?

Field mapping is the process of defining how data from the source system is transferred and adapted to the target system. It ensures that:

• Each piece of data is mapped to its correct destination field.

• Required fields in the target system receive appropriate values.

• Data types and formats align across systems.

Example:

If you're transferring a Jira task to ServiceNow as an incident, you might map:

• Jira "Summary" → ServiceNow "Short Description"

Types of Field Mapping in ZigiOps

1. Simple Field Mapping

One source field → One target field.

This can include:

• Direct mapping (value comes from the source system)

• Hardcoded values (defined in ZigiOps)

• Combination of both

Example:
To form a Jira ticket URL in a ServiceNow comment, you might:

• Take the base Jira URL (configured in ZigiOps)

• Append /browse/ (hardcoded)

• Add the ticket key (from Jira)

2. Conditional Field Mapping

When the source and target systems use different value representations (e.g., statuses or priorities), conditional mapping ensures proper translation.

Example – Status Field Mapping:

In ServiceNow:

• "New" = state = 1

• "In Progress" = state = 2

• "Resolved" = state = 6

In Jira:

• "To Do", "In Progress", "Done"

ZigiOps Conditional Mapping Example:

• If {state} == 1, send "To Do"

• If {state} == 2, send "In Progress"

• If {state} == 6, send "Done"

Without conditional mapping, mismatched values may cause integration failures — for instance, Jira rejecting an unrecognized status value like 2.

3. Advanced Field Mapping

Some integrations require combining values, setting multiple fields conditionally, or sending system-specific mandatory fields.

Example – Closing an Incident in ServiceNow:
When a Jira ticket is marked "Done", ServiceNow also needs:

• close_code (e.g., "Resolved by Caller")

• close_note (e.g., "Closed by Jira")

Conditional logic in ZigiOps ensures these fields are only populated when the status is "Done", avoiding invalid updates.

4. Multi-Field Logic (Example: Priority)

In Cherwell, priority is derived from Impact and Urgency, while Jira has only a single Priority field.

ZigiOps Solution:

• If Impact = Production AND Urgency = Critical → Jira Priority = Highest

• If Impact = Production AND Urgency = Medium → Jira Priority = High

• If Impact = Test AND Urgency = Critical → Jira Priority = Low

This enables accurate translation of complex value combinations between systems.

Conditional Mapping Sets

Soon, ZigiOps will introduce conditional mapping groups:

• Entire mappings will be triggered based on specific conditions.

• This allows drastically more flexible and dynamic integration logic — ideal for enterprise-grade use cases.

Common Mistakes in Field Mapping

1. Missing Required Fields
   Forgetting to map or provide values for mandatory fields in the target system (e.g., "Summary" in Jira).

2. Invalid Fields
   Mapping to fields that don't exist in the target system.

3. Incorrect Values
   Providing incompatible values (e.g., sending a string when a number is required).

ZigiOps helps avoid these errors by:

• Highlighting required fields

• Providing field suggestions

• Validating mappings based on system requirements

Conclusion

Field mapping is the backbone of successful integrations. It's essential to plan carefully, understand both systems' requirements, and use the right combination of direct, hardcoded, and conditional mappings.

ZigiOps makes this easier by:

• Automating technical transformations

• Providing intuitive UI for Extract and Load

• Offering pre-configured templates and validations

• Supporting advanced, condition-driven logic

If you’d like to see how this applies to your specific use case, book a technical demo with our team. We’ll help you configure a robust, accurate, and scalable integration flow tailored to your needs.

Or give it a try via the ZigiOps Free Trial option.