Building Your Own Library of Reusable Components in Iguana

One of the biggest advantages of using Iguana is how quickly your development process accelerates once you start reusing components. After you build a few interfaces, you begin to notice familiar patterns. Most integrations follow a similar structure, and once you have good components for each part, you can remix them for new clinics or customers with very little effort.

This post covers how reusable components work in Iguana, how collections help you organize them, and how the built in iNTERFACEWARE Collections give you a starting point before you create your own.

The pattern behind almost every integration

Almost any healthcare integration can be broken down into three parts:

1. A source component
Listens for incoming data. Examples include LLP listeners, file readers, SFTP, APIs, and database queries.

2. A mapping component
Handles data validation, transformation, routing, normalization, and business logic.

3. A destination component
Sends the processed data to another system, such as an EHR, API endpoint, or another Iguana instance.

Once you build reliable versions of these pieces, you can reuse them repeatedly.

iNTERFACEWARE Collections: Our built-in, reusable components

Because most integrations rely on recognizable patterns, Iguana ships with two built in Git Collections from iNTERFACEWARE that already cover many common source, mapping, and destination scenarios. These collections give you ready made building blocks for the type of work you will encounter most often.

HL7 Collection
This collection actually goes far beyond HL7 itself. It includes adapters, creators, parsers, protocol handlers, and mapping tools covering a wide range of healthcare workflows.
Examples include Athenahealth and eCW adapters, Epic FHIR tools, CDA creators, FHIR resource builders, X12 parsing, LLP listeners and senders, HL7 to database workflows, mapping utilities, simulators, and more.

Core Collection
A collection of general purpose components and utilities for handling protocols, data formats, file operations, and common integration patterns.

These collections allow you to begin building integrations immediately instead of starting with a blank slate. You can import any component, modify it, or use it as inspiration for your own versions.

Creating your own reusable components

As your team builds more interfaces, you'll naturally develop components that become reusable across projects. Even with the built-in iNTERFACEWARE Collections, teams often create their own standardized patterns tailored to their workflows. Common examples include:

• Customized LLP listener patterns for HL7 v2 feeds

• Shared ADT-to-JSON mapping scripts

• Demographic normalization routines

• FHIR resource builders aligned to internal profiles

• File polling components with retry and archival logic

• Destination wrappers for partner-specific APIs

When these components are placed into your own collection, they turn into repeatable building blocks. Instead of rebuilding connection logic, validation, or mapping logic every time, you drop in the component and tweak only what is unique.

Git integration: How your library stays synchronized

Iguana includes native Git support directly inside the translator. This lets you:

• Commit changes to individual components

• Track a full history of your mapping logic

• Push updates to a shared repository

• Pull improved components into future projects

This makes collaboration simple. When a developer improves a mapping script or connection pattern, it becomes available to the entire team.

Git turns your component library into a living resource that grows stronger over time.

Creating your own Iguana collections

When you want to organize your reusable components into a structured library, Iguana lets you create your own custom collections and store them in Git. A collection can contain components, shared libraries, and any supporting scripts your team commonly uses.

You can create custom collections following the guide in our help documentation.

Teams typically create collections for:

• Standard clinic onboarding workflows

• Base HL7 to JSON conversions

• Vendor specific workflows

• Common validation and routing patterns

• Internal best practices or shared utilities

Collections make it easy to package a complete integration pattern and import it into a new Iguana instance with just a few clicks.

The long term payoff

Building a reusable component library pays dividends over time. You will notice benefits such as:

• Faster delivery of new integrations

• Consistent design across customers and sites

• Less time spent rebuilding the same logic

• Easier debugging due to familiar component behavior

• Smoother onboarding for new developers

• Continuous improvement through shared Git updates

A mature component library becomes one of your strongest assets. It reduces repetitive work, preserves institutional knowledge, and gives your team a reliable toolkit to build integrations efficiently.