AI-assisted configuration can help turn shared standards into working connections at scale, and patient-data exchange still follows predictable rules.
A national framework can set out how organizations should trust one another, and a standard can define how they exchange information. But to put those agreements into practice, someone still has to make thousands of decisions about how each individual system actually works.
Think about what that involves. A medication field has to be mapped, and the receiving service has to authenticate. Referrals need an acknowledgment. If a system goes down, it needs a recovery procedure. Each of these behaviours gets configured and verified, and then someone keeps maintaining it as requirements change.
Multiply that by every care setting, software product, and organizational boundary involved, and you can see why the “last mile” covers so much ground.
Canada Health Infoway’s Connected Care Trust Framework (CCTF) provides shared governance, legal and technical foundations for trusted exchange across existing systems. That common foundation matters because it lets organizations stop solving the same problems on their own.
We see the next opportunity in applying that idea to implementation. Make the engineering work reusable first, then use AI to speed up configuration.
The hidden cost of integration is repeated interpretation
Connecting two interfaces is only part of integration. Teams also interpret specifications, reconcile data structures, turn policies into controls, and decide how a service should respond when conditions aren’t ideal.
Some of this work is specific to one organization, though much of it follows patterns that come up again and again. The trouble is that a project-by-project delivery model can bury those patterns inside individual implementations. When the next team runs into similar requirements, they repeat the analysis. What was learned stays in project documents, the working code is hard to adapt, and testing starts over.
You can add development capacity, and it helps, but the repetition underneath doesn’t go away. A better question is what the next implementation should inherit from the one we’re building today.
Make variation something we can configure
Take two specialist referral services. Each one needs to receive submissions, check for required information, confirm receipt, track progress and escalate anything unresolved. Where they differ matters too: they may ask for different information, send referrals to different teams and work under different service expectations.
A reusable implementation makes those differences explicit. Things like required fields, permitted destinations, deadlines and escalation paths become controlled configuration around an established process. That changes the work. Teams can spend more time resolving what’s unique to the service while existing components handle the common functions, and AI gets a clearer role.
Give AI a bounded engineering task
If you ask an LLM to “connect these systems,” you’re handing it an open-ended problem. Instead, give it approved requirements, defined configuration structures, and a library of supported components, and the task becomes more bounded.
With that to work from, it can help propose field mappings, fill in workflow configurations, find missing requirements and draft tests. It can also show reviewers where settings differ from an established implementation and where a new requirement falls outside the available patterns.
A referral team, for example, could get a proposed configuration with its source requirements, the questions still unresolved, and the behaviour it’s expected to produce. Their review then focuses on specific decisions. The time savings could come from less manual translation between documents, configuration, and tests, so experts can focus on ambiguity and exceptions.
Anything the AI generates is still a proposal until it passes review and validation. Drafting faster adds value only if the whole delivery process gets more efficient, including assurance.
Keep AI in development and rules in operation
After release, the integration runs on approved code and configuration, and there’s no LLM at runtime. Access checks use explicit permissions. Routing follows defined conditions, validation enforces the requirements everyone agreed to, and when something fails, it triggers a specified response.
The system can still respond to changing inputs and current authorization information, but it does so by following rules teams can inspect and test. If a situation falls outside those rules, it goes down a defined exception path where an authorized person resolves it.
That boundary gives organizations something concrete to govern, since they can establish which version ran, what conditions were evaluated and why an action happened. It also keeps how the integration was built separate from the decision to trust it in operation. Using an LLM to help produce an integration doesn’t give that model authority over patient-data exchange.
Build a delivery capability that improves with use
Reuse takes more investment than putting templates in a repository. Someone has to own each component, and configurations need version control. Every change needs a compatibility check, and tests have to confirm prohibited behaviour as well as expected behaviour. Organizations also need a way to find out which implementations are affected when a shared component changes.
Infoway’s conformance services offer a foundation for validating implementations against pan-Canadian specifications, but local requirements and complete operational workflows still have to be verified in the settings where they’ll run.
The practical test is whether later implementations get easier. Can another service adopt the established pattern with less engineering? Are the differences visible, and does review become more focused? Can a shared correction be applied safely across deployments? These are measurable questions, and they should guide a first program built around several related exchanges, similar enough to test reuse but varied enough to show its limits.
The last mile will stay demanding, and clinical requirements, policy decisions, and organizational responsibilities deserve careful attention. Even so, every team should be able to start further along. Reusable integrations give them that starting point, and AI-assisted configuration can help them adapt those integrations faster, while approved workflows and explicit rules keep execution predictable. That’s how the last mile can get shorter with every implementation.
To understand more about how our perspectives translate into practical solutions:
Enterprise Applications | Digital + AI Transformation | Data + AI | node-wire
Author Profile:
Michael Kares is Head of Enterprise Sales at AOT Technologies. He has worked in technology and enterprise sales for three decades, helping organizations navigate complex technology decisions and modernize with practical, scalable solutions.