For many organizations, TIBCO BusinessWorks 5 is the backbone of their integration landscape — a technology with over two decades of proven reliability powering everything from enterprise service buses and SOA implementations to microservices, cloud-native integrations, complex batch workflows, and stateful backend applications. That investment is substantial, and the idea of modernizing it often raises an uncomfortable question: do we need to start over?
The answer is no — and that changes everything.
TIBCO BusinessWorks 5 Containers brings your existing BW5 applications into the cloud-native world without requiring a rewrite. The same EAR files. The same engine. The same business logic your teams have built and maintained for years. What changes is how those applications are deployed, managed, and operated — and that change is significant.
What TIBCO BusinessWorks 5 Containers Actually Mean
When TIBCO BusinessWorks 5 applications run on the TIBCO Platform through TIBCO BusinessWorks 5 Containers, they are no longer tied to TIBCO Administrator domains, TIBCO Runtime Agent, TIBCO Hawk, or TIBCO Rendezvous for infrastructure management. Each application becomes an independent Kubernetes Deployment — self-contained, self-healing, and managed centrally through the TIBCO Control Plane.
This architectural shift delivers capabilities that simply were not available in traditional BW5 deployments:
Self-healing and high availability — Kubernetes automatically restarts failed pods and reschedules them across available nodes. Applications that previously required expensive active-passive configurations for HA can now rely on the platform itself, reducing infrastructure costs and operational overhead.
Autoscaling — Horizontal Pod Autoscaler (HPA) support means that applications can scale dynamically in response to demand. Throughput-sensitive integrations no longer require manual intervention to provision capacity.
Improved observability out of the box — OpenTelemetry metrics and traces, combined with the Control Plane’s built-in log architecture, provide a level of visibility that traditionally required significant custom tooling to achieve.
API-driven lifecycle management — Deployment, configuration, and lifecycle operations are all available through REST APIs and the TIBCO Platform CLI, enabling seamless integration with modern CI/CD pipelines. AppManage, the traditional deployment tool, is no longer required for day-to-day operations.
Visual process diagrams — Similar to TIBCO BusinessWorks 6, the Control Plane displays process diagrams for each deployed BW5 application, improving operational transparency and supporting faster troubleshooting.
Simplified plugin and dependency management — Plugins and adapters are provisioned declaratively at deployment time. Additional JAR dependencies are managed through a supplement mechanism, meaning no software needs to be installed on cluster nodes.
The Modernization Challenge: Know Before You Go
Relocating a BW5 application portfolio to containers is not a big-bang effort — and it should not be treated as one. We recommend a phased, iterative approach that prioritizes stateless, service-oriented applications first, progressively expanding to batch workflows, adapter-based integrations, and more complex patterns.
The practical challenge is assessment. Before committing an application to the containerized platform, teams need to understand whether its design patterns are compatible. A few patterns require attention:
- Fault Tolerant Groups are replaced by Kubernetes Deployment replicas and self-healing — not a blocker, but a design consideration.
- Wait and Notify patterns work within a single pod instance; cross-instance scenarios require architectural review.
- Checkpoint storage must be database-backed in the containerized model.
- HTTP Basic Authentication in server-mode endpoints relies on TIBCO Administrator domain users, which are not present in the containerized runtime — authentication should be externalized to an API gateway.
- Plugins and adapters not yet available in the current Containers release require alternative approaches or phased scheduling.
Doing this assessment manually across a portfolio of dozens or hundreds of applications is time-consuming and error-prone.
Introducing bw5ToCE: Automation from EAR to Running Application
bw5ToCE is an open-source automation tool that covers the complete journey from a BW5 application running in TIBCO Administrator to a deployed workload on the TIBCO Platform — with a single command.
./bw5ToCE.sh <DOMAIN> <APP_NAME> –platform <PLATFORM_ENV> –namespace <ns>
That single invocation exports the EAR from TIBCO Administrator via AppManage, runs a full portability analysis against it, extracts Global Variables into a Kubernetes-ready values.yaml, and deploys the application to the TIBCO Platform via its REST API. No manual steps. No intermediate file management. No custom scripting.
Built-in Portability Analysis
Before every deployment, bw5ToCE automatically scans the EAR for patterns that require attention in the containerized environment. Findings are grouped into four severity levels:
| Level | Meaning |
|---|---|
| BLOCKER | Must be resolved before platform onboarding can proceed |
| WARNING | Behavior differs from classic deployment; review and test required |
| NOTE | Architectural consideration for cloud-native deployment |
| QUALITY | Best-practice advisory for production readiness |
By default, blockers stop the deployment — ensuring that nothing reaches the platform in a state that could cause silent failures. Reports can be generated as HTML or plain text for sharing with teams and stakeholders.
To analyze an application without deploying:
./bw5ToCE.sh tibco516 OrderProcessor –analyze-only –report output/OrderProcessor-report.html
Or analyze a local EAR directly, without any connection to a running BW5 domain:
./bw5ToCE.sh –ear /path/to/OrderProcessor.ear –analyze-only
Portfolio-Scale Onboarding with Batch Mode
For organizations with large BW5 domains, bw5ToCE supports batch export of all applications in a domain in a single operation:
./bw5ToCE.sh tibco516 –batch –offline
This produces portable artifacts — EARs, deployment properties, and values.yaml files — for every application in the domain, stored under a structured output/ directory. Teams can then review, triage by portability status, and deploy applications to the platform incrementally:
./bw5ToCE.sh –deploy-offline –platform platform –namespace bwce-prod
The batch report provides a deployment summary across all applications, giving teams the visibility they need to plan and track progress across the portfolio.
Flexible Workflows for Real-World Environments
Not every organization can connect tooling directly to their TIBCO Administrator environments from where deployment automation runs. bw5ToCE is designed with that reality in mind:
- Offline export produces artifacts without deploying, for environments with network separation between TIBCO Administrator and the TIBCO Platform.
- Custom artifacts mode accepts a pre-existing EAR and XML directly, bypassing AppManage entirely — useful when EAR files are already available from build pipelines or artifact repositories.
- Offline deploy takes artifacts from a previous export and deploys them to the Platform, supporting air-gapped or phased workflows.
A Practical Path to the TIBCO Platform
The recommended approach for relocating a BW5 portfolio follows a clear sequence:
- Assess — Run portability analysis across the application portfolio to understand readiness. Identify blockers, schedule remediation, and prioritize candidates.
- Provision — Enable the TIBCO BusinessWorks 5 capability on a TIBCO Control Plane dataplane. For hybrid scenarios, link existing BW5 domains to Control Tower to maintain unified visibility during the transition.
- Onboard iteratively — Begin with Priority 1 applications: stateless, HTTP and JMS-based services with standard plugin dependencies. Expand progressively to batch workflows, adapter integrations, and more complex patterns.
- Optimize — Once applications are running on the platform, evaluate opportunities to adapt designs for cloud-native advantages: autoscaling, event-driven patterns, reduced replica requirements through Kubernetes self-healing.
bw5ToCE supports every step of this journey — from the initial assessment through production deployment — removing the tooling gap that would otherwise require custom automation for each onboarding wave.
Protecting Existing Investments While Moving Forward
The TIBCO Platform is designed to support a hybrid operational model during transition. Applications can run side-by-side — some on TIBCO Administrator, others on the TIBCO Platform — while teams progressively relocate workloads at their own pace. TIBCO EMS and other shared infrastructure components can remain on-premises and continue to serve both environments. This eliminates the pressure of a forced cutover and allows the transition to be driven by readiness, not deadline.
The TIBCO BusinessWorks 5 engine itself does not change. The process logic, the Global Variables, the integration patterns — they all carry forward. What the TIBCO Platform adds is the operational model those applications deserve: cloud-native deployment, centralized management, built-in observability, and the flexibility to scale.
bw5ToCE is available on GitHub. To get started, clone the repository, configure your domain environment file, and run your first analysis. Your BW5 portfolio is likely closer to the TIBCO Platform than you think.
https://github.com/TIBCOSoftware/bw-tooling/tree/master/bw5toCE
Please refer to the link here for a tutorial video on bw5ToCE tooling.
Author:
Alexandre Vazquez
Alexandre Vázquez is part of the Product Strategy and Adoption Team at TIBCO. With more than 15 years of experience in software architecture, integration, and cloud transformation, Alexandre has held diverse roles spanning product strategy, customer success, and solution architecture.His deep technical background and passion for platform scalability and innovation have enabled him to bridge the gap between customers, field teams, and engineering—driving product excellence and modernization of enterprise integration solutions.
