Developer SDK

Build customer-specific workflows without modifying the platform core

Develop, test, and debug customer-specific HL7 v2 → FHIR workflows locally in your IDE. Normalize source HL7, enrich generated FHIR, call external services, perform FHIR lookups, apply semantic rules, and deploy the same Groovy workflow to FireSonic.

Work in a familiar Maven project using IntelliJ IDEA or Eclipse
SDK Foundations

Designed for customer-specific integration logic

Extend FireSonic through defined lifecycle hooks, platform-managed integration APIs, and a controlled runtime without modifying the platform core.

Lifecycle Hooks

Intercept key points in the integration lifecycle to filter, enrich, or validate data with custom logic.

Managed Integration APIs

Secure, versioned APIs to connect, orchestrate, and manage integrations with reliability and scale.

Sandboxed Runtime

Execute custom logic in an isolated, secure runtime with strict boundaries and zero impact on core flows.

SDK Capabilities

Build real integration logic

Use SDK services to implement local healthcare workflows without rebuilding platform infrastructure.

HL7 normalization

HL7 Normalization

Read, replace, clear, and normalize HL7 fields and segments before conversion.

FHIR enrichment

FHIR Enrichment

Inspect, patch, add, or remove generated FHIR resources after conversion.

FHIR resource lookups

FHIR Lookups

Search Patient, Encounter, and other resources using the managed FHIR client.

Terminology services

Terminology Services

Validate local codes against configured terminology services and standard coding systems.

REST integrations

REST Integrations

Call external HTTP services using managed clients, authentication, and sync/async requests.

Caching and configuration

Caching & Configuration

Use TTL caches and injected environment-specific configuration properties.

Semantic rules

Semantic Rules

Implement INFO, WARN, and ERROR rules against the generated FHIR Bundle.

Retry utilities

Retry Utilities

Use managed retry helpers to make external integrations more resilient.

Engineering Flow

Standard software-development workflow

Develop, test, version, and deliver workflow changes using familiar engineering practices.

IntelliJ IDEA / Eclipse Develop & debug workflows
JUnit / Spock Unit & integration tests
Git Version workflow code
GitLab / Jenkins CI/CD pipeline
FireSonic Runtime Deploy & run
Customization Model

Keep hooks focused

Generic interoperability stays in the platform. Customer scripts contain local workflow rules, normalization, enrichment, terminology reconciliation, validation, and organization-specific behavior.

✓Platform handles the heavy lifting

Transport, parsing, mapping, durable processing, and delivery.

✓Your hooks handle local logic

Workflow rules, enrichment, validation, terminology, and external integrations.

Main.groovy
class Main implements IntegrationScript {

    @Override
    void onStartup() {
        // Initialize script resources after dependency injection.
    }

    @Override
    FilterResult shouldProcess(MessageEnvelope envelope) {
        // Accept, filter, or reject the incoming HL7 message.
        return FilterResult.accept()
    }

    @Override
    MessageEnvelope preConvert(MessageEnvelope envelope) {
        // Normalize customer-specific HL7 before conversion.
        return envelope
    }

    @Override
    Bundle postConvert(MessageEnvelope envelope, Bundle bundle) {
        // Enrich generated FHIR and apply workflow-specific logic.
        return bundle
    }

    @Override
    void postValidation(MessageEnvelope envelope,
                        Bundle bundle,
                        SemanticValidationResult result) {
        // React to semantic validation errors, warnings, and info.
    }

    @Override
    void onShutdown() {
        // Release external resources owned by the script.
    }

    @Override
    String scriptVersion() {
        // Report the active integration-script version.
        return "customer-workflow-1.0.0"
    }
}

Develop. Test. Debug. Deploy.

Build and verify customer workflows locally with confidence, then deploy the same workflow code to FireSonic without modifying the platform core.