appdev – Page 2

bpmNEXT 2018: Application Development with ProcessMaker, Capital BPM, Camunda

Next-Generation Backendless Workflow Orchestration API for ISVs, ProcessMaker

Brian Reale and Taylor Dondich from ProcessMaker presented their new ProcessMaker.io product for a BPMN 2.0 workflow microservice API in the cloud, targeted at ISVs to add process management capabilities into their vertical products. This is intended to solve the problem of software vendors who want customized workflow features without having to embed a full BPMS platform. They provide a simplified Javascript process designer that ISVs can use to present to their end users, although a full BPMN designer could be used and the results imported into the environment, and there’s a simple task invocation interface that can be called from pretty much any language or environment via language-specific SDKs and generalized REST APIs. The demo showed creating a new environment, and walked through a Slack integration application where Slack becomes the task list user interface, and simple HTML forms are used as the task processing UI (which could be any UI environment). This is a developer tool, not an end-user or low-code tool; check out their github for SDK and connector code as well as samples, and their own site for videos and descriptions of use cases. There was some pushback on the use of the term “microservice”; it’s really a lean cloud-based BPPM engine in the cloud that provides fast, scalable, enterprise-grade workflow capabilities. Although I haven’t done any direct comparison, there’s at least some overlap with Camunda’s Zeebe.io offering.

CapBPM’s IQ no-code BPM development – Turning Ideas into Value, Capital BPM

Max Young from Capital BPM talked about their no-code code generator: a graphical environment that can import industry-standard models (including BPMN, but also from IBM BPM’s application format), augment with functions such as service calls and user interfaces, and export as a BPM application in a number of different formats including those that can be imported into BPMS vendors’ products, or open source code. The demo showed how they can start with an application template that includes process and data models, then have the tool use AI to suggest UI layouts and other application parameters. There are a number of analysis tools for simulating processes, visualizing interactions between components (such as between a process model and a decision model). He created a process application from scratch, defining data fields, allowing auto-layout to suggest a visual form which he then modified to add logic to fields, and defining a BPMN process model to create an application shell. He then exported to both IBM BPM and Camunda BPM, which deployed the application to each of those environments and created application dashboards. The goal of this product appears to be to allow a broader range of people to rapidly develop BPM apps without being trained in the specific target BPM tool, with the resulting application passed off to a development team that will maintain it in the long term. For low-code tools such as IBM BPM, that may not be a perfect use case, but for products that are targeted at developers, such as Camunda, it might be a better fit as a UI and application code generator.

Monitoring Transparency for High-Volume, Next-Generation Workflows, Camunda

Ryan Johnston of Camunda presented on their Zeebe.io product, which (like the new ProcessMaker.io offering discussed above), is a microservice orchestration engine, but more specifically monitoring the performance of Zeebe by pairing it with Camunda Optimize to create heatmaps and other reports. The demo is based on a stock market pairs trading arbitrage use case, where a third-party process detects arbitrage opportunities and sends a signal that instantiates a Zeebe process; this process calls services to calculate the risk, calculate the long/short positions, and execute the trade. Speed and volume are key since rapidly changing market conditions could impact the effectiveness of the trade, hence the requirement for a high-performance engine like Zeebe, but also the need to monitor performance. The Zeebe Simple Monitor is the first of the administration tools being ported to this environment from the main Camunda product, providing a lighter-weight version of Cockpit. Camunda Optimize is used directly to view Zeebe performance, with the ability to create reports and assemble them into dashboards that show metrics such as flow node distribution (in pie chart, heatmap and tabular format), process instance count, and raw process instance data. He also demonstrated alerts, which can notify (by email) when specific values hit certain milestones, such as process instance count exceeding a value. He finished with one of Camunda’s fun add-ons, which is a video game view of a process model that allows you to walk through a 3D representation and shoot to kill process instances. Interesting audience question on using Zeebe as a smart event bus in addition to standard process applications at high volume.

Vega Unity 7: productizing ECM/BPM systems integration for better user experience and legacy modernization

I recently had the chance to catch up with some of my former FileNet colleagues, David Lewis and Brian Gour, who are now at Vega Solutions and walked me through their Unity 7 product release. Having founded and run a boutique ECM and BPM services firm in the past, I have a soft spot for the small companies who add value to commercial products by building integration layers and vertical solutions to do the things that those products don’t do (or don’t do very well).

Vega focuses on enterprise content and process automation, primarily for financial and government clients. They have some international offices – likely development shops, based on the locations – and about 150 consultants working on customer projects. They are partners with both IBM and Alfresco for ECM and BPM products for use in their consulting engagements. Like many boutique services firms, Vega has developed products in the course of their consulting engagements that can be used independently by customers, built on the underlying partner technology plus their own integration software:

Vega Interchange, which takes one of their core competencies in content migration and creates an ETL platform for moving content and processes between any of a number of systems including Documentum, Alfresco, OpenText, four flavors of IBM, and shared folders on file systems. Content migration is typically pretty complex by the time you consider metadata and permissions mappings, but they also handle case data and process instances, which is rarely tackled in migration scenarios (most just recommend that you keep the old system alive long enough for all instance to complete, or do manual migration). Having helped a lot of companies think about moving their content and process management systems to another platform, I know that this is one of those things that sounds mundane but is actually difficult to do well.
Vega Unity, billed as a digital transformation platform; we spent most of our time talking about Unity 7, their latest release, which I’ll cover in more detail below.
Vertical solutions for insurance (underwriting, claims, financial operations), government (case management, compliance) and banking (onboarding, loan origination and servicing, wealth management, card dispute resolution).

Unity 7 is an integration and application development tool that links third-party content and process systems, adding a consistent user experience layer and consolidated analytics. Vega doesn’t provide any of the back-end systems, although they partner with a couple of the vendors, but provide tools to take that heterogeneous desktop environment and turn it into a single user interface. This has a significant value in simplifying the user environment, since they only need to learn one system and some of the inter-system integration is automated behind the scenes, but it’s also of benefit for replacing one or more of the underlying technologies due to legacy modernization or technology consolidation due to corporate acquisition. This is what systems integrators have been doing for a long time, but Unity makes it into a product that also leverages the deep system knowledge that they have from their Interchange product. Vega can add Unity to simplify an existing environment, or come in on a net-new ECM/BPM implementation that uses one of their partner technologies plus their application development/integration layer. The primary use cases are federated enterprise content search (where content is indexed in Unity Intelligence engine, including semantic searches), case management applications, and creating legacy modernization by creating a new front end on legacy systems to allow these to be swapped out without changing the user environment.

Unity is all about rapid development that includes case-based applications, content management, data and analytics. As we walked through the product and sample applications, there was definitely a strong whiff of FileNet P8 in here (a system that I used to be very familiar with) since the sample was built with IBM Case Manager under the covers, but some nice additions in terms of unified interface and analytics.

Their claim is that the Unity Case Manager would look the same regardless of the underlying technology, which would definitely make it easier to swap out or federate content, case and process management systems behind the scenes. In the sample shown, since IBM Case Manager was primary, the case view was derived directly from IBM CM case data with the main document list from IBM FileNet P8, while the “Other Documents” tab showed related documents from Alfresco. Dynamic foldering can combine content from different systems into common folders to reduce this visual dichotomy. There are role-based views based on the user profile that provide access to data from multiple systems – including CRM and others in addition to ECM and BPM – and federate it into business objects than can include records, virtual folder structures and related objects such as people or claims. Individual user credentials can be passed to the underlying systems, or shared credentials can be used in connectors for retrieving unrestricted information. Search templates, system connectors and a variety of properties are set in a configuration console, making it straightforward to set up and modify standard operations; since this is an XML-based declarative environment, these configuration changes deploy immediately. The ability to make different types of configuration changes is role-based, meaning that some business users can be permitted to make changes to the shared user interface if desired.

Unity Intelligence adds a layer of visual analytics that aggregates data from the underlying systems and other sources; however, this isn’t just visualization, but can be used to filter work and take action on cases directly via action popup menus or opening cases directly from the analytics interface. They’re using open source tools such as SOLR (search), Lucene (information retrieval) and D3 visualization with good effect: I saw a demo of a Sankey diagram representing the workflow through cases based on realtime data that provided a sort of process mining view of work in progress, and allowed selecting dates for past views of work including completed cases. For case management, in which processes are semi-structured (at best), this won’t necessarily show process anomalies, but can show service interruptions and opportunities for process improvement and standardization.

They’ve published a video showing more about Unity 7 Intelligence, as well as one showing Unity Semantics for creating pivot tables for faceted search on content repositories.

Getting started with OpenText case management

I had a demo from Simon English at the OpenText Enterprise World expo earlier this week, and now he and Kelli Smith are giving a session on their dynamic case management offering. English started by defining case management:

Management of dynamic, unstructured processes
Processes are driven by events or human interactions to support faster, more accurate decisions
Decisions are tied to content and the case directs that content to the right conclusion

In their terms, a case is a transaction that is “opened” and “closed” over a period of time: resolve a problem, settle a claim, or fulfill a request. There may be many different types of participants required to complete the case, and a variety of content and data involved.

Similar to the approach of other vendors, OpenText equates “case management” with “vertical application development” to a certain extent, and getting to case handling quickly needs a blueprint to quick-start solution development. To that end, they provide an accelerator as part of Process Suite that includes a pre-defined case model and entities to provide a starting point for developing a case management application, particularly incident management or service requests. Essentially, it’s a sample app/template, albeit a well-structured one that can easily be modified for actual solutions; they have no illusions that this is going to be an out-of-the-box solution for anyone, but rather a guide for people creating new case management applications so that they don’t need to start from scratch.

If you refer back to the more complete description of AppWorks Low Code that I gave in the previous post, they have defined entities, forms, layouts and a case lifecycle that fit a wide variety of request-style case management applications.

Smith then gave us a demonstration of People Center — similar to what we saw her do on the main stage on Tuesday — and discussed how they used the case management accelerator as a starting point for developing the People Center application. They used some parts of the template pretty much as is — such as the request creation form — but made it specific to HR management and extended the capabilities to suit, including a dashboard specific to each role. Checklists and options are specific to the HR application, but as discussed in previous posts, those will persist through an upgrade of the underlying People Center application.

She also walked us through the case management accelerator in the development environment, showing the fairly complete set of entities, forms, layouts, action bars, lists, relationships, rules, email templates, BPM processes, roles and other objects, as well as how easy it is to modify them for your own use. For any partners in the audience, or even customer developers, this will resonate as a method of quickly creating a fully-customized application based on the template that addresses a specific vertical functionality.

OpenText Process Suite becomes AppWorks Low Code

“What was formerly known as Process Suite is AppWorks Low Code, since it has always been an application development environment and we don’t want the focus to be on a single technology within in.” – Dana Khoyi, architect of OpenText’s Process Suite

That pretty much sums up the biggest BPM positioning/branding announcement at OpenText Enterprise World 2017 this week. BPM is dead, long live low-code application development? Note that AppWorks is the name used for all OpenText developer tools; the technical developer APIs and access points, plus this low code product which is really a separate product.

Khoyi and Kelli Smith (who did the main stage People Center demo on Tuesday) led a session on the last day of Enterprise World to show how ~~Process Suite~~ AppWorks is used to create applications, starting with defining composite entities (business objects made up of multiple pieces of data), then UI constructs including forms, dashboards and lists. Because process and content are built into the environment, there are easy building blocks for content lifecycle, activity flow and history. Declarative rules are supported — triggered on conditions, events or user actions — and dropping out to a full process model for more complex flows and events. They also have a development framework for building customizable applications that persists customizations separately from the application and merges them at runtime, allowing a new version of the core application to be installed without discarding the previous customizations, although obviously you’d want to test and might require some minor retrofits.

Application development starts by defining the core entity for the application (think process or case instance class) then add properties (data fields) and building blocks: forms to edit and display those properties (as well as built-in properties such as state); lists that can be worklists or reporting artifacts; and layouts, which are essentially the application UI screens and can include the previously-created forms plus actions, breadcrumbs, and related content. Data/content security and access/update conflicts are handled automatically on the forms/layouts based on underlying security definitions. Apps that are created can be published immediately to run; these can be moved as packages between testing and production environments although it’s not clear that there’s any versioning or automation around that, so likely some manual governance is required.

Other building blocks that can be added to an application include:

A history log that maintains a complete audit trail of everything done during the instance including field-level data changes
A discussion for collaborative chat/comments on an instance
Content, which can be files/folders that are attached to the case instance using a local document store or other content store via a connector or CMIS, or a businses workspace within Content Server (using Extended ECM) which stores the content in CS and allows access from either environment while syncing properties between them.
Email templates that provide a form letter email capability for inbound/outbound email associated with the case
Three ways of managing work:

Lifecycle, which is a state machine-oriented view (i.e., milestones and the actions required to move between states) for a simple case workflow
BPM, for a full drop to the BPMN editor for complex process flows
Action flow, which is a simple sequence flow

Mobile app creation
Entity relationships

There’s a lot of stuff in here, and we didn’t see it all in this short session, but looks like a pretty robust environment for low-code development. Khoyi stated explicitly that this is becoming the development for all OpenText products, replacing the workflow capabilities in Content Server and Documentum.

Bridging the bimodal IT divide

I wrote a paper a few months back on bimodal IT: a somewhat controversial subject, since many feel that IT should not be bimodal. My position is that it already is – with a division between “heavy” IT development and lighter-weight citizen development – and we need to deal with what’s there with a range of development environments including low-code BPMS. From the opening section of the paper:

The concept of bimodal IT – having two different application development streams with different techniques and goals – isn’t new. Many organizations have development groups that are not part of the standard IT development structure, including developers embedded within business units creating applications that IT couldn’t deliver quickly enough, and skunkworks development groups prototyping new ideas.

In many cases, this split didn’t occur by design, but out of situational necessity when mainstream IT development groups were unable to service the needs of the business, especially transformational business units created specifically to drive innovation. However, in the past few years, analysts are positioning this split as a strategic action to boost innovation. By 2013, McKinsey & Company was proposing “greenfield IT” – technology managed independently of the legacy application development and infrastructure projects that typically consume most of the CIO’s attention and budget – as a way to innovate more effectively. They found a correlation between innovation and corporate growth, and greenfield IT as a way to achieve that innovation. By the end of 2014, the term “bimodal IT” was becoming popular, with Mode 1 being the traditional application development cycle focused on stability, well suited to infrastructure and legacy maintenance and Mode 2, focused on agility and innovation, similar to McKinsey’s greenfield IT.

Read on by downloading the paper from Software AG’s site; right now, it looks like registration isn’t required.

American Express digital transformation at Pegaworld 2016

Howard Johnson and Keith Weber from American Express talked about their digital transformation to accommodate their expanding market of corporate card services for global accounts, middle market and small businesses. Digital servicing using their @work portal was designed with customer engagement in mind, and developed using Agile methodologies for improved flexibility and time to market. They developed a set of guiding principles: it needed to be easy to use, scalable to be able to manage any size of servicing customer, and proactive in providing assistance on managing cash flow and other non-transactional interactions. They also wanted consistency across channels, rather than their previous hodge-podge of processes and teams depending on which channels.

AmEx used to be a waterfall development shop — which enabled them to offshore a lot of the development work but meant 10-16 months delivery time — but have moved to small, agile teams with continuous delivery. Interesting when I think back to this morning’s keynote, where Gerald Chertavian of Year Up said that they were contacted by AmEx about providing trained Java/Pega developers to help them with re-onshoring their development teams; the AmEx presenter said that he had four of the Year Up people on his team and they were great. This is a pretty negative commentary on the effectiveness of outsourced, offshore development teams for agile and continuous delivery, which is considered essential for today’s market. AmEx is now hiring technical people for onshore development that is co-located with their business process experts, greatly reducing delivery times and improving quality.

Technology-wise, they have moved to an omni-channel platform that uses Pega case management, standardizing 65% of their processes while providing a single source of the truth. This has resulted in faster development (lower cost per market and integration time, with improved configurability) while enabling future capabilities including availability, analytics and a process API. On the business side, they’re looking at a lot of interesting capabilities for the future: big data-enabled insights, natural language search, pluggable widgets to extend the portal, and frequent releases to keep rolling this out to customers.

It sounds like they’re starting to use best practices from a technology design and development standpoint, and that’s really starting to pay off in customer experience. It will be interesting to see if other large organizations — with large, slow-moving offshore development shops — can learn the same lessons.

Camunda BPM 7.5: CMMN, BPMN element templates, and more

I attended an analyst briefing earlier today with Jakob Freund, CEO of Camunda, on the latest release of their product, Camunda BPM 7.5. This includes both the open source version available for free download, and the commercial version with the same code base plus a few additional features and professional support. Camunda won the “Best in Show” award at the recent bpmNEXT conference, where they demonstrated combining DMN with BPMN and CMMN; the addition of the DMN decision modeling standard to BPMN and CMMN modeling environments is starting to catch on, and Camunda has been at the front edge of the wave to push that beyond modeling into implementation.

They are managing to keep their semi-annual release schedule since they forked from Activiti in 2013: version 7.0 (September 2013) reworked the engine for scalability, redid the REST API and integrated their Cockpit administration module; 7.1 (March 2014) focused on completing the stack with performance improvements and more BPMN 2.0 support; 7.2 (November 2014) added CMMN execution support and a new tasklist; 7.3 (May 2015) added process instance modification, improved authorization models and tasklist plugins; and 7.4 (November 2015) debuted the free downloadable Camunda Modeler based on the bpmn.io web application, and added DMN modeling and execution. Pretty impressive progression of features for a small company with only 18 core developers, and they maintain their focus on providing developer-friendly BPM rather than a user-oriented low-code environment. They support their enterprise editions for 18 months; of their 85-90 enterprise customers, 25-30% are on 7.4 with most of the rest on 7.3. I suspect that a customer base of mostly developers means that customers are accustomed to the cycle of regression testing and upgrades, and far fewer lag behind on old versions than would be common with products aimed at a less technical market.

Today’s 7.5 release marches forward with improvements in CMMN and BPMN modeling, migration of process instances, performance and user interface.

Oddly (to some), Camunda has included Case Management Model & Notation (CMMN) execution in their engine since version 7.2, but has only just added CMMN modeling in 7.5: previously, you would have used another CMMN-compliant modeler such as Trisotech’s then imported the model into Camunda. Of course, that’s how modeling standards are supposed to work, but a bit awkward. Their implementation of the CMMN modeler isn’t fully complete; they are still missing certain connector types and some of the properties required to link to the execution engine, so you might want to wait for the next version if you’re modeling executable CMMN. They’re seeing a pretty modest adoption rate for CMMN amongst their customers; the messaging from BPMS vendors in general is causing a lot of confusion, since some claim that CMMN isn’t necessary (“just use ad hoc tasks in BPMN”), others claim it’s required but have incomplete implementations, and some think that CMMN and BPMN should just be merged.

On the BPMN modeling side, Camunda BPM 7.5 includes “element templates”, which are configurable BPMN elements to create additional functionality such as a “send email” activity. Although it looks like Camunda will only create a few of these as samples, this is really a framework for their customers who want to enable low-code development or encapsulate certain process-based functionality: a more technical developer creates a JSON file that acts as an extension to the modeler, plus a Java class to be invoked when it is executed; a less technical developer/analyst can then add an element of that type in the modeler and configure it using the properties without writing code. The examples I saw were for sending email and tweets from an activity; the JSON hooked the modeler so that if a standard BPMN Send Task was created, there was an option to make it an Email Task or Tweet Task, then specify the payload in the additional properties that appeared in the modeler (including passed variables). Although many vendors provide a similar functionality by offering things such as Send Email tasks directly in their modeling palettes, this appears to be a more standards-based approach that also allows developers to create their own extensions to standard activities. A telco customer is using Camunda BPM to create their own customized environments for in-house citizen developers, and element templates can significantly add to that functionality.

The process instance migration feature, which is a plugin to the enterprise Cockpit administration module but also available to open source customers via the underlying RESET and Java APIs, helps to solve the problem of what to do with long-running processes when the process model changes. A number of vendors have solutions for this, some semi-automated and some completely manual. Camunda’s take on it is to compare the existing process model (with live instances) against the new model, attempt to match current steps to new steps automatically, then allow any step to be manually remapped onto a different step in the new model. Once that migration plan is defined, all running instances can be migrated at once, or only a filtered (or hand-selected) subset. Assuming that the models are fairly similar, such as the addition or deletion of a few steps, this should work well; if there are a lot of topology changes, it might be more of a challenge since there could need to roll back instance property values if instances are migrated to an earlier step in the process.

They have also improved multi-tenancy capabilities for customers who use Camunda BPM as a component within a SaaS platform, primarily by adding tenant identifier fields to their database tables. If those customers’ customers – the SaaS users – log in to Cockpit or a similar admin UI, they will only see their own instances and related objects, without the developers having to create a custom restricted view of the database.

They’ve released a simple process instance duration report that provides a visual interface as well a downloadable data. There’s not a lot here, but I assume this means that they are starting to build out a more robust and accessible reporting platform to play catch-up with other vendors.

Lastly, I saw their implementation of external task handling, another improvement based on customer requests. You can see more of the technical details here and here: instead of a system task calling an external task asynchronously then wait for a response, this creates a queue that an external service can poll for work. There are some advantages to this method of external task handling, including easier support for different environments: for example, it’s easier to call a Camunda REST API from a .NET client than to put a REST API on top of .NET; or to call a cloud-based Camunda server from behind a firewall than to let Camunda call through your firewall. It also provides isolation from any scaling issues of the external task handlers, and avoids service call timeouts.

There’s a public webinar tomorrow (June 1) covering this release, you can register for the English one here (11am Eastern time) and the German one here (10am Central European time).

bpmNEXT 2016 demos: Appian, Bonitasoft, Camunda and Capital BPM

Last day of bpmNEXT 2016 already, and we have a full morning of demos in two sessions, the first of which has a focus on more technical development.

Intent-Driven, Future-Proof User Experience – Malcolm Ross and Suvajit Gupta, Appian

Appian’s SAIL UI development environment. Build interfaces with smart components that detect the capabilities of the runtime device (e.g., camera, Bluetooth) and enable/disable/configure components on the fly. Supports a variety of UI rendering architectures/frameworks for desktop, and generates native mobile apps for Android and iOS. Directly supports their underlying constructs such as Records and process models when building forms. Dynamic content based on selections and data on form. Fast rebranding of forms with color and logos. Full functionality on mobile devices, and offline support via caching data down to device, and saving any offline transactions to automatically synchronize when reconnected. Switch between design (tree/graphical) view and code view in IDE to support different technical capabilities of UI designers. Not a focus on BPM per se, since Appian is repositioning as more of a process-centric application development tool than BPMS, although used as the UI development environment for their process applications.

Continuous Integration: Tools to Empower DevOps in Process-Based Application Development – Charles Souillard, Bonitasoft

Embodying continuous integration for live updates of applications, enabling easier development and automated testing supported by Docker images. Demo of simple shopping cart application created using BonitaBPM, with a combination of forms, pages, layouts, custom widgets and fragments that can be rendered on desktop and mobile devices. Underlying BPMN process model with human activities connected to UI artifacts. Versioned using Subversion. The continuous integration functionality monitors checked-in changes to the application and integrates them into the dev/test repository to allow immediate testing; in the demo, a new input parameter was added to a process step; the updated code was detected and tested, with testing errors raised due to the unknown parameter. Potential to accelerate the dev-test cycle, since code can be checked in by developers several times each day, with the results automatically tested and fed back to them.

Combining DMN with BPMN and CMMN: The Open Source Way – Jakob Freund, Camunda

Camunda’s “developer-friendly” BPM for developers to add process, case and decision capabilities to their applications. Their DMN decision tables allows changing decision tables at runtime for increased agility, depending on binding specified by process designer. Decisions executed as decision tasks from a process are logged as part of process history, and visible in their admin Cockpit interface to trace through decisions for a specific process instance. DMN engine also available outside decision tasks in a process, such as a REST API call from a form to dynamically update values as parameters change; when deploying a table, both a public ID for executing the table and a private ID for editing the table are generated for the REST access. Nice traceability directly into the decision table, and fast changes to production decision tables. Open source, with a free (non-production) DMN cloud version. Extra points for creating an online dungeon game using BPMN, and playing a round during the demo.

Appian Around The World – Toronto

Appian was recently doing a round of road-show conferences, and when they landed in my backyard, I decided to stop in for the day and see what was new. I missed Appian World this year and was looking forward to a bit of a product update as well as some of the local customer stories.

The day started with Edward Hughes, SVP of sales, giving us a high-level overview of Appian and their BPM platform-as-a-service and case management products (for the non-customers in the audience), as well as their shift to becoming more of a broad application development platform rather than just a BPMS. I’ve been seeing this trend with many BPM vendors over the past few years, and Appian has been repositioning this way for a year or two already. Using Appian as an application development platform allows applications to be developed independently of the deployment platform, both on server side (e.g., develop on the cloud version, deploy on premise) and for client interfaces on desktops or mobile devices. The messaging is that you can use their platform to create customer service applications “beyond CRM” to handle the entire customer journey, with a unified interface plus a consolidated view onto enterprise data using their Records function. He also talked about the Appian App Market, which is an expanded version of their Appian Forum, containing add-in components and complete applications from Appian and third parties.

Since it was a small room, the local customers introduced themselves and talked about their Appian experience and applications: 407 ETR with 10 apps integrated with their customer portals so that online actions (e.g., acquiring a new transponder) become Appian processes assigned to the 125 internal users; Manulife, the first Appian cloud customer back in 2008, now migrating their “legacy” Appian apps to the Tempo UI and serving 900 users for work/time tracking and records management in Marketing; and IESO with apps to register and manage information about energy companies participating in electricity markets. We also heard from some of the partners attending: TCS, Princeton Blue, and boutique contender Bits In Glass with 15+ Appian-trained people in Canada and the US. Bits In Glass used to do mostly code-level (Java) bespoke development, and have reduced their efforts and timelines to 1/3 of that using Appian’s model-driven development.

Next up was Michael Beckley, describing his new role as Chief Customer Officer (as well as CTO) as well as giving us a product update on the 7.11 quarterly release. Appian is seeing corporate IT budgets as 20% innovation and 80% maintenance, but they want to flip that ratio so that maintenance is much less expensive than the original build, freeing up time and energy for innovation. Most large enterprises aren’t going to get rid of custom applications, but they do need to make them faster to build and maintain, while enforcing strict security and providing a user-friendly interface for internal and external users. In theory, an integrated application development such as Appian provides all the pieces:user interface, reports, rules, collaboration, process, on-premise cloud, mobile, social, data, content, security, identity, and integration; in practice, most organizations end up doing something outside the model-driven development environment, although it can definitely improve their custom development efforts. Appian’s focus, as with many of the other BPMS vendors pivoting to become app dev vendors, is on providing a platform to build process-centric applications that get things done via automation, with people injected into the process where required.

Beckley gave us a hint of their growth strategy: they tend to build rather than buy in order to keep their technology pure, and since growth by acquisition inevitably requires a large (and underestimated) effort to integrate the new technology.

Here’s a quick list of the Appian 7.11 updates (some of these likely came before 7.11, but I haven’t had an update for a while):

Three UI styles for Appian apps: the Tempo social interface, Sites limited-function workspace/worklist for heads-down workers, and Embedded SAIL to embed Appian functionality within an existing portal for internal or external users. Sites have Action Forms for fit-for-purpose apps when a social feed UI isn’t appropriate, and Embedded SAIL has Action Forms for customer-facing apps within a third-party web portal. These latter two are critical for real-world enterprise applications: although I like the Tempo interface, many of my enterprise clients need a different sort of view for heads-down workers, which can be provided by Sites or using Embedded SAIL.
A number of improvements to the Tempo news feed and UI, including the Tempo Kudos view to promote collaboration and provide awareness of accomplishments, dynamically-updating filters to better link and manage record data and underlying data sources
Improvements to SAIL, including positioning it as a device-independent UI that provides shared model experience (rather than an HTML5 gateway into an existing app as seen in some other mobile-enablement technology) that is natively rendered on each device. The rendering engine can be updated independently of the applications, making it easier to adapt to new OS versions and devices. Appian uses SAIL to build their own components and apps that become part of the product. From a developer functionality standpoint, SAIL has added placeholder text and tooltips on forms, auto first field focus to reduce clicks and improve efficiency, additional image sizes that are auto-scaled to the device, initially-collapsed form sections, “submit” links that can be placed on a graphic element instead of standard buttons, links in milestones and pickers, grid enhancements, and continuing speed improvements. There’s also a new barcode component, although on iOS only and requiring a Verifone device for capture.
Mobile offline actions use native encrypted data containers rather than HTML5 storage (some of this is iOS only although Android is planned for later this quarter), with the developer deciding which actions and data are available offline. Changes to the definition of a form while a user is offline will prompt the user to review and resubmit the form with the new/updated form field definitions, so application changes can continue even if there are active offline users. This does not (yet) allow existing records to be locked for offline updates, although tasks can be locked to user before going offline.
For designers, the developer portal is being migrated to SAIL and enhanced with build processes; there’s a UI designer navigation tree to allow view/select/edit within a hierarchical tree view of an action form; the expression rule designer (“for those of you who are still writing expressions”, namely power developers) auto-suggests rule inputs and there is some level of expression rule testing; a process report designer can be used to create performance reports; impact analysis reports show where rules are invoked and other object relationships; bulk security updates can be made across objects.
For administrators, a big new thing is LDAP/SAML authentication with multiple LDAP servers and complex configurations.

They have frequent product update webinars , free introductory courses and tips & tricks sessions online; in fact, there is a product update webinar tomorrow if you want to hear more about what I’ve listed above.

We heard from Rew Dickinson, a solutions consultant, on what makes a great app — complete with a live demo to show us how it’s done. There were a lot of best practices here that I won’t repeat, better for you to check out one of their webinars, but a few key pointers:

Design applications to be omni-channel and easily adaptable.
Use Records to organize and model corporate data, regardless of source, for use in an application; bidirectional links between Records and process instances allow for a full view whether you’re coming from the process or data side of things.
Use Sites for fit-for-purpose applications, e.g., a worklist for heads-down task execution, as an alternative to full Tempo environment. Effectively, this is a report that can be sorted and filtered, with links to tasks that takes the user to the task form; it can include work management analytics for a manager/dispatcher user to monitor and reallocate task assignments. This made me think that Appian has just reinvented their per-application portal mode with Sites, albeit with better underlying technology, but that’s a discussion for another day.
Use Embedded SAIL for customer-facing portal environments, e.g., create service request from a customer order page.

Michael Beckley came back to talk to us about Appian Cloud, that is, their public cloud offering. It uses Amazon AWS/EC2/S3 in a single-tenant architecture, which allows each environment to be upgraded independently — more of a managed hosting model. The web tier is shared and handled by Appian, who also manages servers, load balancing, high availability and upgrades. There can be a VPN tunnel to on-premise data, and in fact the AWS instance does not have to be available on the public internet, but can be restricted to access only through the VPN from a corporate location. This configuration provides the elasticity and availability of the Amazon cloud, but allows private data to remain on premise — something that goes a long ways to resolving geographic data location issues. They’ve obviously been working on the optics of US-owned data centers by listing their privacy chops, but it would have been even more reassuring to see a mention of any Canadian standards such as PIPEDA for this purely Canadian audience. There are tiers for development, medium, large and extra-large deployments, with a redeployment to move between tiers (so not that elastic…) but it supposedly only takes a few minutes if planned. Uptime this year is mostly 5 9’s, with customer credits for missed uptime SLAs. You can also self-host Appian in other environments, e.g., Azure, although the Appian Cloud SaaS offering is currently Amazon only.

We finished up with Mike Cichy, an Appian consultant, discussing their center of excellence offerings and how customers can plug into the vast wealth of information, from checklists to migration guides to training in order to embody best practices. There are a number of tools available such as the Appian Health Check and Deployment Automation in addition to these practices, with an overall goal to help achieve a large improvement in developer speed and quality within customer/partner organizations.

Altogether an informative day, and great catch up with some old friends.

Pega 7 Express at PegaWORLD 2015

Adam Kenney and Dennis Grady of Pega gave us the first look at Pega 7 Express: a new tool for building apps on top of the Pega infrastructure to allow Pega to push into the low-code end of the BPM/ACM market. In part, this is likely driven by the somewhat high degree of technical skill that has traditionally been required to create applications using Pega, but also by the fact that customer experience is becoming a key differentiator, creating the need to create good customer-facing applications faster. Customer experience, of course, is much more than just the type of apps that you’re going to create using Pega 7 Express: it’s new devices and methods of interaction, but all of these are setting the bar high and changing customer expectations for how they should be able to deal with vendors of goods and services. Pega 7 Express is part of the Pega 7 platform, using the same underlying infrastructure: it’s (just) a simpler authoring experience that requires little or no advance training.

We saw an introductory video, then a live demo. It includes graphical data modeling, form building and case configuration, all with multi-device support.

Call it end-user computer (EUC), citizen computing or low-code model-driven development, Express is addressing the problem area of applications that were traditionally built using email, spreadsheets and local desktop databases (I’m looking at you, Excel and Access). I’m not going to enumerate the problems with building apps like these; suffice it to say that Express allows you to leverage your existing Pega infrastructure while allowing non-Java developers to build applications. They even include some badges for gamifying achievements – when you build your first app, or personalize your dashboard. Just-in-time learning is integrated so that you can see an instructional video or read the help as you need it, plus in-context guidance while you’re working.

In the demo, we created a new case-based app by specifying the following:

Application name, description and logo
Case type
Major phases (a straight-through process view)
Steps in each phase
Form design for specific steps – the data model is created behind the scenes from the form fields
Routing/assignment to reviewers and approvers
Milestones and deadlines
Device support

In part, this looks a lot like their Directly Capturing Objectives tools, but with more tools to create an actual executable app rather than just as input to the more technical Designer Studio development environment. We also saw customizing the dashboard, which was a pretty standard portal configuration.

As with any good Pega demo, however, Kenney went off-screen to “create a little data table” while Grady showed us the graphical form/case builder; they are definitely the masters of “pay no attention to the man behind the curtain” during demos, where one person does the user-friendly stuff on-screen, while a couple of others do a bit of heavy lifting in the background. Lucky for us (unlikely for Kenney), he couldn’t connect to the wifi so we did get to see the data table definition, which was straightforward.

This does look like a pretty usable low-code application development environment. Like any other low-code model driven development, however, it’s not really for complete non-techies: you need to understand data types, how to design a form, the concept of linking case types and separately-defined data types, and how to decompose a case into phases and steps. It wasn’t clear from the brief demo how this would interact with any sort of expected case automation or other parts of the underlying Pega infrastructure: predictions, automated steps/service calls, more complex process flow or temporal dependencies, access control, etc. It’s also unclear any sort of migration path from Express to the full Designer Studio, so that this could be used as an operational prototyping tool for more complex development. They did respond to a question about reporting; there is some out of the box, and they will be adding more as well as adding ad hoc

Pega 7 Express was announced today, with the cloud version available starting today, with a 30-day free trial followed by subscription pricing; when Pega 7.19 rolls out to on-premise installations, it will also offer Express. They’re not really pushing it yet, but will start to roll out the marketing around it in Q3.