This report assesses the capabilities of TIBCO’s Process Application Platform, and also examines the partners and intellectual property that TIBCO can offer customers exploring associated technology implementations. This assessment report forms part of a series of reports from MWD Advisors which assesses business process application technology offerings – technology-related capabilities which support organisations wanting to design, develop, deploy, monitor and optimise partially- or wholly-automated business processes.
We strongly encourage you to read this report in conjunction with our accompanying Assessment Framework report.
Although TIBCO is often thought of as being principally focused on integration and straight-through process automation, its ‘high-end’ process application platform ActiveMatrix BPM (AMXBPM below) is very well-suited to transactional work scenarios where human process participants dominate task work, and has a number of features that support large-scale deployments. Recent decoupling of user experience from core process applications and case management enhancements are noteworthy recent improvements. In 2017 TIBCO also launched TIBCO Cloud Live Apps (TCLA below), which complements AMXBPM in providing a case-centric, low-code application development capability that is simple and quick to use for blended teams, though limited in sophistication.
Support for different types of work
Automated work: There’s very good support for automated work scenarios, particularly through the combination of ActiveMatrix BPM with the BusinessWorks application integration platform. The smooth interoperability between TIBCO Cloud Live Apps and TIBCO Cloud Integration is also of value here.
Transactional work: Support for transactional work is excellent: very large-scale, multi-team deployments are possible particularly with ActiveMatrix BPM. For customers not wanting to co-ordinate work through software, Nimbus provides a smart ‘halfway house’ that still delivers process knowledge, control and governance.
Exploratory work: Exploratory work scenarios are increasingly well-served by TIBCO today, whether you opt to use ActiveMatrix BPM or TIBCO Cloud Live Apps. ActiveMatrix BPM provides more sophistication in this respect, but TCLA makes it easy to build relatively simple case management applications quickly.
Rapid prototyping / quick-start
TIBCO has created TCLA primarily to enable relatively non-technical ‘gifted amateurs’ to quickly build full-featured case management applications. The design environment uses a ‘design by interview’ approach to lead people through the process of specifying an application, while only requiring minimal technical information. Right now, there’s no ability to migrate applications from TCLA to AMXBPM, but integration is possible and TIBCO is working on making more integration use cases easier to address.
In the context of ActiveMatrix BPM, change management facilities are fairly strong, though there is room for improvement – for example change impact analysis could be stronger. With Business Studio you can visually compare different versions of a process model to identify changes, though, which is useful. If you’re using TCLA, then the facilities on offer are more limited.
User experience options
With AMXBPM, TIBCO provides multiple user experience options – from an open REST API enabling you to build custom front-ends, to a packaged HTML5 component-based client application framework, out-of-the-box web apps and a mobile app framework. If you’re using TCLA, you have two choices: to use the in-built responsive web-based case management application or mobile UI.
TIBCO does now certify AMXBPM for deployment to public cloud infrastructure (AWS today) for customers looking for high control of the platform, but its primary cloud push for low-code application development is TCLA. TCLA is delivered via the TIBCO Cloud, which itself is hosted on AWS and is available in the US, EU and Australia.
Inside TIBCO’s platform
TIBCO’s Process Application Platform offering revolves around three principal products. First, there’s ActiveMatrix BPM – which the company pitches for the automation of core business processes that drive high-volume business operations. ActiveMatrix BPM is currently at version 4.2. Second, there’s TIBCO Cloud Live Apps. This PaaS is specifically designed for building simple case-centric, low-code applications quickly, where simple processes are invoked as cases progress between stages. Third, there’s Nimbus, which is principally used where the goal is to drive process knowledge, governance and operational consistency, but without automating workflows. Nimbus is currently at version 10.2.
Key tools and capabilities
In more detail, the main tools and capabilities that make up TIBCO’s overall Process Application Platform are as follows:
- TIBCO Nimbus. A web-based process mapping tool that allows customers to design high-level business-level process maps using a very non-technical, easy-to-understand ‘Universal Process Notation’. If required, customers can deploy maps in an operational environment as ‘How-To Guides’ that workers can use to get assistance in carrying out their work in line with desired processes and imposed regulations.
- TIBCO Cloud Live Apps. A cloud-based application PaaS with highly visual, web-native design and administration tools that’s designed to help people build and deploy case-centric applications very quickly and easily. Professional and Enterprise Editions of TIBCO Cloud Live Apps are also bundled with the TIBCO Cloud Integration capability, which meets our definition of a Digital Integration Platform.
- TIBCO ActiveMatrix BPM Suite
- TIBCO Business Studio (BPM Edition). An Eclipse-based suite of tools for specifying the structure and behaviour of ActiveMatrix BPM projects. Optimised for definition and management of BPMN and UML models, Business Studio provides not only process design capabilities, but also information and organisation modelling capabilities, user interface (task form) design capabilities, simulation capabilities and limited process discovery and analysis capabilities. TIBCO provides two different versions of Business Studio: the full-featured, Eclipse-based Business Studio for Designers, and a simplified client called Business Studio for Analysts that hides some of the complexities of the Eclipse environment and supports process, data and organisational modelling.
- TIBCO ActiveMatrix BPM. The runtime business process platform for process applications (process, data, organization, and form models) you design and develop using Business Studio tools. It’s built as a set of components atop TIBCO’s ActiveMatrix, which provides a set of highly-scalable application middleware and integration services for a growing range of TIBCO platform offerings.
- TIBCO ActiveMatrix Decisions. A business rules management platform delivered as a bundle for licensing along with ActiveMatrix BPM when you want to specify sophisticated rules for process decisioning.
- TIBCO ActiveMatrix BPM Spotfire. A sophisticated analytics environment that enables non-technical business analysts to use the Spotfire desktop client or web-based client to drill-down into historical process performance and visualise this in the context of other related business data – and also to take actions on the insights directly from the Spotfire dashboards where they are surfaced.
- TIBCO JasperReports for ActiveMatrix BPM. This free add-on provides tailorable web-based process monitoring dashboards that can be delivered standalone, or via Openspace gadgets (see below).
- TIBCO ActiveMatrix Workspace, Openspace and Mobilespace. These are the out-of-the-box dynamic user interface frameworks that act as containers for process participant interactions through worklists, task forms and monitoring/performance dashboard components. Workspace uses AJAX technologies; Openspace is a gadget-based client based on Google Web Toolkit (GWT). Openspace provides two additional variants: Openspace-Mobile is optimised for use on iPhones, and Openspace (Accessible) is Web Content Accessibility Guidelines (WCAG) compliant. The Openspace forms renderer is also available to be embedded in third-party or custom user interfaces. Mobilespace is a generic mobile client app (for iOS and Android) that provides access to device features as well as providing access to ActiveMatrix BPM application services.
In addition, TIBCO offers ActiveMatrix BusinessWorks. This is a sophisticated application integration platform with associated tools that you can use to wrap, transform, orchestrate and expose functionality from existing systems, applications and data sources as standards-based Web services, which then can be enlisted in Business Studio models.
User experience options
As introduced above, AMXBPM provides a wealth of user experience options:
- You can use ActiveMatrix Workspace or Openspace web UI frameworks to surface process application capabilities in dedicated user interfaces.
- You can deploy mobile application user interfaces through Openspace-Mobile or the newer Mobilespace native mobile app container.
- You can use AMXBPM’s Application Management capability to create and deliver multiple role-based front-end Applications that can blend access to process application functionality with other role-based web content. Crucially, these Applications can be managed completely independently from the process application back-ends that they provide access to; so restyling (or even localising or restructuring) an Application can be done without having to redeploy the associated processes. TIBCO provides an out-of-the-box Case Management app built on this framework that customers can clone and adapt to their own use case.
- A comprehensive AMXBPM platform REST API enables you to create completely custom application clients.
If you’re using TCLA, you have two choices: to use the in-built responsive web-based case management application UI, or the provided prebuilt mobile app.
TIBCO does now certify AMXBPM for deployment to public cloud infrastructure (AWS today), but its primary cloud push for low-code application platforms is TCLA. The team responsible for AMXBPM development is the same team that’s behind the development of TCLA, but as noted above TCLA’s design is principally oriented around ease-of-use and immediacy (whereas AMXBPM is an extremely rich and capable platform that takes much longer to master). TCLA is delivered via the TIBCO Cloud, which itself is hosted on AWS. It’s available today in the US, EU and Australia regions – meaning customers choose their location to minimize latency and/or opt for their preferred regulatory framework.
Using the products: core capabilities
Rapid prototyping / quick-start
TIBCO has created TCLA primarily to enable relatively non-technical ‘gifted amateurs’ to quickly build full-featured case management applications. The design environment uses a ‘design by interview’ approach to lead people through the process of specifying an application, while only requiring minimal technical information. The process starts with you first designing the information your case will manage; then defining a series of “states” that your case might pass through on its way to resolution, before defining the actions (tasks and workflows) that will drive the progress of cases through those states (also highlighting which actions are available in which case states).
Mapping, modeling and application design
In TIBCO’s portfolio there are two alternatives you might use for high-level process mapping and design: Nimbus and Business Studio. It’s possible to export Nimbus diagrams to Business Studio for further enrichment – positioning Nimbus as a process discovery and requirements definition tool for BPM projects ultimately pursued with ActiveMatrix BPM (it’s not currently possible to export into TCLA). When diagrams are imported from Nimbus into Business Studio, a reverse link is also preserved – making it easy for Studio users to refer back to those related requirements. Nimbus’s mapping tool is uncomplicated by design: the focus is on laying out easy-to-read workflow maps so that they are as comprehensible as possible to a wide audience. The tool does a decent job of making this simple.
TCLA is designed around a case-centred application model, so processes don’t govern end-to-end behaviour here: instead, processes are employed as implementations of Actions that get invoked as an application case moves from state to state. The process notation used in TCLA is a highly simplified BPMN: processes comprise start and end events, activities, and exclusive gateways (‘decision points’). There’s no concept of a parallel gateway, so processes you define here can’t orchestrate the initiation of multiple activities in parallel.
If you’re using AMXBPM then you’ll use the Process Modeler within Business Studio to define processes using all the usual BPMN process constructs (swimlanes, activities, gateways, timers, events, exceptions, and so on). Two flavours of Business Studio are available: Business Studio for Analysts and Business Studio for Designers. Business Studio for Analysts offers a modelling environment that hides elements that are used to specify process and integration implementation details. If the process author is comfortable with a more technical environment Business Studio for Designers can be used in the ‘Business Analysis’ perspective to provide additional details, or in the ‘Solution Design’ perspective for full implementation details and control, thus allowing each process author to operate at the level of detail they are comfortable with.
A number of model import options are available for Business Studio’s Process Modeler: including from TIBCO iProcess, ARIS, Visio and Casewise.
As a case management application development tool, TCLA’s application model is centred around entities and the fields within those, rather than processes. Each application is organised around one particular entity (employee, complaint, product, invoice, and so on). You can define complex types (so, for example, an invoice entity definition can contain multiple invoice lines as well as header information). You can then reference your application’s entity data when specifying actions, conditions, work assignment and more. Behind the scenes, your application manages the state of multiple entity instances and persists them in the TIBCO Cloud.
If you’re using AMXBPM, then you can use the UML-based Business Object Modeler within Business Studio to create sophisticated entity models that both provide a foundation for application analysis and high-level design, and can be used within your running process applications themselves.
Unlike in TCLA, with AMXBPM and the Business Object Modeler you can define multiple objects, with relationships between them – though as in TCLA, each object can be compound (so again, you can define an invoice object that contains one or more invoice lines as well as header information). As you define your AMXBPM applications, you then elect to instantiate these objects as ‘local’ datatypes (in which case they’re scoped to individual process instances) or ‘case’ data types. Case objects are persisted within the AMXBPM platform, and case data is available to be referenced and updated across multiple processes and process instances (find out more in the Facilities to support exploratory work section below). Objects instantiated in your AMXBPM applications can be referenced and updated throughout the layers of your specifications – across process tasks, scripts, rules, user interface definitions, and so on.
For customers wanting to implement sophisticated rules-based decisions, AMXBPM will be the vehicle. In the context of TCLA today, you’re limited to specifying very simple data-based conditions to drive action process flow and specify other user-facing behaviours.
If you’re using AMXBPM, then TIBCO offers its BusinessEvents Decision Manager technology – and in the current version Decision Manager functionality is available as an integrated add-on to ActiveMatrix BPM as ActiveMatrix Decisions. Rules specifications are stored together with other application model elements and they’re also available within the Packages that Business Studio uses as the logical containers for your process application assets. A strength of this integration is that rules share the same Business Object Model as other process application assets – so you don’t have to manually ensure that parameters passed to and from rules services match definitions stored elsewhere in your application definitions.
ActiveMatrix Decisions provides decision tables, decision trees and ‘decision flows’ as specification metaphors; with decision flows, designers can graphically chain together multiple decisions. A useful validation mechanism called Table Analyzer provides facilities to validate decision tables, find ‘gaps and overlaps’ in rulesets and redundant rules, and generate test data. You can define and manage constants for use within rules separately from those rules, which makes it straightforward for people to make simple changes to rule behaviours without changing rule details themselves.
If you’re using TCLA then you have the option of using TIBCO Cloud Integration alongside (this functionality is bundled in premium TCLA subscriptions). TIBCO Cloud Integration is hosted on the same core platform as TCLA, and the two capabilities are designed to work together: when you create integration flows in TIBCO Cloud Integration’s Web Integrator tool or import integration code (from TIBCO Business Studio, or an existing Node.js microservice), it’s straightforward to make these available directly within the TCLA environment to consume as packaged integration services. Today there are off-the-shelf connectors available for Marketo, Salesforce and SugarCRM SaaS properties; you can also use connectors available with BusinessWorks Cloud Edition (please see Reference information for more information). The BusinessWorks option is only available with a standalone TCI subscription and is not included with the TCI capabilities bundled with TCLA. You can of course also leverage any public REST API as an endpoint.
If you’re using ActiveMatrix BPM, there’s a strong set of technology-focused resource and application connectors made available for use in your process applications by default. Processes deployed can straightforwardly integrate with resources via Java Message Service (JMS) queues, SOAP and REST web services, standard SQL queries and stored procedure calls, invocation of remote Enterprise Java Beans (EJBs) and locally-hosted Java objects. If you have more sophisticated integration requirements for your process applications – for example, if you need to orchestrate interactions with multiple resources and systems in order to execute a particular task then you have the choice of using AMXBPM’s in-memory Service Processes or BusinessWorks for this orchestration. If you need to integrate with external systems that don’t offer standard interfaces then TIBCO recommends you use the BusinessWorks application integration platform as an intermediary layer. This is licensed separately.
Work assignment and distribution
If you’re using TCLA, then you can define simple organisational (work distribution and application access) models comprising individual members, and one or more groups. Members can belong to multiple groups; in defining applications and activities, you define which groups (or individuals) are allowed to use them. You can import user metadata into TIBCO Cloud, though the process is rudimentary today; one TIBCO Cloud knows about these user accounts, it can authenticate against a customer’s existing LDAP directory service. More sophisticated integration with enterprise identity management infrastructure is planned.
If you’re using ActiveMatrix BPM then you’ll have very strong capabilities to hand in support of transactional work scenarios that revolve around teams of human process participants. AMXBPM provides these capabilities through interlinked models that are much richer than those provided by most of its competitors. Information models and organisational models work hand-in-hand with process models to specify sophisticated work distribution behaviours and patterns, with a minimum of coding.
AMXBPM organisational models in particular are very rich indeed – enabling designers to model not only roles and groups, but also associate those with teams, capabilities, privileges, locations and other custom attributes. Organisation model concepts can be used drive work assignment dynamically (so it’s easy to specify through declarative models, for example, that a particular task should only be escalated to staff located in Paris with superior accounting skills). ‘Elastic organisation models’ enable you to define organisation models with ‘extension points’ that are associated with organisational model templates that you define. Through extension points and templates, you can declaratively specify organisational models that can will expand and contract dynamically – as, for example, branches (in a retail or banking business, perhaps) are opened or closed.
Both TCLA and AMXBPM also implement a set of ‘workflow patterns’ that reflect common work management needs (such as ‘separation of duties’, in which work carried out in one task by one member of a group has to be reviewed by a different group member; or ‘chaining’, in which tasks of the same type are assigned sequentially to the same worker). In both TCLA and AMXBPM you can set these up declaratively, again following a model-driven approach. The result of all this is a set of discrete Work Management capabilities that’s clearly separated from process management – and it’s a very strong feature of TIBCO’s overall process automation platform.
If you’re using AMXBPM then Business Studio offers strong capabilities for UI definition, which you’ll use where your process tasks need to be executed by people. Business Studio can auto-generate first-cut forms based on existing human task definitions, and there’s also the concept of ‘page flows’ – chained series of forms, defined using a subset of BPMN – which help users work effectively with complicated multi-step tasks that can invoke multiple back-end services and include conditional flow logic. You can also define dynamic forms for tasks that have rich client-side event-based behaviours, and the built-in form design tools make this relatively straightforward. You can also make use of third-party UI libraries in the designer and have those integrated into forms at runtime. Form elements can exchange information with each other using TIBCO’s own PageBus client-side integration technology – enabling very dynamic, rich behaviours to be specified quickly.
As mentioned briefly in User Experience options above, in AMXBPM (since version 4.0) there’s now a separate ‘Application’ layer you can author and manage within the platform through Application Development and Application Management capabilities. Here, ‘Applications’ are collections of web pages, stylesheets and scripts that provide role-based, tailored user experiences for your process application back-ends. Importantly, you can create and manage multiple of these applications for each process (or set of processes) – and Application lifecycles are independent of process lifecycles. That means that teams can rapidly prototype, update and otherwise re-design or re-style web engagement front-ends to your processes without having to update or redeploy your core process application back-ends on AMXBPM. There’s the ability to deploy application families in multiple languages through localisation packs, too. There’s also version control for Applications.
If you’re using TCLA, then one of the compromises you make (in return for very rapid application development capabilities) is that you’re restricted to the default out-of-the-box, responsive web-based application user experience. You have no discretion over form layout, for example.
Operation and execution
With ActiveMatrix BPM, deployment from the development environment to the runtime environment is straightforward: deployment during development and testing can now be a simple operation, and even deployment to a live environment can be controlled via a simple script; all model elements required for a process application to run can be deployed as one integrated artefact (including ActiveMatrix Decisions rule definitions, which can be deployed at the same time as other project elements), or separately in staged or aggregate releases over time. Process models are automatically validated for completeness and BPMN conformance on deployment and during design-time.
Prior to deployment, Business Studio provides some useful testing facilities – including the ability to emulate the behaviours of process resources (people, external systems) during testing. There’s a debugging tool provided, too. In deployment, multiple versions of processes can be executed simultaneously, and individual steps within a process can also be executed independently of a running process instance, where required.
When it comes to operational administration, people with sufficient privileges will use the ActiveMatrix BPM Workspace or Openspace environment to carry out process-related administrative actions (such as starting, stopping and restarting process instances, redistributing work, reassigning tasks and so on; and mapping corporate LDAP directory resources to your organisational model).
If you’re using TCLA, then the runtime environment is tightly integrated with the development tools provided; you have the ability to test an application right within the development experience, and run your application even if not all the implementation details are fully specified; TCLA verifies the application logic for consistency when you do this. Deploying an application is a simple ‘one-click’ matter of publishing into the production environment. You can carry out simple administration tasks on running cases in the Administrator tool within TCLA – for example you can lock and unlock cases, purge closed cases, and retry or delete halted processes.
As an alternative or as a complement to deploying automated processes using ActiveMatrix BPM or TCLA, you can deploy Nimbus process maps to its server to create ‘How-to Guides’ that staff can use as online guides for their process work. Today, individual tasks within Nimbus process maps can provide online links not only to widely-used packaged applications like those from SAP; but also that link to automated processes managed by ActiveMatrix BPM.
Monitoring and improvement
If you’re using AMXBPM then administrators will conduct real-time monitoring of individual process instances for administration and optimisation purposes through an Event Viewer provided within both Workspace and Openspace that can be used to filter and correlate events.
If you want to explore AMXBPM process performance more deeply, you have a couple of options:
- ActiveMatrix BPM Spotfire. Runtime events from the ActiveMatrix BPM platform populate the in-memory analytic database underpinning Spotfire, and the Spotfire user interfaces present dashboards that allow administrators and managers to explore views of process and work performance. Alerts, KPIs and thresholds can be defined on the fly without the need to use specialist tools. ActiveMatrix BPM Spotfire can perform predictive alerting – highlighting if it looks like a predefined metric is going to go out of range, for example – and it’s also possible to estimate the amount of time it will take a given process instance to complete, based on interactive analysis of past performance. There’s also now the ability for Spotfire dashboards to surface recommendations and actions – so administrators can quickly take action to resolve issues, redistribute work or improve performance.
- JasperReports for AMXBPM. Here, you can generate performance reports from process measurements and also from instance- (case-)specific data managed by AMXBPM. You can combine reports into dashboards, and make them available to users via Openspace or custom web applications. It’s also possible to back-link from reports and dashboards to your AMXBPM applications, so you can drive behavioural interactivity (to, for example, enable people to quickly explore problem causes).
Today there’s no capability within TCLA to monitor case or process performance. It is possible to migrate operational data from TCLA to Spotfire Cloud, with help from a technical TIBCO specialist; today it requires use of an undocumented API. However TIBCO does plan to provide a fully-supported integration between TCLA and Spotfire Cloud in future.
In the context of ActiveMatrix BPM, process models and other related application artefacts are stored by Business Studio in Packages. Packages themselves (stored as XPDL files) are managed within the scope of Projects, which are the top-level construct in Business Studio. Business Studio uses a generic file-based source code management system for version control of assets, and so at the moment capabilities like change impact analysis could be much stronger – particularly in the context of supporting multi-developer and analyst teams. With Business Studio you can visually compare different versions of a process model to identify changes, though, which is useful.
When it comes to capabilities that explicitly help you to manage AMXBPM processes through their lifecycle, there are some important strengths to hand. Staged deployment of processes at scale is made easier by there being a clear distinction between process versions that are ‘deployed’ and ‘active’, and the ability to migrate existing process instances to new versions in the context of administrator-defined migration rules. Packages representing complete process applications can themselves be versioned, independently of the model artefacts they consist of. There’s the ability to create and manage libraries of components for reuse across projects; these libraries can contain any kind of process application artefact. You can also manage multiple application design repositories and share models and components across them; Business Studio creates and manages any cross-project references for designers.
Business object models and organisation models you create to underpin ActiveMatrix BPM process applications can be reused and ‘subclassed’ across projects, making it possible to deliver multiple variants of these models based on common parentage. However there’s currently no similar concept supported for subclassing of process models.
If you’ve licensed ActiveMatrix BPM Spotfire as well as Nimbus, within Spotfire you can also create visualisations of design and improvement activity within your Nimbus implementation – exploring opportunities for process change by being able to find out which elements of process maps have changed most frequently, for example; or which parts of maps have the most comments assigned to them over time.
If you’re using TCLA, then the facilities on offer are currently much more limited, although applications are versioned (with version lifecycles being controlled by authorised administrators) and upgrading in-progress instances to new versions is very simple.
Using the products: support for different kinds of work
Facilities to support automated work
In the context of AMXBPM, facilities to support the full automation of work (not just of work orchestration) are strong. In process modelling, support for definition of sophisticated error handing logic (including compensation) is fairly good, as is the ability to specify transactional behaviour – you can specify a sub-process as a transaction, and the operations in that subprocess will be executed using the transaction protocol defined in the runtime environment.
The degree to which running processes can be influenced by – and can influence other systems through – events is a key strength of the platform in support of automated work scenarios. The fact that a lot of sophisticated event-based behaviours can be specified without coding makes this capability even more useful.
Scaling the AMXBPM platform for high-throughput automated work scenarios is also something TIBCO has paid a lot of attention to: the runtime environment can be straightforwardly clustered and scaled, with individual components (web server, work manager, process manager) independently clustered and distributed. The underlying runtime platform supports ActiveMatrix BPM multi-tenancy in a sophisticated way; a single platform instance can maintain multiple tenants running on multiple versions of ActiveMatrix BPM, with the ability for administrators to upgrade tenants individually. There’s also in-built platform support for TIBCO Hawk, the company’s systems monitoring and management tool.
The core of TCLA is not designed to run straight-through work processes, and so the kinds of features and capabilities described above are not present today. TCI, which is licensed along with the Professional and Enterprise versions of TCLA, does deliver the ability to automate integration flows end-to-end however.
Facilities to support transactional work
All the bases required to support transactional work are covered well in ActiveMatrix BPM – with the ability to distribute tasks based on organisational model queries, calendars and workflow patterns being a real strength. Task forms can currently be generated either using the Google Web Toolkit or using the AJAX-based General Interface framework; the implementation of the ‘page flow’ concept is also significant. A new ‘singular inbox’ feature provides a unified front-end for task lists that span multiple business process applications.
Support for the CMIS standard is important in support of transactional work scenarios. Integration of a process application with a CMIS-compliant content or document management platform is relatively straightforward, and currently the integration has been validated by TIBCO against Microsoft SharePoint and Alfresco. New in 4.2 is an “internal CMS” called the TIBCO DocumentStore, that application developers can use to develop and test case management application functionality.
ActiveMatrix BPM also works well to support dynamic behaviours that help in demanding implementations of transactional work. You can configure the ActiveMatrix BPM runtime environment so that on-the-fly prioritisation changes between process instances are automatically made, to try and ensure that SLAs you define that are determined to be ‘in jeopardy’ are reached; and if you need to, it’s also possible to have the platform make on-the-fly changes to the way that process execution occurs, in order to ensure that goals are reached – for example tasks can be reassigned or escalated.
If you’re using TCLA, all the core bases are covered, although there’s nothing like the degree of sophistication offered here as you’ll find in AMXBPM. As described earlier, though, TIBCO’s implementation of common work distribution patterns in TCLA is welcome.
Facilities to support exploratory work
Over recent releases the facilities on offer to support exploratory work (through case management applications) have dramatically improved, both through enhancements to AMXBPM and the introduction of TCLA.
Remember that TCLA is specifically built to deliver case-centric applications; the core of the application framework revolves around case data, case states and milestones, and actions, tasks and processes that get initiated and progressed as cases pass through states within their lifecycles. This is a model that inherently and deliberately supports teams in carrying out non-linear work.
The past three releases of AMXBPM have also seen significant enhancements in this area. As well as enabling analysts to model Case Objects within the Business Object Model and have case data available from multiple processes running in the platform at execution time, there’s now explicit support for common case management application constructs, particularly:
- Any application (process or custom client application, as described in User interfaces above) can interact with case data models to create and reference case data.
- Case folders enable you to store documents (or references) associated with cases in an external CMIS-compliant content management system.
- Processes can subscribe to case objects; changes in case state then fire events that are handled through signal event handlers in those processes (where appropriate action can be taken).
- A case management gadget in Openspace makes it easy for users to search for cases, interact with and manage case data, view and manage related case documents, locate associated work items and process instances, perform case-specific actions, and update case data in an ad hoc fashion (for example, in response to an unsolicited customer request).
Also relevant here is an ActiveMatrix BPM concept called ‘compose for change’: here, in a suitably configured application, work participants can select from a library of process fragments at runtime, and compose them on the fly to deal with particular situations as they arise. Combining this capability with the global data repository means the creation of case management applications in support of exploratory work scenarios is much more straightforward than it was before.
Monitoring and improvement capabilities aligned with exploratory work are good. Business data from the global data repository can be referenced in monitoring dashboards, which gives you some ability to report on cases as well as individual processes; and moreover, the global data repository maintains an auditable event history for each data object – which provides a foundation capability to help specialists analyse the history of completed cases for potential improvements.
In addition to this it’s possible to report on work performance according to organisational models (group and team performance), which is helpful when looking for opportunities to improve work when structures are not completely set.
TIBCO has a strong global footprint. In the Americas it has direct presences in the US, Canada, Brazil and Mexico – with distributors covering other South American countries. There’s very strong local coverage across European countries, with direct offices in Belgium, Croatia, Denmark, Estonia, France, Germany, Hungary, Italy, Luxembourg, Netherlands, Norway, Poland, Portugal, Romania, Spain, Sweden, Switzerland, Turkey and United Kingdom. The company’s Middle East / Africa offices are in Dubai and South Africa. Across Asia TIBCO has offices in Australia, mainland China, Hong Kong, India, Indonesia, Japan, South Korea, New Zealand, Singapore and Taiwan with an additional distributor covering Vietnam.
TIBCO develops specialised industry-specific capabilities and content in Financial Services and Healthcare, and also runs a group dedicated to supporting companies wanting to license and embed its platform.
Much of TIBCO’s industry-specific content is delivered through Nimbus. Customers are encouraged to map their own organisation’s processes and align those to the appropriate industry reference or framework. Selected process maps can then be exported into Business Studio if required.
For financial services, TIBCO can provide process content relating to many common regulations – including the Basel/BIS account opening and customer identification guide; Dodd-Frank; FATCA; FINRA; Solvency II; Treating Customers Fairly; and more. For healthcare, TIBCO can provide process content relating to FDA regulations (clinical trials); NQF SP-15; HCIF PAVE; and more.
TIBCO’s principal consulting and implementation partners for its process application platform business are CGI, Logica and Infosys; it also has a strategic alliance and licensing relationship with Siemens Medical.
Platforms and connectivity
ActiveMatrix BPM runs on the ActiveMatrix platform, TIBCO’s own middleware runtime, rather than third-party Java EE application servers (or .NET infrastructure, for that matter). Connectivity with external applications, data sources and systems can be achieved directly using SOAP and REST web services or managed through BusinessWorks, which can be extended (on a chargeable basis) with a large range of sophisticated TIBCO adapters – including SAP, Siebel, Oracle, Salesforce.com, Clarify and PeopleSoft packaged applications; CICS, IMS, DB2 and VSAM systems on IBM mainframes and midrange platforms; COM, CORBA and EJB components. A full list of connectors for BusinessWorks (versions 6.x) can be found at https://community.tibco.com/wiki/connectors-activematrix-businessworks6x.
TCLA runs on the TIBCO Cloud, which is itself hosted on AWS. It’s currently available in the US, EU and Australia regions – meaning customers choose their location to minimize latency and/or opt for their preferred regulatory framework.