Monday, 28 April 2025

Earning in HL7/FHIR Integration: Strategies for Freelance Consultants in 2025

Earning in HL7/FHIR Integration: Strategies for Freelance Consultants in 2025

Healthcare integration has always been a niche but vital field. As an HL7/FHIR integration engineer or healthcare IT consultant, you have specialized skills that are in steady demand. But how can you generate the best income from these skills in today’s evolving market? In this overview, we’ll explore common income models, real-world earning ranges, and how emerging trends – like AI automation and new partner programs – are changing the game. We’ll also look at how tools like HL7 Soup are enabling new revenue streams (including recurring commissions) that can compound over time.

Let’s dive into how you can stay ahead of the curve and maximize your earnings as an integration professional.

Common Income Models for HL7/FHIR Integration Professionals

Freelance HL7/FHIR specialists typically earn revenue through a few tried-and-true models. It’s important to understand each and how they fit into your business:

  • Hourly Contracts (Time & Materials): Many integration engineers work on an hourly basis, billing for each hour spent on interface development, mapping, testing, etc. This model offers flexibility – you get paid for all the time you put in, even if requirements change. Rates can vary widely based on expertise and location (more on typical rates below). Hourly contracts are common for staff augmentation roles or open-ended integration support needs.

  • Project-Based Fees (Fixed Price): In this model, you charge a flat fee for a defined integration project or deliverable. For example, a fixed price to implement an HL7 interface between a lab system and an EHR. Project fees reward efficiency – if you finish faster, you still get the full fee – but they also put the risk on you to estimate accurately. Successful project-based work requires clear scoping of HL7/FHIR interface requirements and managing scope creep. Many clients like the certainty of a fixed price for budgeting purposes.

  • Support Retainers & Managed Services: Some consultants move into a managed service role, offering ongoing support and maintenance for healthcare interfaces on a retainer basis. In a retainer model, a client pays a monthly or quarterly fee (regardless of hours) for you to be “on call” to handle interface issues, updates, or enhancements. It’s essentially an insurance or subscription for integration support. Retainer pricing means billing in advance for work to be done in the future (7 Steps to Implementing a Retainer Pricing Model - Forecast App), which smooths out your income. For example, a hospital might pay a freelance integrator $X per month to manage their HL7 feeds and ensure uptime. This provides steady recurring income, though you must be ready to respond quickly when issues arise.

Each of these models can be combined or adjusted. Some freelancers do an up-front project fee for the implementation, then transition into a smaller ongoing support retainer. The key is to diversify how you charge for your expertise so you’re not relying on any single one-off project.

The Impact of AI and Automation on HL7 Integration

Technology never stands still – and even the world of HL7 interfaces is now being affected by AI automation. Tools are emerging that can automate significant portions of integration work that consultants used to do manually. This is a double-edged sword for freelance engineers: it can reduce your billable hours on a given project, but it also opens up new opportunities to deliver value faster (and take on more projects or new revenue streams).

One of the most striking developments is the use of AI to generate or convert integration workflows. For example, HL7 Soup (a modern HL7 interface engine and toolkit) introduced an AI-powered workflow generation tool that can convert existing Mirth Connect channels into HL7 Soup configurations automatically (HL7 Soup - HL7 Interface Engine, Editor and Analysis Software). This “AI Mirth Connect Converter” essentially allows a consultant to take an interface built in another engine and have HL7 Soup’s AI recreate it within their platform. According to HL7 Soup, this is offered for free and can drastically speed up migrations: “Convert your Mirth Channels to HL7 Soup for free using AI-driven tools. Enjoy simple integration design, faster process, and secure messaging.” (HL7 Soup - HL7 Interface Engine, Editor and Analysis Software).

Consider what this means: tasks that once required hours of tedious mapping and re-coding can now be done in minutes by AI. Similarly, HL7 Soup’s Integration Host tool can use AI to quickly onboard clients by analyzing their existing interfaces and reproducing them. The company notes that AI-powered client onboarding helps transition clients from their old integration solutions to HL7 Soup, so “they save money faster, while you make it.” (HL7 Soup Partner Program). In other words, automation helps clients reduce costs (by speeding up implementation), but ensures the consultant/partner still earns income efficiently.

Beyond HL7 Soup, we’re seeing early moves by others to incorporate AI in healthcare integration – from mapping tools that auto-generate HL7 message mappings to intelligent monitoring systems that predict interface failures. This trend is only beginning. What does it mean for your income? Potentially, you may bill fewer hours for building each interface, as AI takes over repetitive tasks. However, rather than this being a loss, it can be an opportunity:

  • You can handle more projects concurrently since each is completed faster, thus increasing your throughput.

  • You can focus your time on the higher-value aspects of integration (architecture, requirements, testing, and exceptions) while letting AI handle rote code generation.

  • Instead of selling hours of labor writing transformation scripts, you might sell software or services that include these AI tools (more on recurring revenue models next).

Think of AI as a force multiplier for integrators. Just as a single expert can outperform a team of juniors (as in the quote above), an expert empowered with AI-driven tools can outperform even their past self. We’re entering an era where you might deliver the same integration project in half the time – so to avoid earning half the money, you’ll want to restructure how you charge and what value you provide. This leads to a notable shift: moving from pure “billable hours” towards productized and subscription models in integration consulting.

From Billable Hours to Recurring SaaS Revenue

If AI and automation are reducing the manual hours required, how do you keep your income strong (or even improve it)? The answer for many is to evolve your business model. Rather than only charging for the one-time build of an interface, integration freelancers are starting to package their services in ways that generate recurring revenue – often by leveraging software-as-a-service (SaaS) platforms.

Consider this scenario: In the past, you might spend 50 hours building a custom HL7 feed and charge hourly for that work. Now, with AI assistance, you might accomplish it in 10 hours. You could simply charge 10 hours and move on (earning less on that project), or you could wrap the integration into a subscription service for your client. For instance, you host or manage the interface using a cloud integration engine and charge the client a monthly fee for keeping it running, supporting it, and continually updating it as needed. In that monthly fee, you might also include the licensing cost of the integration engine. In effect, you become a service provider selling an integration solution, rather than just a one-time builder.

This is where tools like HL7 Soup’s Integration Host and partner program come into play. HL7 Soup provides an integration engine on a subscription basis (with monthly or annual licenses), which is very amenable to a “managed service” model. As a freelance integrator, you can resell this as part of your service. Instead of delivering code and walking away, you might offer “HL7 interface as a service” where the client pays, say, $500 per month for you to ensure their lab results feed to their EMR is always working. Under the hood, you use an engine like HL7 Soup (which might cost, for example, $200 of that per month in licensing – just a hypothetical number) and your expertise to keep things smooth. The markup and the ongoing nature of the service become your profit.

Even if you’re not directly hosting, you can set up clients with their own integration host instances and then keep a support contract. Many healthcare providers prefer this arrangement – they often don’t have in-house HL7 gurus, so they are happy to pay a recurring fee to someone who does. It also aligns incentives: you are invested in the interface’s long-term success, not just a quick build-and-run.

Crucially, automation increases the value of these recurring models. If your interfaces require less manual tweaking (thanks to smarter tooling), you can confidently support more clients at once, or with less effort per client, without reducing your client’s monthly fee. In fact, your value to them is in the outcomes (data flowing reliably), not the hours worked. Meanwhile, your margin improves because AI is handling tasks that you used to do laboriously.

We’re seeing a shift where integration freelancers might start looking more like software vendors or managed service providers, rolling their expertise into a package. The industry is already nudging this way – for example, Redox (a healthcare integration platform) operates on a SaaS model, and many consulting firms partner with them to deliver “integration as a service” to digital health startups. Independent consultants can do the same on a smaller scale with the right tools.

In summary, don’t fear automationembrace it and change how you charge. By moving to subscription/retainer models and reselling integration platforms, you can maintain or increase your income while giving clients more predictable costs and value.

Adapting to Legacy Tool Changes (Mirth Connect and Others)

Another factor prompting change in the integration freelancing world is the evolving landscape of legacy integration engines. A prime example is Mirth Connect (now NextGen Connect), which has been extremely popular among freelance integrators due to its open-source model and flexibility. If you built a consulting business around deploying Mirth for clients, you likely enjoyed the fact that it was free and widely adopted. However, as of 2025, major changes have occurred in Mirth’s licensing that affect consultants and their clients:

  • Mirth Connect Goes Closed-Source: NextGen Healthcare announced in March 2025 that Mirth Connect will transition from an open-source license to a fully commercial, proprietary license as of version 4.6 (Mirth Connect License Change - The Key Points - Meditecs). In practical terms, this means no more free updates or community-supported versions going forward – only paid enterprise editions will get new features, security patches, and official support. Mirth, once a “cornerstone of healthcare interoperability,” is now a proprietary product (Mirth Connect License Change - The Key Points - Meditecs).

  • Impact on Freelancers: If you’ve been freelancing by setting up Mirth interfaces for hospitals or clinics, this raises tough questions. Your clients can continue running older open-source versions (3.x or 4.5) for now, but they won’t receive further updates or bug fixes. Upgrading to new versions will require them (or you, on their behalf) to purchase a license from NextGen. This could make projects more expensive and introduce licensing paperwork where none existed before. Some clients may be hesitant to pay for a formerly free tool, or they might turn to you for advice on alternatives.

  • Community Response: Not everyone is accepting the new status quo. The integration community is already responding – for instance, an Open Integration Engine project has emerged as a community-driven fork of Mirth Connect’s open-source code (Mirth Connect 4.6: What It Means for Open-Source Users and Next Steps). The president of a prominent interoperability firm even publicized that they are supporting this open-source fork (Mirth Connect 4.6: What It Means for Open-Source Users and Next Steps). This indicates a belief that an open alternative should exist for those who don’t want to pay NextGen. However, for consultants, adopting an unofficial fork could be risky for enterprise clients (due to uncertain support). It’s an option, but one to approach carefully.

  • Opportunity for Alternatives: The situation with Mirth has a silver lining for other vendors and for integrators willing to adapt. Clients “looking for alternatives” to avoid vendor lock-in is now a real trend (Mirth Connect 4.6: What It Means for Open-Source Users and Next Steps). This means you might find receptive ears if you propose a different integration engine for new projects – especially one that is more cost-effective or comes with better support. This is where modern solutions like HL7 Soup’s Integration Host or other interface engines can be pitched. In fact, HL7 Soup directly targets this scenario: it provides an AI-assisted migration path from Mirth (as discussed), aiming to make it easy to switch. The messaging is essentially: why pay for Mirth’s new license when you can migrate quickly and possibly save costs with another tool? As their site puts it, their competing solution is priced competitively and designed to address common pain points of other engines (HL7 Soup Partner Program).

For legacy Mirth freelancers, it might be time to update your toolkit. This doesn’t mean abandoning all the knowledge you have – quite the opposite. Your HL7 expertise and experience with integration logic remain extremely valuable. You can leverage that experience on new platforms. In fact, by learning a tool like HL7 Soup (or others like Rhapsody, Cloverleaf, etc.), you make yourself more marketable in a post-open-source-Mirth world. You’ll be the guide for clients on how to navigate these changes – whether that’s sticking with old Mirth for now with your support, migrating to the new paid Mirth (if they choose to pay for it), or moving to a different engine.

Key takeaway: The licensing shake-up in legacy software is pushing the freelance community to broaden their options. Stay flexible and inform your clients pro-actively. If a client comes to you worried about their Mirth interfaces, you can confidently explain the pros/cons of staying on old versions versus moving to something new. If you’ve aligned yourself with a partner program (like HL7 Soup’s), you can also offer them a seamless migration path with clear cost benefits (and you earn in the process). In short, turn this headwind into an opportunity to differentiate and provide strategic value.

Do Other Integration Platforms Reward Consultants?

With this talk of partner programs and revenue sharing, you might wonder: how do the major integration engine vendors handle independent consultants? Historically, most integration platform companies do not offer revenue-sharing or formal partnership commissions to individual consultants or small firms. Let’s briefly compare:

  • Traditional Vendors (Infor Cloverleaf, Lyniate Rhapsody/Corepoint, NextGen Mirth, Qvera, etc.): These companies mainly sell directly to healthcare organizations or through large channel partners. As an independent consultant, you can certainly work with their products (and even become certified or recommended), but there’s typically no program that pays you a percentage of the license fee. For example, if you recommend Infor Cloverleaf to a hospital and they purchase it, Infor isn’t going to send you a commission check – your benefit would only be any consulting hours you get implementing it. Some vendors have partner networks, but those are often about co-marketing or training, not sharing subscription revenue. In other words, the value flow is one-directional: a consultant may help a vendor get a new customer, but the vendor keeps all the software revenue. The consultant’s income remains solely whatever they charge the client for services. (There are occasional referral fees or reseller arrangements in the industry, but they’re not common for integration engines specifically.)

  • Modern Platforms and iPaaS: Some newer players, like certain integration-platform-as-a-service (iPaaS) providers, do have affiliate or partnership models. For instance, a cloud integration service might have referral partners. But in the healthcare-specific integration space, it’s still rare. Many cloud vendors like Redox or InterSystems will partner with consulting firms in terms of collaboration, but not usually in cutting the consultant into the deal financially. The consultant benefits indirectly by being the expert a client needs to implement the platform.

Given this landscape, the HL7 Soup Partner Program stands out. It’s somewhat unique in offering a revenue-share model tailored to integration consultants. HL7 Soup basically says: bring us customers (users of our HL7 Soup Integration Engine), and we will share the recurring subscription revenue with you. This approach turns the old model on its head – now the vendor (HL7 Soup) actively helps you, the consultant, build a recurring income stream, because your incentives are aligned. You both want the client to stay subscribed and happy.

Why don’t most other platforms do this? Likely because their sales models are oriented towards large direct sales or they see the software and services as separate domains. HL7 Soup, being a newer entrant, is leveraging a more modern, partnership-friendly strategy to grow usage – which can be a win-win for freelance integrators looking to augment their income.

So if you’ve felt in the past that you give free marketing to vendors (by using their tool at a client) without any kickback, you’re not alone. But now you have options to change that equation.

HL7 Soup’s Partner Program: Turning Integration Skills into Recurring Revenue

Let’s talk more about the HL7 Soup Partner Program, since it’s a concrete example of how you can generate ongoing income beyond just billing for labor. HL7 Soup is known for its HL7 message editor and its Integration Host engine, and recently it rolled out a partner program specifically targeting consultants and integrator companies. The highlights of this program include:

  • Revenue Share on Licenses: When you become an HL7 Soup partner and you get a client to use HL7 Soup’s software (say the Integration Host engine at a hospital), you earn a share of the subscription or license revenue. This means every month or year the client pays for HL7 Soup, you receive a commission cut. HL7 Soup describes it as an “attractive revenue-share partner model” that helps you “grow your recurring revenue streams.” (HL7 Soup Partner Program) The exact percentages aren’t published on the site, but the key is that it’s recurring – not just a one-time referral bonus. As long as your client keeps using the software, you keep earning.

  • Compounding Recurring Income: Over time, this can be powerful. You could sign up multiple clients. For each one, you add a new recurring revenue stream to your business. HL7 Soup essentially becomes a source of passive or semi-passive income for you. You might do initial work to get a client set up (for which you can also charge service fees), but then the license commissions keep coming. As one guide on affiliate revenue notes, “as you continue to refer new customers, your income can grow exponentially because you’re stacking new commissions on top of those from previous referrals.” (20+ Best Recurring Affiliate Programs 2025: Lifetime Commissions) This really applies here – you’re layering commission from Client A, Client B, Client C, and so on. Over a few years, a diligent HL7 integrator could build a sizeable book of business in license renewals alone. (And remember, these are high-value enterprise software subscriptions, so even a percentage of one client’s annual license can be a few thousand dollars in your pocket.)

  • Flexible Partnership Models: HL7 Soup mentions that they work with partners flexibly, adapting to your business model (HL7 Soup Partner Program). So whether you want to be a reseller, a referral partner, or include their product as part of a larger solution, they’ll support it. This is great because it doesn’t force you to change how you operate – it adds to it. You can continue to charge for consulting and projects as you normally do, and the partner program simply layers additional revenue on top.

  • Onboarding and Support for You: As a partner, you’re not left to figure everything out. HL7 Soup provides sales and marketing resources, training, and technical support to help you succeed (HL7 Soup Partner Program). Essentially, they help you sell and implement their solution to your clients. If you’re an expert in integration but not in sales, this is a nice perk – you can lean on their materials and team to convince clients (with case studies, ROI arguments, etc.). It lowers the barrier to entry to start offering a new tool. They even highlight that their growth has been driven by word-of-mouth and satisfied customers (HL7 Soup Partner Program), which can bolster your confidence in recommending it.

  • AI-Powered Migration = Quick Wins: We touched on this earlier – the AI migration tools (HL7 Soup Partner Program). From a partner’s perspective, this is gold. If you spot a prospective client using Mirth (and now worried about licenses), you can approach them with an offer to migrate to HL7 Soup for free or minimal cost using the AI converter. That means you can deliver a solution quickly, the client saves money (no hefty Mirth license, potentially), and you start earning commission right away when they subscribe to HL7 Soup. It shortens the sales cycle dramatically if you can say, “We have an automated way to switch you over.” Less effort, faster onboarding, quicker recurring revenue – it addresses the usual friction of migrating integration engines.

  • No More Unpaid Endorsements: Once you’re a partner, every time you deploy an integration using HL7 Soup, you’re effectively paying yourself in the long run. This is a stark contrast to, say, using Mirth or Rhapsody – where in the past you might set up those solutions for a client, but only invoice for your time. Now, by choosing HL7 Soup, you invoice for your time and you’ll get a slice of the software subscription you placed. It’s a way to monetize the “tool” part of your solution, not just the labor.

To make use of the program, you’d apply on their website (they have an application form for partners) and presumably get details on revenue share percentages and terms. The program is ideal for people with healthcare IT consulting experience and existing client relationships (HL7 Soup Partner Program) – which describes most freelance HL7 integrators perfectly.

Long-Term Earning Potential: The Power of Recurring Commissions

Let’s cast an eye to the future: what could all this mean for your long-term earnings if you pivot to including recurring revenue streams? The math can be exciting. Imagine:

  • Year 1: You convince 5 clients to adopt a new integration platform (e.g., HL7 Soup) via your consulting. Each client’s subscription yields you $200 per month in commission (just as an illustrative figure). By the end of the year, you’re making $1000/month in recurring income, on top of any hourly/project fees you earned from initial setup. That’s $12,000 a year that repeats, even if you don’t do much new work for those clients each month.

  • Year 2: You add 5 more client subscriptions in the next year. Now you have 10 clients, bringing in $2,000/month in commission. Plus, the Year 1 clients are still contributing (assuming they renewed, which is likely if the solution is working well). Your yearly recurring portion is now $24,000.

  • Year 3 and beyond: The process continues. Maybe a few clients drop off over time, but if you keep adding more than you lose, the total grows. Over, say, 5 years, you could be looking at a substantial passive income stream that, by itself, might equal a full-time salary. And none of this accounts for the fact that you probably also charged each of these clients for implementation and support services along the way.

This is the essence of compounding growth in recurring revenue. You’re no longer starting from zero at the beginning of each year; you’re stacking on top of an ever-growing base. It’s akin to building a portfolio of assets that pay you dividends. In fact, one affiliate program blog described it well: each referral’s ongoing commission is like adding a new layer, and “your income can grow exponentially because you’re stacking new commissions on top of those from previous referrals.” (20+ Best Recurring Affiliate Programs 2025: Lifetime Commissions)

For an integration engineer used to project-based work, this is a refreshing change. It provides stability – even if you hit a slow month where new contracts are hard to find, your existing commission streams are still flowing. It also adds equity to your business; theoretically, if you ever stepped back, you have a recurring revenue engine that could be sold or passed on (whereas you can’t sell your billable hours business easily).

It’s worth noting that quality and customer satisfaction are crucial to maintain this. You’ll only get those renewal commissions if the clients stay on the platform year after year. That means choosing a platform that performs well and meets their needs (so they don’t churn off). It also means providing excellent service so that they have no reason to switch to a different consultant or solution. Essentially, your incentive to keep the customer happy is built-in – which is how it should be. It fosters a long-term partnership with your clients, rather than a one-and-done transaction.

Conclusion: Staying Ahead of the Curve

The world of healthcare IT integration is undergoing a significant transformation. HL7 and FHIR skills remain highly valuable, but the way freelance integration engineers monetize those skills is broadening. By combining traditional income models (hourly, project, support retainers) with innovative approaches (AI-driven efficiency and recurring SaaS partnerships), you can create a robust and future-proof consulting business.

Here are a few parting recommendations for integration consultants and engineers:

  • Embrace New Tools & Automation: Don’t shy away from AI or new integration platforms. Master them. They can make you faster and more competitive. Your role can evolve from just a coder to a solution architect who leverages the best tools (like AI workflow generators) to deliver results. This will keep you relevant as routine tasks become automated.

  • Diversify Your Revenue: Mix and match your income streams. Continue charging for your time and expertise, but also set up deals where you earn from product subscriptions, maintenance contracts, and value-add services. This blend will smooth out the feast-or-famine cycle of consulting. As one expert noted in the context of AI and integration, “Healthcare integration is not just about coding interfaces anymore; it’s about delivering a reliable service. The more ways you can deliver value, the more ways you can get paid.” (Industry observation).

  • Leverage Partnerships: Consider partnering with vendors that align with your interests. The HL7 Soup example shows that smaller, agile companies are eager to collaborate with independent consultants in ways giants might not. Joining a partner program can provide you with software discounts, sales leads, training, and of course financial incentives. It can also differentiate you – you become the go-to person in your region or network for that solution.

  • Keep an Eye on Industry Changes: The Mirth Connect licensing change is a perfect example of why you can’t get too complacent with one technology. Stay plugged into the integration community (forums, LinkedIn groups, conferences). When you hear of upcoming shifts – whether it’s a new FHIR version, a vendor merger, or an AI tool – think about how it might affect your business and be proactive. Your clients will look to you to guide them through the noise.

Ultimately, the demand for interoperability in healthcare is only growing. More systems than ever need to talk to each other (thanks to initiatives around data sharing, population health, and digital health apps). This means opportunity for those with the right skill set. By staying ahead of tech trends and smart in your business strategy, you can not only remain relevant – you can truly thrive and increase your earnings year over year.

In the words of HL7 Soup’s partner invitation: “Join a community that's committed to transforming healthcare data exchange... together, let's make healthcare integration as easy as soup!” It’s a fitting sentiment – success in this field will come to those who collaborate, innovate, and find easy, scalable ways to solve integration challenges.

As an integration engineer on the front lines, you have a chance to ride this wave, deliver great solutions, and secure your financial future in the process. Here’s to your growth in the current and emerging market for HL7/FHIR integration!

Sunday, 20 April 2025

Comparing HL7 Interface Engines

Comparing HL7 Integration Engines

If you're knee-deep in HL7/FHIR messages and trying to choose an integration engine (or maybe replace your aging, and now expensive Mirth setup), you're in the right place. I’ve pulled together a comparison of the main players in the HL7 v2 integration space—from well-known giants to some refreshingly modern up-and-comers. Let’s break down who’s doing what, how easy they are to work with, and whether they’ll burn a hole in your wallet.

Integration Engine License & Cost Ease of Use Standards & Connectivity Scalability & Deployment Strengths / Weaknesses
HL7 Soup Integration Host Commercial subscription per workflow; free dev license. Lower cost than enterprise incumbents. Very high – Intuitive GUI, drag-and-drop mapping, English HL7 translation. Minimal coding needed. Training/support included. HL7 v2, FHIR, JSON, XML, CSV. MLLP (TCP), HTTP/S, file, DB, REST/SOAP. .NET scripting possible. Moderate scalability. Runs on Windows, Azure, AWS, Docker. Secure TLS. No public HA/clustering info. Strengths: Extremely user-friendly, embeddable UI, fast setup, low-cost. AI Designer.
Weaknesses: Smaller vendor, limited large-scale presence. No Dicom support.
Infor Cloverleaf Commercial, enterprise pricing per site or connection. Medium – GUI exists, but often needs TCL scripting. HL7 v2, HL7 v3, X12, DICOM, NCPDP. Broad protocol support. Very high scalability; enterprise HA support. Unix/Linux or Windows. Strengths: Trusted, powerful, highly scalable.
Weaknesses: Expensive, steep learning curve, legacy tooling.
iNTERFACEWARE Iguana Commercial, licensed per interface/channel. Higher-end pricing. Medium – Lua scripting focus, minimal GUI mapping. HL7 v2, JSON, XML, REST, DB, files. Highly flexible with code. High scalability. Docker/cloud native. Windows/Linux. Strengths: Fast, flexible, reliable for developers.
Weaknesses: Requires coding, not beginner-friendly, costly.
Lyniate Corepoint Commercial, enterprise subscription or perpetual. High – Low-code GUI, drag-and-drop interface building. HL7 v2, CCD, limited FHIR. Mostly GUI-based development. Enterprise-grade, HA, Windows-only. Strengths: Highly rated UI, excellent support.
Weaknesses: Expensive, less flexible, not cloud-native.
Mirth Connect (NextGen) Free open-source (MPL 2.0); enterprise version paid. OSS updates ending in 2025. Medium – GUI-based, but JavaScript needed for mapping logic. HL7 v2, X12, JSON, XML, REST, SOAP, DICOM. Scalable via clustering. Cross-platform Java-based. Strengths: Free, flexible, huge community.
Weaknesses: Coding required, dated, cumbersome UI, questionable value as a commercial product.
Qvera Interface Engine (QIE) Commercial; subscription or perpetual. Mid-range cost. High – Web-based GUI, drag-and-drop + scripting. HL7 v2, FHIR, HL7 v3, X12, DICOM, DB, JSON, XML. High scalability, cloud-ready, HA supported. Strengths: Versatile, modern UI, strong standards coverage.
Weaknesses: Not open-source, smaller market share than top brands.

So... what do I choose?

Look, Mirth has had a good run—but let’s be honest, it's open source quality with a shiny new commercial license. I could justify my wasted time previously with the savings on licensing, but that's changed. It might be time for something new. That’s where HL7 Soup comes in.

It’s easy to use (like actually easy), has a drag-and-drop workflow builder, and reads HL7 in plain English. But what really makes it shine? Their AI-powered Mirth Channel Conversion Tool. You literally upload your Mirth channel, and—boom—it builds the equivalent HL7 Soup workflow for you. No rebuilds from scratch. No headaches.

Whether you're doing one-off lab results feeds or building out a whole interoperability stack, HL7 Soup is seriously worth a look. Especially if you want to spend less time writing glue code and more time doing, well... literally anything else.

Monday, 7 April 2025

Convert Mirth Connect Channels with HL7 Soup's AI


If you are a professional HL7 or FHIR integrator, this is your chance to collect recurring revenue on your work while producing integrations faster than ever.
Install HL7 Soup's Integration Host instead of Mirth Connect, and you receive a handsome share of the license fees.
The AI tooling will allow you to convert your existing channel across, too.

Sunday, 14 May 2023

Manipulating XML Messages with C# in HL7 Soup’s Integration Host

Are you looking for a way to manipulate XML messages using HL7 Soup’s Integration Host using c#? Look no further! In this post, we’ll show you how to use the code below to do just that.

In this sample, we'll demonstrate with XDocument, but XmlDocument will work fine too.

First, make sure that the System.Xml.Linq.dll file is correctly referenced in your code. If you can’t find it, don’t worry - the code will still work, but you may see red squiggly lines in the editor. These can be ignored.

Next, get the destination message using the activityInstance.Message property. Then, load the incoming message into an XDocument object using System.Xml.Linq.XDocument.Parse().

From there, you can update the XML as needed. In our example, we add a new ValidFrom element to the root of the document. Once you’ve made your changes, get the updated XML using the ToString() method and set it as the new text for the root element.

Here’s the full code:

//Note, the next line might need redirecting to the file System.Xml.Linq.dll on your computer. 
//Another common location is C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.1\System.Xml.Linq.dll
//Even if you can't find it, don't worry. The code will still work, but you will just see red squiggly lines in the editor.  These can be ignored - it's only the editor that cannot find them.
#r "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\System.Xml.Linq.dll"

//Get the destination message
var destinationMessage = activityInstance.Message; //Use IHL7Message for HL7 Messages and IMessage for other message types

string xmlIn = workflowInstance.ReceivingActivityInstance.Message.Text;
workflowInstance.SetVariable("xmlIn",xmlIn); //put into variable to help debugging.  Remove once working

//Load incoming message into an XDocument object
System.Xml.Linq.XDocument doc = System.Xml.Linq.XDocument.Parse(xmlIn);

//Update as you see fit.
doc.Root.Add(new System.Xml.Linq.XElement("ValidFrom", "2021-06-25T11:45:22Z"));

//Get the updated XML
string xmlString = doc.ToString();

workflowInstance.SetVariable("xmlOut",xmlString);//put into variable to help debugging.  Remove once working

//Set the root element to be the new XML text.
destinationMessage.SetStructureAtPath("Patient",xmlString); 

We hope this helps you manipulate XML messages with HL7 Soup’s Integration Host! Let us know if you have any questions or comments. 

Thursday, 23 March 2023

Execute a database Sub Query on a Database to generate HL7 message with multiple rows of OBX's.

Are you looking to execute a database query in HL7 Soup's Integration Host and generate an HL7 message from it? Well, I have good news for you! It's super easy. But what if you needed to retrieve multiple rows of data to generate OBX results or similar (RXA, DG1 etc)? This scenario is certainly a little fiddlier as you need to execute a sub-query and loop over those results too in order to generate the segments. In addition, you don't know how many OBX fields might be needed, so you'll have to create them manually.

Thankfully, Integration Host has a very handy Add Segment Transformer, but it can only access the data in the outer query. So, it's one of those places where code is the best option.

In this post, I'll show you how to do it using a Code Transformer, but keep in mind that there are many possible ways you could also achieve this.

Let's start by executing a sub-query to retrieve the patient details. Once we have those details, we'll loop over the results and generate the OBX segments accordingly. Here's the code snippet that does just that:


#r "C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.1\System.Data.dll"
using System.Data.SqlClient;

IHL7Message destinationMessage = (IHL7Message)activityInstance.Message; //Use IHL7Message for HL7 Messages and IMessage for other message types
IMessage sourceMessage = workflowInstance.ReceivingActivityInstance.Message;

string patientId = sourceMessage.GetValueAtPath("[0]"); //returned patient ID from my database
string connectionString = @"Server=MyServer\sqlexpress;Database=MyDB;User Id=MyUser;Password=abc123;";

using (SqlConnection connection = new SqlConnection(connectionString))
using (SqlCommand command = connection.CreateCommand())
{
    //Get the vax records 
    command.CommandText =$@"Select * from Vax Where PatientID = {patientId}";
    connection.Open();
    using(SqlDataReader reader = command.ExecuteReader())
    {
        int c = 0;
        while (reader.Read())
        {
            c++;
                
            //Get the values from the Vax table
            string administeredDate = reader.IsDBNull(0) ? null : reader.GetString(0);
            string vaccineType = reader.IsDBNull(1) ? null : reader.GetString(1);
            decimal? amount = reader.IsDBNull(2) ? null : (decimal?)reader.GetDecimal(2);
            string units = reader.IsDBNull(3) ? null : reader.GetString(3);
                
            //insert the values as a new HL7 Segment line
            destinationMessage.AddSegment($"OBX|{c}|CE|{vaccineType}||{amount}|{units}||||||F|||{administeredDate}");
        }
    }
    connection.Close();
}



Thursday, 16 March 2023

How to update HL7 messages in a loop with HL7 Soup

 When working with HL7 messages, it is often necessary to modify certain segments within the message. However, when dealing with a large number of segments, it can be difficult to ensure that the message is not modified in unexpected ways during the modification process. This is where the BeginUpdate and EndUpdate methods come in handy.

Consider the following code snippet:

scss
//Get the current message we are writing as an HL7 Message IHL7Message destinationMessage = (IHL7Message)activityInstance.Message; //Get all the IN1 Sgments var in1 = destinationMessage.GetSegments("IN1"); //Set BeginUpdate as we are updating multiple Segments and don't want our list to change untill we complete destinationMessage.BeginUpdate(); //Loop over all the IN1 segments foreach (var seg in in1) { //remove the individual Segment destinationMessage.RemoveSegment(seg); } //Update the message destinationMessage.EndUpdate();

In this code, we retrieve the current message being processed as an HL7 message object called destinationMessage. We then retrieve all the segments in the message that are of type IN1, which is typically used to store insurance information.

Next, we call the BeginUpdate method on the message object to indicate that multiple segments will be updated, and the message should not be changed until the updates are complete. We then use a foreach loop to iterate over each IN1 segment in the message, and call the RemoveSegment method on the message object to remove each individual IN1 segment from the message.

Finally, after all the IN1 segments have been removed, we call the EndUpdate method on the message object to indicate that the updates are complete, and the message can be modified again.

Without the BeginUpdate and EndUpdate methods, it is possible that the message could be modified unexpectedly during the loop, causing issues with subsequent iterations. For example, if we did not use these methods, only the first item would be deleted as the foreach would then reference another message, and the remaining IN1 segments would not be removed.

In summary, when working with HL7 messages and modifying segments within them, it is important to use the BeginUpdate and EndUpdate methods to prevent unexpected modifications to the message. These methods ensure that the message is not updated until all modifications are complete, allowing for safe and efficient modification of large numbers of segments within the message.

Remove multiple segments from an HL7 message with HL7 Soup

 If you're working with HL7 messages, you may need to remove multiple segments from a message.

However, if you do it in a loop, you find that only the first item is removed.  This is because the delete causes the message to be recreated, and all remaining segments in the loop reference a different message instance.

Try this instead:

//Get the current message we are writing as an HL7 Message
IHL7Message destinationMessage = (IHL7Message)activityInstance.Message; 

//Get all the IN1 Sgments
var in1 = destinationMessage.GetSegments("IN1");

//Set BeginUpdate as we are updating multiple Segments and don't want our list to change until we complete
destinationMessage.BeginUpdate();

//Loop over all the IN1 segments
foreach (var seg in in1)
{
      //remove the individual Segment  
      destinationMessage.RemoveSegment(seg);
}

//Update the message
destinationMessage.EndUpdate();

The above example removes all the IN1 segments from an HL7 message. The code first gets the current message as an HL7 message and then gets all the IN1 segments. It then sets BeginUpdate as it is updating multiple segments and doesn’t want the list to change until it completes. It then loops over all the IN1 segments and removes the individual segment. Finally, it updates the message.