This report assesses the capabilities of OpenText’s Process Application Platform, and also examines the partners and intellectual property that OpenText 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.
Over the years following its acquisition of Cordys in 2013, OpenText made a marked shift in its BPM approach – and the company is continuing this shift as it moves beyond the current release of the Process Suite (16.3). OpenText’s Simplified Application Development experience hides much of the complexity exposed in the core design and development tools, and the unique approach taken here really supports iterative, collaborative design – and there are plans to further expand the role and capabilities on offer here. OpenText’s acquisition of Actuate in 2015 has delivered a more tightly integrated Process Intelligence offering; and thirdly, an optional Extended ECM module specifically designed for use with the Process Platform creates very close synergy with the OpenText Content Server (for those that want to use the two platforms together).
Support for different types of work
Automated work: A rich set of integration capabilities within the OpenText Process Platform – including an integral Enterprise Service Bus (ESB) and Master Data Management (MDM) technology – is combined with a very flexible event-driven engine to create very good support for the straight-through orchestration of automated systems.
Transactional work: Support for transactional work scenarios is very good. Rich organisational modeling and support for ad hoc task creation and assignment mean you can create flexible workflows and manage work distribution at scale. Sophisticated monitoring facilities can leverage the MDM features of the platform, meaning you can create context-rich reports and dashboards.
Exploratory work: Support for exploratory work scenarios is excellent. The Simplified Application Development experience is particularly suited to case management application creation, and the result can be very sophisticated; in addition, there are three optional Case Management Accelerators you can use.
Rapid prototyping / quick-start
OpenText’s Simplified Application Development experience offers an unique composition-based approach to application design, based around entity modelling that enables you to create simple applications quickly, and evolve them iteratively by adding highly configurable ‘building blocks’.
Your ability to manage change in the OpenText Process Suite will be largely a function of the degree to which your team is comfortable with more technical developer-focused tools. The tools on offer will be very familiar to mainstream software developers, but features to enable less technical people to manage change comfortably are lacking. Still, as long as you’re comfortable with developer-led change efforts, there are some good tools in the box that help automate application validation, packaging and deployment.
User experience options
As well as the standard option of a responsive HTML5 application user experience, OpenText offers a generic mobile task management app, and a particularly rich set of server APIs that enable you to build completely custom front-end applications on top of a Process Platform installation.
OpenText offers its Process Suite as an on-premise licensed product, but also offers hosting in the OpenText Cloud – and there’s the option to add Managed Services on top to create more of a fully-managed PaaS proposition. Great support for application multi-tenancy is a particularly strong point in deployment.
Inside OpenText’s platform
OpenText’s Process Application Platform offering revolves around the OpenText Process Suite, which provides a very rich set of design-time and runtime capabilities for creating and deploying sophisticated process applications. The Process Suite is available for deployment both on-premises and via OpenText’s Managed Hosting Services. The OpenText Process Suite is currently at version 16.3.
In addition OpenText offers a set of optional add-ons (see below) and Process Suite Applications. A range of professional services for process application implementation projects is also offered.
Key tools and capabilities
The main elements of the OpenText Process Suite are as follows:
- Process Platform. The OpenText Process Platform comprises multiple layers of capability that deliver ‘traditional’ business process application capabilities across design, operations and monitoring, along with case management application capabilities, an Enterprise Service Bus (ESB), a Master Data Management (MDM) capability, and Business Activity Monitoring (BAM) functionality. Release 16.3 sees continued refinement of the platform around its Cordys technology foundation, with specific focus on its ‘information-first’ application development toolset; and richer integration with the OpenText Extended ECM Platform.
- Process Intelligence. Now based on OpenText iHub technology (acquired with Actuate Corp.), this option provides interactive dashboarding, reporting and visualisation features – as well as alerting and escalation features – on top of the core BAM features provided by the OpenText Process Platform.
- Case Management Accelerators. As well as the case management application delivery capabilities in the core Process Platform, OpenText also provides a set of three complete application frameworks designed to accelerate the delivery of incident management, service management or investigative case management applications. Each framework bundles together a set of prebuilt design elements that provide a fully-functioning but generic application, which you can quickly customise with high-level visual configuration tools.
In addition, clients can purchase any of the following add-ons:
- ProVision. A well-established Enterprise Architecture and business process modeling tool.
- Capture Center. A document capture platform providing document classification, OCR, ICR and IDR functionality that integrates readily with OpenText’s Content Suite and Microsoft SharePoint.
- There’s also an expanding list of Process Suite Applications, pre-built on the Process Suite Platform. At the time of publication the principal applications available focus on Cloud Services Brokerage, Procurement Performance Management and Contract Management.
- Lastly, clients may want to take advantage of AppWorks Gateway. This is a set of RESTful APIs and developer resources across the broader OpenText Enterprise Information Management (EIM) product portfolio, to allow developers to easily create solutions that span the breadth of the portfolio.
User experience options
OpenText offers a fair degree of flexibility in how you deliver user experiences for process applications built using the OpenText Process Platform.
The default user interface is a responsive HTML5-based web application that can be very dynamically controlled by sophisticated role-based access control rules (if you choose to employ those). Depending on the elements you choose to build into your application, the user interface may present not only tasks and forms, but also team conversations relating to processes and cases, and embedded Content Server user interface widgets. Every application you build has its own web application user interface. In addition, if you choose, your application can use email to distribute process and case tasks (and where addressees have the required permissions, they can instigate application actions directly from those emails).
In addition there’s a generic mobile app that acts primarily as a task inbox and form container, built using Adobe’s Phonegap technology. Lastly, there’s a very comprehensive set of server APIs that expose almost every function of the server – making it possible to build very sophisticated, highly customised applications around a core Process Platform server.
The OpenText Process Platform is available as an on-premise licensed product, as well as via a hosted model. Customers can work with the Process Platform hosted on the public OpenText Cloud or via a private hosted service platform, and can elect to engage additional support services via an OpenText Managed Services contract.
If you decide to run the Process Platform on-premise, you’ll be administering a Java runtime environment. Currently, the OpenText Process Platform runtime platform is based on proprietary Java server technology – so you can’t deploy it on third-party application servers such as Tomcat, WebSphere or WebLogic. However OpenText plans to transition its platform to Apache TomEE in the near future.
The runtime platform has many strengths – in particular its level of support for distributed processing and clustering, via the Smart Services Grid. Although there are configuration steps that administrators have to follow, with configuration work you’ll have the ability to deploy process applications that scale well and reliably, across pools of server hosts. There’s also support for multi-tenancy, which makes the Process Platform particularly interesting for applications that might underpin commercial digital services of some kind.
Using the products: core capabilities
Rapid prototyping / quick-start
OpenText offers you two high-productivity application development options, both of which are oriented around support for case management scenarios specifically.
Firstly, there’s a set of three Case Management Accelerators, each of which is specialised to serving a particular kind of case management scenario (Incident Management, Service Request Management and Investigative Case Management). Each accelerator is a fully-functioning case management application, defining entity models, process models, rules, organisation models and so on: but using the supplied graphical customisation tools you can quite easily alter and extend the functionality, features and presentation of the accelerators to meet your precise needs.
Secondly – if you need to build an application that doesn’t fit what’s on offer with the Case Management Accelerators – OpenText now offers a new ‘simplified application development’ tool layer that enables you to quickly build functioning applications, starting by defining the information types (‘entities’) you want your application to manage.
The OpenText Process Platform’s new entity modelling capability isn’t just one new tool specifically for defining information types, though: it’s a completely new approach to defining all your application functionality which revolves around definitions of those entities. In defining a new application, you start by defining one or more entities (for example ‘customer’, ‘claim’, ‘order’), the data elements within each, and the relationships between them.
Then, you incrementally add behaviours and capabilities by ‘decorating’ these entities with modules of configurable functionality called ‘building blocks’. There are 24 building blocks you can use in the current release, including building blocks that you use to define entity lifecycles (comprising a set of stages and transitions between them), deadlines (that you can define against one or more stages or stage combinations in a lifecycle), tasks, rules, forms (for creating, viewing, updating and deleting entity instances), audit trails, reports, mobile experiences, and processes (that you can attach via lifecycle stages, rules and actions). A new ‘Activity flow’ process model representation is designed for non-specialists to use.
Importantly, your applications can function regardless of the particular number and combination of building blocks you employ and configure; this means you can very rapidly and iteratively build, test and experiment with features in collaboration with application users.
Mapping, modeling and application design
When designing process applications within the Process Platform, you’ll work principally through the Collaborative Workspace. This is a role-based design portal that houses all the editing and administrative tools that each given role defined in a system can access. In all there are around 60 individual tools on offer; business-focused designers might use only around 10 of these, though – including core tools focused on specifying business processes (using BPMN), forms, data models, integration interfaces, business rules and the like. Each editor creates its own type of XML-based specification document behind the scenes, and these documents are what form the source of your applications at runtime.
As an upstream exercise from detailed process application design, the Collaborative Workspace provides a number of specialised modeling tools to help you analyse the context for your process application projects. Specifically, you can create Value Chain Models, and use these within Business Context Models. Business Context Models relate value chain units together with categories of business processes, and also show how business partners fit into this context. Models you create here are purely for documentation purposes, however; they don’t play any role in how you manage processes or process applications, or in how you monitor processes or business performance.
When it comes to modeling processes themselves, the Business Process Model Editor tool enables you to specify all the standard BPMN constructs you’d expect (swimlanes, activities, gateways, timers, events, exceptions, and so on). You can specify KPIs and thresholds in the context of process models: in fact you can define objectives and customisable performance ranges at the level of activities as well as business processes, and as well as tracking process performance you can also track business data through the specification of ‘business measures’.
If you want to create high-level maps that contextualise processes, capture goals, business policies and constraints and so on, you can use OpenText’s ProVision modeling and architecture tool – and there’s a prebuilt import/export facility for transferring detailed BPMN models from ProVision to the Process Suite, although there’s currently no capability to keep models synchronised across ProVision and the Process Suite. Separately, there’s also the facility to import process models from other third-party modeling tools that support the XPDL standard.
In the OpenText Process Platform business rules are defined separately from business process models, based on the popular ‘decision table’ metaphor and designed using a dedicated rule authoring tool: rule actions can include business process triggering, further rule invocation, web services invocation, and alerting. There’s a simple business rule testing tool, too, and some rule debugging features. Business rule definition in the core Process Platform isn’t obviously open to business analysts, though, as it is in some competing technology platforms – you define rule expressions in XPath, for example.
New in 16.3, there’s a fine-grained, rule-based permissions framework that goes much further than influencing form presentation. Now, you can define context-specific behaviours that, for example, can limit the ability to edit or delete an entity based on other process data values, and/or on the user’s role.
Prior to release 16.1, the OpenText Process Platform was designed with the assumption that your process or case management applications would principally read and write data managed in other applications, rather than managing business data directly themselves. For this reason, the platform shipped with a Master Data Management (MDM) capability that enabled you to design an abstract data access layer for your applications. Since 16.1, however, OpenText has re-thought this approach. It now enables designers to create application ‘domain models’, comprising entities and relationships, that the Process Platform uses to manage application-specific business data directly. The MDM capability still exists, too, should you need it (see below).
When it comes to integration with external data sources and applications, you have three options at your disposal:
- You can use the pre-built Application Connectors on offer. There are pre-built infrastructure-level connectors for FTP, LDAP, email; and connectors for generic Java applications and popular relational DBMSs.
- If your application needs to access data from external sources, you can use the MDM platform that’s part of the Smart Services Grid (previously SOA Grid) layer of Process Platform to read and write that data – you’ll use Enterprise Data Objects (EDOs) as intermediate definitions that you can work with in your business processes and user interfaces.
- If you want your process applications to be able to invoke the capabilities of other OpenText platforms (for example Enterprise Content Management, Digital Asset Management, eDocs) you can address the REST APIs to these products provided by the AppWorks Gateway, via the REST or HTTP connectors provided within the Process Suite; or alternatively, you can connect directly to OpenText Content Server, OpenText Core, OpenText Media Manager, and Capture Center via out-of-the-box connectors.
Work assignment and distribution
Organisation models are a core part of the suite of models you’ll use to underpin your process applications; they’re used to drive runtime behaviour as well as for documentation purposes. Using the Organization Modeler, you create a model that relates users to organisation units, roles, and relationships (both hierarchical and informal). Organisation models can also be nested. When organisational models are published to the runtime platform, organisational units are known as ‘teams’; individual users are then assigned to teams by administrators.
When designing tasks within business processes, the assignment of tasks can then either be driven by the configuration of swimlanes in process models, or assignment can be done on a task-by-task basis using expressions that query the organisational model. Indeed, when modeling processes, you can create swimlanes by dragging organisational unit definitions onto your process model canvas. Using expressions, it’s also possible to specify custom (for example skills-based) routing rules for individual tasks. Also in the context of task assignment, there’s built in support for two common workflow patterns: ‘four-eyes’ (where, if user X works on task A, then they cannot work on task B) and ‘rendezvous’ (where, if user X works on task A, they should also be assigned task B). There’s also the ability to define business calendars to help drive work assignment. You can specify multiple business calendars, and assign them to different parts of organisational models.
When it comes to making tasks available to individuals or teams, there are two work delivery models: ‘inbox’ (where tasks are shown in the default Process Experience task list UI) and ‘email’ (where users are notified of tasks via email). Task forms are implemented using XForms. There’s a graphical XForms Designer tool, and if you’re using the entity modelling approach supported as part of the new ‘Simplified Application Development’ experience, you can very quickly create default form layouts directly from entity definitions. These forms can be further decorated to add dynamic behaviour – for example showing/hiding form sections depending on runtime context.
Recent enhancements to email work delivery allow rich styling in emailed task information, and the addition of contextual document attachments.
Operation and execution
The runtime environment for the OpenText Process Suite is formed of a ‘grid’ of modular middleware services, called the Smart Services Grid. Each service can be scaled up and deployed independently of the others; specialised services are deployed to execute (among other things) business processes, semi-structured cases, business rules, and integration logic. The platform is also designed to make it straightforward for clients to maintain multiple environments in parallel – for example development/test, staging and production.
Whether you’re using the new simplified application development experience or you’re using the ‘regular’ OpenText Process Platform, deployment into a test or live environment is fairly straightforward: you use the Application Deployer tool to package and transfer your application design documents to target servers or clusters, and you can optionally define and use deployment templates to speed up the process of deploying your application to different (or multiple) environments.
Prior to deployment, the Process Suite includes some useful testing and validation facilities for those using the development features of OpenText Process Platform directly. Whenever you publish or deploy an application all its constituent documents are validated for completeness and consistency. Dedicated testing tools are provided to help developers ensure the correctness of business rules, web services interfaces and operations, and data transformations. There’s also the ability to debug running business processes, via the Process Instance Manager – which is the core runtime administration tool within the Process Suite. As well as providing debugging facilities, authorised administrators can easily start, reset, terminate and adjust running process instances – for example skipping activities, reassigning tasks, and so on.
Monitoring and improvement
Process Instance Manager within the OpenText Process Platform is the tool you’ll use to carry out real-time monitoring of individual process instances. From here, you can quickly explore all running process instances, drilling into individual instances to explore their current state – and if you’re using business rules as embedded artefacts in a process, you can also drill in to explore the execution of decision tables within rule activities.
For more sophisticated instance performance monitoring you’ll use the Business Activity Monitoring (BAM) features of the platform, which enable you to deliver information to dashboards, comprising one or more views. You design dashboards as XForms using the dedicated visual Dashboard Designer tool. Each view featuring a graph or KPI is built using a ‘business measure’ – a query referencing an entity definition.
As an alternative, where you want to combine real-time and historical performance data to analyse process or case performance, you can use OpenText Process Intelligence (built on the iHub platform, acquired when OpenText bought analytics vendor Actuate in 2015). With OpenText Process Intelligence you can define interactive reports and dashboards, and in addition you can define sophisticated sets of alerting rules and actions that are associated with KPIs and thresholds you define (though these aren’t automatically transferred into OpenText Process Intelligence from the Process Platform itself – you have to manually re-enter the information).
Within the OpenText Process Platform, all the specifications that form the source for your applications are stored as XML documents – whether you’re talking about user interface definitions, process models, case models, business rule definitions, business object definitions, or KPIs.
The OpenText Process Platform has no version control features of its own, and instead delegates version control to third-party source code configuration management (SCCM) tools. A plugin for the popular Apache Subversion project is available out of the box. Each workspace you set up in the Collaborative Workspace design environment is associated with its own Subversion repository. With Subversion integrated into the Collaborative Workspace, check-in, check-out and versioning of design documents are handled seamlessly. What this does mean, though, is that there are no version management features that are more domain-specific on offer: for example there’s no tool on offer that helps analysts visually compare process model differences between versions. There’s a simple ‘where-defined/where-used’ impact analysis tool within the Collaborative Workspace, though.
The design and development tools that ship within the Collaborative Workspace all follow the principle that design documents can only be deployed to a runtime environment when they’re validated to be logically consistent – and each of the main design tools contains very helpful inbuilt features to validate the documents they create.
The Application Deployer tool creates application packages from the documents you specify within a workspace; and once the packaging is complete, it’s straightforward to install packages across multiple environments (for example transferring from a test environment to a staging environment, and onto a live environment). As with all the tools within the Collaborative Workspace, access to the Application Deployer is controlled by a robust authorisation scheme – meaning it’s straightforward to control who is able to deploy new and changed applications. When deploying new application versions, administrators don’t need to stop or re-start servers.
There’s no out-of-the-box features provided to help you create and manage libraries of shared application components (groups of related documents), but there is a tool that makes it straightforward to synchronise documents across multiple design workspaces.
The Process Platform’s entity modelling application design approach also brings support for design inheritance. Specifically: designers can take pre-existing entity specifications (including the building blocks that extend the capabilities of those entities), and create ‘subtypes’ of them. Subtypes can inherit behaviours and properties from their parents, but designers can also choose to override or extend inherited functionality. There’s also support for the concept of ‘entity customisation’, which enables designers to use existing entity definitions as templates on which to build customised copies.
Using the products: support for different kinds of work
Facilities to support automated work
When creating process applications that work ‘straight-through’, features like error handling, transaction control and compensation are crucial even though not always obviously so. The OpenText Process Platform does a good job here: there are sophisticated error-handling and system-event handling capabilities, and the BPMN concept of compensation is well-supported. There’s the ability to exert distributed transaction control over multiple web services calls in certain environments, too.
One of the areas where the OpenText Process Platform excels is the degree to which elements of the runtime platform can be dynamically invoked and configured at runtime. This means that if you have an automated work scenario that’s demanding in terms of its complexity, the OpenText Process Platform is going to be able to support you.
The foundation of the strength on show here is the fact that the runtime platform is composed of many specialised runtime services, all communicating via open interfaces connected to a standards-based service bus (the Smart Services Grid, f.k.a. SOA Grid). You can design applications so that running processes can be heavily influenced by, and can influence other systems through, events – events that are either gathered from the runtime environment itself, or from external IT resources.
Facilities to support transactional work
All the core functionality you need to implement transactional work scenarios is covered well by the OpenText Process Platform.
As mentioned in Mapping, modeling and design above, there’s the ability to distribute tasks to individuals or groups based on abstract specifications and logical constraints (for example organisational model queries, calendar queries, and popular workflow patterns). There are facilities to link organisational models to external LDAP directories or Active Directory instances, and synchronise information between them. As per the BPMN specification you can specify, and drive behaviour based on, task timers; and, via the specification of ‘escalation points’ in organisation models, you can have the runtime system automatically escalate or reassign overdue tasks.
OpenText offers an Extended ECM module specifically for the Process Platform – which creates a deep level of integration with the OpenText Content Server or OpenText Core (your choice) that provides some very strong document and content management capabilities to your applications. If you use OpenText Content Server then applications you create can be easily configured to have an associated Content Server Business Workspace, and via this, not only are document management capabilities surfaced natively within your Process Platform applications; but if you elect to enable it, all entities your application manages are also synchronised with that Business Workspace (and so all entity data and content can be managed under Content Server’s lifecycle controls). In addition, Process Platform application entities in this arrangement are then fully searchable from within Content Server. Furthermore: if you’ve also implemented Extended ECM for SAP or Salesforce, it’s possible to share Business Workspaces across these other domains with your process applications. If you elect to use OpenText Core you’ll have the ability to upload, download, delete, copy, move, share and version documents from within your applications using that platform.
With the sophisticated runtime APIs provided by the Process Platform, it’s possible – with some work – to have the system automatically make on-the-fly prioritisation changes between process instances, to increase the chances of business goals are reached. It’s also possible, through the same programmatic interfaces, to code dynamic behaviours such that individual instances are re-structured (for example, that certain activities are skipped) to ensure that performance goals are reached. The calculations determining such dynamic actions can be based on performance data gathered from running processes, or – as is the case with the BAM elements of the platform – also based on externally-managed business data.
Facilities to support exploratory work
As we already discussed in Rapid prototyping / quick-start at the start of this report, the OpenText Process Suite provides two routes to supporting exploratory work scenarios: an integrated case management application design capability, based around entity modelling; and a set of Case Management Accelerators.
The core of a case management application is modelled through one or more entity definitions, and corresponding entity lifecycle definitions (using the ‘lifecycle’ building block). You specify a lifecycle for each entity graphically, using the OMG’s Case Management Model and Notation (CMMN) specification – and through CMMN, you define stages, together with tasks and processes that are to be enacted optionally or mandatorily at certain lifecycle stages. A case can progress from one stage to the next based on user action, or on the basis of a certain event occurring; or (for example) when all activities contained within the first state are completed. Activities can be automatically chained together, or you can specify that case workers will ‘pull’ activities in a given sequence manually; or alternatively, you can also specify that workers can choose to initiate any activites within a given case state, purely on their own initiative.
At runtime, case workers – within constraints that may be placed on case execution at design time, as above – are empowered to conduct activities in ways that make sense for the particular case at hand. When authorised, case workers can transfer activities to their colleagues, choose to skip activities, and create and schedule new sub-activities. Case workers can also, where you configure the system to allow this, link cases together to create association references (and those links can also be broken by those with the right permissions).
The Process Platform provides some good monitoring and improvement features for Case Management applications, in support of exploratory work scenarios. The main enabler here is that OpenText Process Intelligence’s capabilities are equally able to monitor and report on the progress of cases, as they are to report on the progress of process instances – both constructs are ‘first class citizens’ as far as it is concerned. For example, it’s straightforward to create case dashboards that show all open cases, the performance of cases, and the outstanding case workload. Just as you can define KPIs for structured processes, you can do the same for cases – and have those KPIs provide the basis for reporting in the Process Intelligence environment. You can also build dashboards that run on queries that segment reporting based on case type or features, and that run on queries based on case-specific business measures; as long as these data are stored and accessible through the Process Platform’s MDM layer, you can use them to shape monitoring views.
As is the situation with structured processes, cases can also be archived within the OpenText Process Platform, based on policies you set. Archived cases and processes have their execution history and performance data retained, and this can be imported into the monitoring environment at a later time of your choosing. Although there are no targeted features to assist you should you want to take completed cases and use those as sources for templates for future case work, it’s straightforward to analyse the historical paths of completed cases and then construct a case model accordingly.
OpenText has a strong global footprint. In the Americas it has direct presences in Ontario, Canada; and in many states in the USA. In Europe there are offices in almost every country; across Asia OpenText has offices in China, India, Japan, Korea, the Philippines, Malaysia and Singapore. There are also direct offices in Australia, Brazil, Mexico and South Africa.
OpenText has focused industry programs for energy, engineering, construction, financial services, insurance, healthcare, legal, life sciences, manufacturing, media and entertainment, utilities and public sectors.
At a corporate level, OpenText has strategic partnerships with Microsoft, Oracle and SAP; and with Accenture and Deloitte. Specifically within its Process Application Platform business, OpenText has around 30 certified partners able to implement its technologies, including Counterpoint Consulting, Sunbonnet Partners, Capgemini, CSC, Getronics UK, Ekema IT, Accenture and Atos.