Designing a Generic Integration Layer for Multiple APIs using Thing Template – Best Practice?

Hi Community,

I am currently working on an integration scenario where I consume data from multiple external APIs (e.g., SAP, APLUs and 4 additional interfaces ).

Each API delivers data in a slightly different structure, but the overall processing logic in ThingWorx is quite similar:

• Call external API

• Receive data

• Perform transformation / validation

• Execute business logic

• Return structured output

To avoid duplication and improve maintainability, I am considering the following generic approach:

Proposed Approach

• Create a Thing Template that contains:

  • Generic input definitions (API endpoint, headers, payload, etc.)

  • A standardized output structure (e.g., JSON)

  • Shared services for:

    • API execution

    • Data transformation

    • Error handling

    • Logging

• Then create individual Things inheriting from this Thing Template for each interface (SAP APLUs, Interface2, Interface3, etc.)

• Override only specific logic where necessary

This way:

• Core logic is centralized

• Services are inherited

• Interfaces remain configurable

• Maintenance effort is reduced

My Question

1. Is using a Thing Template as a generic integration base considered a good architectural approach in ThingWorx? Would you recommend a different pattern (e.g., separate Integration Things + shared Utility Thing, Resource-based approach, etc.)?

2. Is there a more professional or scalable way to implement a reusable integration framework inside ThingWorx?

My goal is to build a clean, reusable, and enterprise-ready structure instead of copying services across Things.

Thank you very much in advance for your advice and best practices!