Swap Any Module Without Replatforming
Replace payment processors, identity providers, messaging systems, or EHR connectors independently.
The Problem This Solves
Before HealthSail
Healthcare organizations adopting commerce platforms face all-or-nothing vendor decisions. Replacing a single component, such as a payment gateway, requires replatforming the entire commerce stack because components are tightly coupled. This vendor lock-in drives up costs and prevents organizations from using best-of-breed tools.
With HealthSail
HealthSail's composable architecture lets organizations swap any module independently through standardized interface contracts. Teams replace a payment processor or EHR connector without touching workflows, compliance controls, or other modules, preserving existing investments while modernizing incrementally.
How It Works
Standardized Interface Contracts
Every module category in HealthSail is defined by a standardized interface contract that specifies the data structures, methods, events, and compliance requirements that any implementation of that module must satisfy. The payment module contract, for example, defines methods for authorization, capture, refund, and tokenization along with the data structures for payment requests, responses, and webhook events. Any payment processor integration that implements this contract can be plugged into HealthSail without modifying the workflows, compliance rules, or other modules that depend on payment functionality. Interface contracts are versioned independently from module implementations, allowing the platform to evolve its contract specifications while providing a migration path for existing implementations. Each contract includes compliance specifications that define the minimum audit logging, data handling, and access control requirements for implementations, ensuring that swapping a module cannot inadvertently reduce the platform's compliance posture. The contract validation system tests new module implementations against the full contract specification before they can be activated in production, catching integration issues during setup rather than during live transaction processing.
Module Replacement Without Disruption
HealthSail supports live module replacement through a blue-green deployment pattern that runs the old and new module implementations simultaneously during a transition period. When an organization replaces a payment processor, for example, the platform can route new transactions through the new processor while completing in-flight transactions through the old processor. The transition period is configurable, and the platform monitors both implementations for error rates, latency, and compliance adherence throughout the cutover. If the new implementation exhibits issues during the transition, the platform can roll back to the previous implementation without data loss or transaction interruption. Module replacement preserves all workflow configurations, compliance rules, and audit histories that reference the module category — only the underlying implementation changes. This means that a workflow step configured to 'process payment' continues to function regardless of which payment processor is active, because the step references the module contract rather than a specific implementation. The replacement process is itself logged in the audit trail, documenting when the change occurred, who authorized it, and the before and after implementation identifiers.
Multi-Vendor Module Strategies
HealthSail supports running multiple implementations of the same module category simultaneously, enabling organizations to use different vendors for different contexts. A healthcare network operating in multiple states, for example, can configure different payment processors for different locations based on regional contract terms or regulatory requirements. A pharmacy that processes both insurance claims and direct-to-consumer payments can route each payment type through a different processor optimized for that transaction pattern. Multi-vendor configurations are managed through routing rules that evaluate transaction attributes to determine which module implementation to invoke. Routing rules can consider factors such as transaction type, organizational unit, geographic region, payment method, or any custom attribute attached to the transaction. Each implementation maintains its own configuration, credentials, and performance metrics, and the platform monitors all active implementations through unified dashboards. Multi-vendor strategies do not compromise compliance — every implementation must satisfy the module category's interface contract, including its compliance requirements, regardless of which vendor provides it. This ensures consistent audit logging, data handling, and access control across all active implementations.
EHR and System Interoperability
HealthSail's composable architecture includes specific module categories for EHR connectivity, supporting integration with major electronic health record systems through standardized connectors. The EHR module contract defines methods for patient identity verification, clinical data retrieval for order context, provider credential validation, and care coordination event exchange. Organizations can select from pre-built connectors for common EHR platforms or build custom connectors for proprietary systems, with all connectors implementing the same interface contract. EHR connectors handle the translation between HealthSail's internal data model and the EHR system's data formats, including HL7 FHIR, HL7 v2, and proprietary API formats. The connector manages credential storage, connection pooling, and retry logic for the external system, isolating the rest of the platform from EHR-specific operational concerns. Data flowing through EHR connectors is subject to the platform's PHI handling rules, with field-level filtering ensuring that only the minimum necessary clinical context is retrieved for commerce operations. For example, a pharmacy order workflow might retrieve the prescribing provider's identity and the medication order from the EHR while excluding the patient's full clinical history, lab results, or notes that are not relevant to fulfillment.
Architecture & Integration Notes
The composable architecture is implemented through a dependency injection framework that resolves module implementations at runtime based on configuration rather than compile-time binding. Each module category defines a TypeScript interface that implementations must satisfy, and the framework validates implementations against these interfaces during registration. Module configurations are stored as declarative JSON that specifies the active implementation for each module category, along with routing rules for multi-vendor configurations. The framework supports hot-swapping of module implementations without platform restart through its blue-green deployment mechanism. All module configurations are upgrade-safe — platform updates add new module categories and evolve existing interface contracts through versioned migration paths while preserving existing module configurations and custom implementations.
AI Copilot for Composable Architecture
The AI Copilot assists with composable architecture decisions by analyzing an organization's existing vendor relationships, integration patterns, and operational requirements to recommend module configurations. When an organization considers replacing a module, the copilot evaluates the new implementation against the interface contract and identifies potential compatibility issues, performance considerations, or compliance gaps. It can generate migration plans for module replacements, including transition period recommendations, rollback criteria, and testing checklists. The copilot also monitors module performance across the platform and identifies modules that are consistently underperforming relative to alternatives.
AI Copilot — Available on Growth & Enterprise Plans
AI Copilot reduces implementation time for composable architecture by automatically generating field mappings, test datasets, and validation scripts based on your compliance schema — so your team can ship faster without writing repetitive configuration code.
Ready to see Composable Architecture in action?
Book a Compliance Blueprint call and get a live walkthrough tailored to your healthcare workflows and compliance requirements.
Before & After HealthSail
| Area | Before | After HealthSail |
|---|---|---|
| Area 1 | All-or-nothing vendor decisions with complete replatforming required | Independent module replacement through standardized interface contracts |
| Area 2 | Vendor lock-in preventing adoption of better tools | Multi-vendor strategies with per-context routing |
| Area 3 | EHR integrations tightly coupled to commerce logic | Standardized EHR connectors that isolate integration complexity |
| Area 4 | Module changes requiring months of development and testing | Blue-green module deployment with live cutover and instant rollback |
Related Features
Frequently Asked Questions — Composable Architecture
Get your tailored compliance implementation plan.
Our Compliance Blueprint call delivers a written implementation roadmap specific to your healthcare workflows, compliance requirements, and your timeline.