K2, PowerApps and Flow: When and Why?

Since Microsoft released PowerApps and Flow in 2016 there have been a lot of questions about how these new tools compare with K2.

Do PowerApps and Flow do the same things as K2? Are PowerApps and Flow a competitor to K2. Can they be used together?

For businesses making the important decision on what process automation platform to use, these are relevant and critical questions. If you are an Office 365 customer you may already have PowerApps & Flow available, and you will need to evaluate these tools to see if they meet your needs.

At the first glance, PowerApps and Flow display a list of similarities when doing a feature comparison with K2. Both offer connectors to allow you to get data from your business systems, a forms designer and a workflow engine.

Both can also be classified as low code platforms.

However, there are a few key points of difference between PowerApps/Flow and K2 that you need to consider before embarking on your process automation journey.

While it will take thousands of words to describe all differences, this introductory article will focus on two of the most obvious differences.

Firstly, K2 has more a more advanced design experience in most areas of the stack, making it faster and easier to build more complex form and workflow scenarios to address the business problem at hand.

Secondly, and most importantly, K2 is a mature Business Process Management (BPM) platform, which means that it not only offers the tools to build more advanced process automation applications, but it also has tools to manage and analyse your applications. This is a very important consideration in evaluating automation platforms that can get overlooked.

Let’s explore these two points of differentiation in more detail.

Design and Build Experience

I am not going to dive into a detailed technical feature comparison between PowerApps/Flow and K2 for a couple of reasons.

One is that the landscape for both platforms is constantly evolving, with more features being added for both all the time, making a comparison done today redundant tomorrow.

The other is that when assessing the suitability of a toolset it is more important to look at the type/s of process automation application you are looking to build.

What do I mean by “type/s of business process applications”?

The following diagram provides a useful reference point for answering this question. The process-driven application landscape/framework below leverages some of the application portfolio management concepts in Gartner’s Pace-Layered IT Strategy as outlined [1]

According to Gartner:

  • Systems of record — Established packaged applications or legacy homegrown systems that support core transaction processing and manage the organisation’s critical master data. The rate of change is low because the processes are well-established and common to most organisations, and often are subject to regulatory requirements. Systems of record have the longest life cycle, at 10 or more years.
  • Systems of differentiation — Applications that enable unique company processes or industry-specific capabilities. They have a medium life cycle (one to three years) but need to be reconfigured frequently to accommodate changing business practices or customer requirements.
  • Systems of innovation — New applications that are built on an ad hoc basis to address new business requirements or opportunities. These are typically short life cycle projects (zero to 12 months) using departmental or outside resources and consumer-grade technologies.

In the context of K2:

  • “Systems of Record” applications, which includes large business systems like SAP & Oracle (ERPs) are pre-packaged vertical applications which cost a lot to purchase, implement, and extend. Implementation of systems in this layer tends to be strongly IT led and often involves the software platform vendor by necessity. K2 can quite often fill some gaps in this space, for example by providing an alternate user interface for your SAP system and integrating it with other systems. These systems typically have rigid and tight business processes built into the system (for good legal and compliance reasons). Still, within the System of Record context, some organisations also choose to use K2 as the enterprise workflow layer in large-scale line-of-business system type, custom development projects.
  • “Systems of Differentiation” applications meet reasonably complex business needs that require integrations into other business systems and flexible reporting. These applications are typically developed to automate a business process which will provide the business with some competitive advantage, whether it be cost reduction, better customer experience or better decision making. Valuable intellectual property that differentiates the organisation from its competitors often lives in this application layer in organisations. Implementation of applications in this layer tends to involve business, IT and external consulting assistance as necessary. K2 plays very well in this layer, allowing business applications with medium and high complexity level workflow logic, sophisticated forms and advanced data integration to be built quickly with little or no code.
  • “Systems of Innovation” applications are typically simple workflow and/or form applications that solve a specific business need across a team or department. These applications are usually developed by individuals within the team or department and are cost effective to implement using widely available toolsets. This is also referred to by many as “citizen developer” type activity in organisations. With specific reference to the use of technologies like PowerApps, Flow, IFTT, and Zapier, we also see a rising trend around the creation of Personal Productivity Applications in this layer in organisations.


As the diagram above illustrates, K2 can play a meaningful role in any of these application layers, but its main strength lies in the “Systems of Differentiation” layer. PowerApps and Flow are mainly used in the “Systems of Innovation” layer.

One reason for this difference is that the K2 platform allows you to more easily design the medium and high complexity workflows and forms that “Systems of Differentiation” demand than PowerApps/Flow. Flow is designed to solve “If This Then That” type workflow problems. For example: “if a new account is added to a CRM system, then send an email”. Flow also does simple data orchestration well, using its large number of connectors it can respond data being created or updated in one system and then create or update data in another.

Flow can be very useful for personal or team-based workflows, such as sending notifications or reminders. However, when requirements start getting more complex – things like rework patterns, parallel paths, sub-workflows, multiple user actions (beyond approve & decline) and task escalations – implementing these in Flow often becomes quite difficult, where K2 can handle these with ease.

PowerApps is a “mobile first” forms platform, primarily used to capture and display data for a single data object (e.g. a SharePoint List). When you want to start doing things like creating complex user interfaces for desktops and mobile (e.g. displaying/updating from multiple data sources on different tabs, offline forms and sharing forms with external users) PowerApps often hits limitations that may be difficult to overcome without significant workarounds or custom development.

K2 uses a simple declarative form rule to drive form behaviour, whereas PowerApps requires Excel-like formulas to be used. Another aspect to consider is the ability in K2 to create reusable objects. K2 Forms, Views, SmartObjects, and Workflows can all be re-used in K2 across multiple applications, reducing your build time and making updates quicker and easier.

A final, and very important, consideration with respect to the design experience, is the management of the application development lifecycle. In K2 you can build an entire application (Forms, Views, SmartObjects and Workflows) and package that up and deploy to a test or production environment in a few clicks.

This is a powerful feature that lets you totally segregate your development, test and production environments and have full control over the deployment process and application development lifecycle.

I am sure we all know by now that almost anything is possible with most development platforms given enough time and energy. In practice, choosing the appropriate tool for the job is often the difference between success or failure though.

Process Management

So, you have built a business-critical process-driven application, released it into the wild, and it starts getting used in anger. Soon, the business starts asking questions like “How many workflow processes are running right now?”, “What happens if someone is on leave and cannot approve an urgent request?”, “By who and when was a particular request approved?”.

This is when having the tools and features that a proper BPM platform come in very handy.  K2 offers a comprehensive set of functionalities to manage your processes, including:

  • Out of Office notifications
  • Task list for all workflows
  • Task escalations
  • Task redirections and sharing
  • Working Hours
  • Workflow permission management (who can start, administer and report on workflows)
  • Workflow error management
  • Workflow version management
  • Workflow instance management – starting & stopping workflow, go to specific workflow steps
  • Workflow Reporting – workflow analysis and insight
  • Centralised and secured management interface
  • Design Permissions – control who can build and deploy applications

Microsoft PowerApps and Flow working with K2

A final thought to consider when looking at K2 and PowerApps/Flow is that they can actually work together quite nicely when building an automation application, utilising the strengths of each platform.

Take the example of a CRM system and an onboarding process for new accounts. A user can add a new account directly into the CRM system, however for the account to become active, we need an onboarding process to occur that involves verification from different business departments and data from other systems.

This workflow might have a parallel approval pattern with rework steps and inputs required from other systems (e.g. the account is added to the Finance system and the new account ID is input back into the CRM system by the finance team.). To implement this application, we need to monitor the CRM system for new accounts, and when one is added we need to start a reasonably complex account onboarding workflow.

Now, we could try and do all this using K2, or similarly by only using Flow/PowerApps.

To trigger the K2 workflow for account onboarding from your CRM system will probably require some sort of custom development in that system – not something you really want to do, but possible.

On the other hand, trying to create a Flow and PowerApp that implements the account onboarding process will quickly become very difficult and complex. In addition, you don’t get the additional benefits of things like task lists, out of office task redirection and task escalations. As the kid on the Old El Paso advert says, “porque no los dos?” (Why not both).

We could also expose the new account form in CRM as a PowerApp, allowing users out on the road to use their mobile device to add new accounts on the run. We could then use Flow connectors to monitor our Salesforce or Dynamics system for new accounts – there are out of the box connectors for these systems that are relatively simple to set up in Flow.

We could then use an action in Flow to start a K2 workflow to start a more complex business process to onboard the new account (involving legal and finance teams, and other LOB systems).  A Flow connector for ease of integration with K2, is available [2].  K2 SmartForms can be used as the task forms, exposing data from not just the CRM systems but other business systems as well.

This hybrid application approach is playing to the strengths of both platforms. Flow gives us the nice and easy way to monitor our line of business system by providing loads of connectors, PowerApps provides a mobile form for new account submission, and K2 gives us both an enterprise-grade workflow engine that can easily handle complex scenarios, and a user interface to allow task completion, as well as all of the other baked in platform, features such as task management and process reporting.

While Flow and PowerApps are constantly evolving and getting more and more features, the types of business problems they are focussed on solving are fundamentally different from the ones that K2 is aimed at. And while there is of course cross-over in the terms of functionality, you need to look at what type of business application you are building based on the application portfolio management approach chosen by your organisation. (i.e. is it a System of Innovation or Differentiation etc.?). Lastly, find a toolset that can deliver for not only your technical requirements but also provides features to let you manage your processes.

[1] Pace-Layered Application Strategy and IT organisational Design: How to Structure the Application Team for Success

[2] Microsoft Connector – K2 Workflow

Join the webinar on October 11th, 2018 at 3PM AEST to see a comprehensive overview of PowerApps and K2 and how when they work together to build an automation solution.

Register now


From Zero to Business App in the K2 Coud



If you’re cobbling together business workflows and across your most critical systems like Dynamics 365, Salesforce, SAP, Exchange, SQL Services, odds are there is room for improvement.

Inefficient communication, mountains of paperwork, inaccurate reports or data time delays disrupt the day to operations needed to keep an organisation running smoothly.

You need to be able quickly to build forms, workflows, and apps on-premise or in the cloud that are able to span your organisation while retaining an unparalleled level of flexibility and data quality.

Join us for this live webinar to learn how to rapidly build business solutions that deliver results.
During this webinar we will showcase:

• Quickly create standalone web and mobile apps to get mission-critical data to users anywhere, on any device, online or offline.

• Simply and easily connect your business applications to all your line-of-business data, on-premises or in the cloud.

• Reuse and modify your business applications as you go or as your business changes, with little to no code.

We’ll also share a demo showcasing how to build apps faster and smarter with intuitive drag and drop tools, from a basic process to a more layered, complex workflow.

K2 Cloud and Azure Function Apps

If you are looking at K2 Cloud or already using it, you will most likely be aware that you cannot create or use custom service brokers in this version of K2 (you can still do this in K2 Five). So, what do you do if you need to execute some custom code in K2? Azure Functions could be your solution. 

Azure Functions enable you to run code-on-demand without having to provision your own infrastructure. Functions can be written in a variety of languages (e.g. C#, JavaScript, Python) and can respond to a variety of events (e.g. HTTP Trigger, Service Bus Queue Trigger). As a K2 Cloud customer, you have an Office 365 subscription, which means you will also have an Azure subscription so you can get started with Azure Functions without any setup (See An introduction to Azure Functions for more details, including information on pricing) 

So how can you incorporate Azure Functions into your K2 solution? 

K2 and REST 

K2 now has a REST Service broker that allows you to integrate K2 with REST-based web services. A good explanation of what REST (REpresentational State Transfer) web services are can be found here. 

The REST broker is the key to working with Azure Functions. The K2 REST service works by reading a service “descriptor” file, called a swagger or OpenAPI file. A swagger file describes the methods and properties that a web service exposes, allowing K2 to create matching SmartObjects. I will provide options below on how to create the swagger file for our function. 

Azure Function Example 

Let’s look at a simple function example. Say as part of a solution you need to convert a number to character/s. So, for example, 1 becomes “A”, “2” becomes “B”, “26” becomes “Z”, “27” becomes “AA” and so on. You could try and do this with functions and expressions in a K2 form or workflow, but it would get quite complex. Or, you could write some code that does this, deploy it as an Azure Function and call it from K2 as a SmartObject. 

Here is some code that does what we need. It looks for a query parameter named “Number” and then uses a while loop and the modulo function to convert the number to characters.  

using System.Net; 


public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log) 


 log.Info("C# HTTP trigger function processed a request."); 


 // parse query parameter 

 string strNumber = req.GetQueryNameValuePairs() 

 .FirstOrDefault(q => string.Compare(q.Key, "Number", true) == 0) 



 int dividend = int.Parse(strNumber); 

 string columnName = String.Empty; 

 int modulo; 


 while (dividend > 0) 


 modulo = (dividend - 1) % 26; 

 columnName = Convert.ToChar(65 + modulo).ToString() + columnName; 

 dividend = (int)((dividend - modulo) / 26); 



 return req.CreateResponse(HttpStatusCode.OK,columnName); 


So how do we use this code in an Azure Function?

The first thing to do is open your Azure Portal and click the “Create a resource” button and choose “Compute” and the “Function App” 

Add the Function “App name” and set the other details. The Function App is a container for a number of functions – you can add more functions to your Function App later. You may need to create a Resource Group (see Manage Azure resources through portal for more info) if you do not have one you can use. 

Once you hit “Create” Azure will provision you with your function app and you will see the following  


Select “Go to resource” and start to edit your function app. 

We are going to choose to use the “Webhook + API” and “CSharp” option. We are using the webhook as this will let us trigger the function by an HTTP call. You can use any programming language you are comfortable with. 

A default function is created for you. Replace this function with the code above. You can then test this function by clicking the “Run” button. Add a number into the “Number” Query Parameter, click the “Run” button at the bottom right and view the result in the Output pane. Note that the log file also shows some entries indicating if the execution was successful, and outputs our “Log.Info” line from the code. 

Ok great, our function works, now how do we consume it in K2? 

Create Swagger File 

There are two choices for creating the swagger file. You can create a template in Azure and then manually update it, or create one from scratch from a tool like REST United (see Resources for Working with the REST Service Broker). 

I will not go into detail on how to create the swagger file, but have include a definition for the GetCharOfNumber function at the end of this post. 

(For a more detailed walkthrough of these steps see Create an OpenAPI definition for a function) 

To get a swagger template for your function app, expand your function and select the Integrate option, and make sure the “Get” HTTP method is selected. Set your “Authorization level” to anonymous for this exercise, and click “Save”. 

Now click on your Function App and select the “API definition” menu item. 

Click “Generate API definition template”, and the swagger template is generated for you 

You can now copy the template out into another editor or edit it directly in the azure portal.  

Once you have created your swagger file, you can choose to host it back in the Azure portal, or in any other location accessible by your K2 Cloud instance. 

If you want to host it back in Azure, you can overwrite the template with your swagger and Save. The API Definition URL can then be used when creating your REST service instance.

Create REST Service Instance 

Open K2 Management and create a new REST Service instance. Add in the swagger location into the Descriptor location and use the Service Account as the Authentication Mode. All other settings can be left as default. Click the option to generate the SmartObjects (or leave unticked and create later) and then Ok to create the service instance. 

Once the SmartObject is created, it’s time to test it. Find it under the Categories in the Management site and execute the “GetCharOfNumber” method.  


"swagger": "2.0", 

"info": { 

"title": "Azurewebsites", 

"description": "API for <yourfunctionappname>.azurewebsites.net", 

"version": "0.0.0" 


"host": "<yourfunctionappname>.azurewebsites.net", 

"schemes": ["https"], 

"paths": { 

"/api/GetCharOfNumber": { 

"get": { 

"tags": ["Web"], 

"description": "Get char of number", 

"operationId": "GetCharOfNumber", 

"produces": ["application/json"], 

"parameters": [{ 

"name": "Number", 

"in": "query", 

"description": "Number", 

"required": false, 

"type": "string", 

"x-example": "445" 


"responses": { 

"200": { 

"description": "OK", 

"schema": { 

"type": "string" 


"examples": { 

"application/xml": "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">QC</string>" 




"security": [] 




"securityDefinitions": { 



"security": [], 

"tags": [{ 

"name": "Web", 

"description": "Operations about Web" 



The Future of AI and Machine Learning in Business Process Automation


Companies are increasingly looking to AI and specifically machine learning (ML) as a way to improve their businesses.
While some of these applications may be in the early development phase, companies must be prepared to successfully implement AI and ML in the future to take full advantage of the power of these technologies.

In this session, we will go beyond the “art of possibility” and show tactical examples of how organisations can start applying AI in incremental ways within their process-based applications.

K2 Cloud Update 5


This webinar will provide an in-depth overview of the capabilities of the new K2 Five and K2 Cloud.

During this session we will focus on:

• K2 Smartbox enhancements;
• SharePoint dynamic URL’s;
• K2 Cloud external users; and
• K2 multiple authentications.

K2 & DocuSign – Keep Processes Automated and Auditable


Experience an all-encompassing demonstration that goes from electronic forms to document management into contract management with electronic signatures and business process spanning multiple systems.

Capability highlights:

Anonymous eForms against Office 365 lists
Workflow process spanning different systems and users
Document generation and online authoring
Multi-stage review and approval of both eForm data and documents
Seamless DocuSign integration into business process
Audience relevance:

Anyone dealing with document approvals, contract management, letters of engagement, recruitment, employee onboarding, digital transformation in general

Driving a Better Customer and Employee Experience with Process – Pre-Emptive vs Reactive



In the old days, as in pre-smartphones customer retention was driven by brand loyalty, a smiling face behind a counter or in a branch or a friendly voice on a phone. Waiting a few days or even weeks for feedback was expected and acceptable.

In today’s App-Driven economy, customers demand instant gratification. The words ‘brand loyalty’ has been removed from the everyday vocabulary. Why would you put up with average service when you can shop around online, anywhere, anytime for a different service provider.

I am sure you can all relate to the last minute online search for a new insurance provider, medical provider, real estate agent or even airline. I recently changed my vehicle insurance provider after being with them for 3 years, not because of bad service but simply because they had not taken the time to analyse my needs and re-value my vehicles. They sent me an over-inflated bill, based on aging data and expected me to pay it. A quick online search solved the problem and I switched.

If the organisation in question had pre-emptively used their data and their processes to their advantage they could have retained me as a customer.

With the above story in mind I would like to challenge you to think about what happens in your organisation when your customers or employees perform the following actions:

  • Click the ‘pay’ button on your app.
  • Fill out a form on your website.
  • Call your customer call centre with a billing query.
  • Report a fault and request a technician. (I have another sad story about my oven repair)
  • Submit a claim.
  • Send an email.
  • Send a fax. (Yes, fax machines they still exist)
  • Request a document or contract to be reviewed.

Typical answers include:

  • An email is sent to a team for action.
  • A PDF document is generated and then an email is added to a queue.
  • The call centre agent makes a note and sends an email to the finance department.
  • We cannot tell you what time when the technician will be there, just wait all day.
  • The document is sent to a mailing group for review. Who knows when we will get a response.

Can you relate to the above answers? The reality is that process happens in every organisation, every day whether we manage it or not. If there are no systems then the process is driven by Excel, paper, email, and humans. Bad processes lead to bad customer service.

“Almost every part of a successful business transaction relies on having the right information available to the right person at the right time, whether that person is an employee or a customer.” – Improving CX with Agile Process for Dummies.

Business Process Applications – How can process make a difference?

Information flow is often hindered by paper, siloed information and lack of visibility.

Low-code Business Process Applications offer the best combination of Electronic Forms, Workflow, Data and Reporting that are customised to meet the unique business needs of each department and process delivered using the best of breed low code platforms.

Business Process Applications provide the business with the ability to design and implement pre-emptive business strategies and processes to guarantee customer retention.

Anatomy of a Business Process Application

Let’s take a closer look at a Business Process Application and highlight a few topics to consider to drive customer and employee adoption.

Electronic Forms

Most of you would have taken care of your customer-facing forms and employed User Experience specialist to create modern apps and web-based interfaces, but what happens after this. Do you revert to PDF, email, and Excel to manage the workflow and tasks?

To improve the end to end customer experience, consider how transforming your backend tools from paper and email to electronic forms driven solutions with workflow can help eliminate the bottleneck and provide the data needed to drive effective processes and improved customer experience.

Electronic forms in combination with workflow can help with decision support, master data management and visual dashboards to track and collate data.

Empowered employees will result in happy customers. Here are four items to consider about forms:

  • As humans, we are naturally self-centered and will always take the easiest route to satisfy our needs. User Adoption is the key to your success. The forms should be more compelling to use than paper.
  • Focus on functionality first and look second.
  • The forms should be intelligent, pre-emptive and designed to drive the result with as few clicks as possible.
  • Features such as pre-loading of data, displaying only the necessary fields, pattern matching, data validation, data-driven rules, cross-browser support, cross-device support are critical to your success.


Data is a critical element to delivering a successful Business Process Application and driving the customer experience.

Here are a few items to consider about data:

  • Clean and accurate data in combination with forms and workflow ensures that managers and employees can make informed decisions quickly.
  • The forms require data to make them intelligent and compelling to use and vice versa, the forms ensure that clean and accurate data is delivered to the correct systems to ensure data integrity.
  • Data is used to drive the logic within workflow processes.
  • Consider how creating connected and integrated forms could improve the customer experience but be warned, do not try and boil the ocean on your first project as the complexity of too much integration and employee change management will sink your project.

Placing employees first results in happy customers according to Richard Branson of Virgin. He is famous for the quote below.

“It should go without saying, if the person who works at your company is 100 percent proud of the brand and you give them the tools to do a good job and they are treated well, they’re going to be happy,” Richard Branson

Are Business Process Applications the “tools” that will make a difference in your business?


An electronic form without a workflow process behind it is as useless as a piece of paper stacked on a desk. Workflow is required to deliver the right work to the right individual at the right time.

However, not all workflow tools are created equal and workflow gets complex quickly.

Here are a few items to consider about workflow:

  • Ensure that you have a workflow platform to support a long-term architecture.
  • Workflows solutions embedded within business platforms such as CRM, ERP or document management platforms will be designed to work within these solutions. Trying to extend these workflow capabilities for cross-platform solutions will often result in headaches for the IT team.
  • Consider a decoupled approach. i.e. choose a Workflow / BPM platform that is designed to work across platforms.
  • Features to help drive the customer experience include:
  • Real-time notifications via email and text to keep the customer and employees informed.
  • Complex task assignment and worklist capability.
  • Document workflow.
  • Management Worklist, out of office and redirect functions.
  • Data-driven rules.
  • Direct integration of forms.
  • Track and trace reporting.
  • Event and data triggers to support pre-emptive processes.
  • Integration with digital signature platforms.
  • Integration with document assembly solutions.

Reports and Dashboards

Reports provide insight into process data to help identify bottlenecks and optimise processes over time.

Consider how to process data and business data can be combined to provided business insights.

Business Intelligence platforms can provide data visualisation to help analyse your business.

Ask your BI team for help. You will be blown away by the possibilities.

Dealing the undefined

Most organisations have processes in place (albeit human-driven) to handle the critical business aspects, e.g. the sales process, new orders etc.

When it comes to customer service, dealing with the unexpected or undefined is where companies often drop the ball.

Let’s look at an example:

  • Your customer sends an email or fax to the wrong department and it gets lost or is never dealt with.
  • A customer calls the technical support centre with a billing query.

It hard to put processes in place to deal with these scenarios. This is where ad-hoc workflow and tasking can play a role.

Imagine the following catch all scenario:

  • An email address is monitored for incoming email. e.g. ContactUs@Mycompany.com
  • When a new email arrives a workflow process automatically starts.
  • Microsoft Azure sentiment analysis is used to determine if the email has a negative of positive sentiment. Negative emails are directed to an accelerated action workflow path.
  • If the email address matches customer records in a system, business rules kick in to automatically route the task to the correct manager, department.
  • Machine learning can be used to detect keywords to drive the business rules.
  • Attachments are automatically extracted and stored in a document repository for reference.
  • The customer receives auto emails and text alerts letting him know that his query is being handled, delayed, completed.
  • Internal staff can route the task to anyone with full tracking and history logs.
  • Internal staff can collaborate with the customer via email, share documents, request documents with full tracking and history logs.
  • Email responses from the customers are automatically associated with the original request.


The result is great customer service happy customers and new customer retention statistics.


Where do we start

Keep it simple to start with. Process gets complex quickly and can have a big change management impact as you are trying to fundamentally change the way people work.

  • Start by digitising and applying workflow to the simplest form in your business.
  • Go for the quick wins first to achieve results quickly and then set up a program of continuous improvement.
  • Interview your employees and customers. They will quickly tell you what needs improving.
  • Start the discussion at your next meeting. Here is a link to a PowerPoint deck that will help frame this get the discussion.
  • Watch this video to learn how process can make a difference. In this video Igor Jericevich from, BPM expert at K2 showcases an example of an Ad-hoc process example.
  • Read the book for inspiration. CX with Agile Process for Dummies


A great experience

After a quick search for a new insurance provider, I found one that offered me a better best price so I signed up by completing the online form.  My application was accepted and processed quickly and efficiently. I received text messages notifying me of my successful application. This is all standard and would be expected as a minimum level of service.

However, there was one more hurdle. I needed to supply proof of my no claim status. Normally this is the painful part of the process, however, in this case, technology and process came to the rescue.

I received a text message with a link to an online form. I was then able to take a photo of my proof of status, attach it to the form and hit submit. My document was automatically attached to my policy in the backend system and I received a follow-up text notifying me that the process was complete.

Halleluiah, that was a fantastic experience. Well done my new Insurance company.

Written by: Tony Roupell

Showcase: K2 and Adobe Sign



eSignatures are becoming more and more popular with businesses as they try to create a competitive advantage and complete business transactions faster.

With eSignature technology like Adobe Sign, you can obtain signatures from your staff and customers within minutes instead of days, and signatures can be obtained on any device. eSignature technology is a perfect fit for a Business Process Management platform like K2, allowing you to automate the collection of signatures as part of your business processes such as sales orders, employee onboarding, and contract creation.

While there is no Adobe Sign feature available for K2 (yet…) we can still integrate with K2 using the Adobe Sign REST API. This article will describe the steps required to integrate K2 with Adobe Sign, including:

  1. Create the Adobe Sign Developer Account and configuring OAuth
  2. Create the swagger file against the Adobe Sign REST API Reference
  3. Create an OAuth resource and resource type in K2
  4. Create the Adobe Sign Service Instance and generate SmartObjects
  5. Using Adobe Sign in your K2 applications

Adobe Sign Developer Account

To get started with Adobe Sign create a developer account. Once your account is created and verified, the first thing you will need to do is create an API application for your Adobe Sign account. Select API Applications under the API menu to create a new application.

Give your application a useful name and display name, and select the Customer option for Domain.

Once created, select your application and click the Configure Oauth for Application link. On this page, you will need to copy your Client Secret and Client ID for later use. You will also need to enter a Redirect URI and select the required scopes.

Your redirect URL will be in the form:

https://<k2 server name>/identity/token/oauth/2

Be careful as this URL is case sensitive. You can add multiple URIs by comma separating them.

Adobe Sign and REST/Swagger

To use the Adobe Sign REST API in K2 you will need to create a swagger file. Swagger files are used to describe the service, and K2 uses these files to create the service objects when you create a REST service instance.

There are many ways to create a swagger file (for example you can do it manually using an online editor like swagger.io). The example below uses REST United, an online tool that uses wizards to generate REST API Libraries.  REST United offer a free account that can be used to generate swagger files.

Before you start, it is important to find the Base URI for your location. You will need the Base URI to ensure you enter the correct path in REST United.

Open the API Reference and find the base_uirs operation. Click the button to create an OAuth resource token and click the Try it Out button. You will need the api_access_point from the response.

Open REST United and select REST API -> New REST API Wizard

Enter an endpoint URL (see the API reference), ensuring you select the correct method (e.g. GET) and use the base URI you obtained above. The wizard will work out the Base URL. Enter a useful Method Name. Don’t enter a response body yet, and leave “Authentication” as none. We will look at authentication later, but for now, we can ignore it as K2 will take care of this for us.

On the next page of the wizard, you can add any more parameters.

If you added a path parameter in the Request Path this will automatically be created for you. Check the API reference for the parameters you need. Ignore the “Access-Token” header parameter – K2 will create this for you automatically when we use the OAuth authorisation type for the service instance.

Click Next to get to the Response Page. Here you can paste in the example response. Get the example response from the Adobe Sign API reference by clicking on Model Schema.

Paste the example in and click the button “Guess Response Type using Example Response”


REST United will create Models for you based on the sample.

**TIP** Use the same name for your Model as the Model Name in the API Reference. This way your SmartObjects will be named the same, making life easier when trying to work out what SmartObject methods to call.

Be careful at this step as the response type may not match the Model you just created

You will need to come back later to select this, as it will not be immediately available (don’t ask me why!)

Click Next to get to the Test page. You won’t be able to test as you do not have an OAuth token.

Click Next again to get to the Release SDK page. Here you can click On Endpoint to add more endpoints, or select Test and Export to generate the swagger.

The 2 REST operations that you will need to send an agreement are:

Type Operation Description
POST /agreements Creates an agreement. Sends it out for signatures, and returns the agreementID in the response to the client
POST /transientDocuments Uploads a document and obtains the document’s ID.

To generate the swagger simply select the Swagger option and click Export to download the file.

You will need to host the file somewhere the K2 server can access (such as the K2 server file system, or for Cloud on an Azure file storage).

When you create your REST service instance enter the address for the Swagger file in the Descriptor Location.


Adobe Sign and OAuth

The Adobe Sign REST API requires an OAuth Access Token to authorize each REST operation (more details can found here). OAuth is “an open protocol to allow secure authorization in a simple and standard method from web, mobile and desktop applications” 1. The details of how OAuth works are beyond the scope of this post, however, what is important to know here is that K2 has a mechanism to allow you to use OAuth so your users can seamlessly authenticate with your providers that use OAuth. You may have noticed that we did not need to add in the “Access-Token” header parameter in our swagger file. That is because when we use to create service instance with OAuth as the authentication mode K2 takes care of obtaining and adding this parameter to all smartobject method calls.

The following steps outline how to set this up for Adobe Sign.

The first step is to create a Resource Type and Resource in K2 Management.

Under the Authentication Node in Management select OAuth->Resource Types.

Add a new Resource Type called “Adobe Sign”

Then add the following resource parameters:

Then click on the Resources node and click New under Resources and add a new Resource.

Take care with the region part of the URL (e.g. au1) as this might be different for your region. You can get you full path by calling the base_uris method (see https://secure.echosign.com/public/docs/restapi/v5)

Then add in the parameter setting, using the client id, client secret and redirect URI you got from the Connect application. For the scope you need to enter the scopes required as space-separated values, e.g. user_login:self agreement_send:account user_read:account agreement_read:account agreement_write:account widget_read:account widget_write:account

Name Authorization Value Token Value Refresh Value
client_id <your client id> <your client id> <your client id>
scope <scopes required>
redirect_uri <your redirect uri> <your redirect uri> <your redirect uri>
grant_type authorization_code refresh_token
client_secret <your client secret> <your client secret> <your client secret>
response_type code

Once this is done you can now use this Oauth resource when creating your service instance.


When you create the service instance you will get a message that you need to redirect for authentication.

You will be directed to the Adobe Sign login page. Once you have logged in you will be asked to accept the scopes you asked for, and then the authorization token will be created and returned to K2.

K2 securely stores these for you-you can find them under Authentication -> OAuth -> Tokens in Management if you need to delete them for any reason.

The good news is that K2 also takes care of refreshing the token for you if it expires (the token has an expiry of one hour) so you don’t need to keep re-authenticating.

When creating the service instance you can tick the option to create the SmartObjects. If you don’t select this option you can either click the button to Generate SmartObjects on the Service Instance list or create them manually.

Using Adobe Sign in your K2 Application

Once you have completed all the above steps and created your SmartObjects, you are ready to use Adobe Sign in your K2 applications

Adobe Sign uses the concept of an Agreement to manage document signing. An agreement contains one or more documents and one or more recipients.

The basic process for sending a document for signing with Adobe Sign is as follows:

  1. Upload a document/s
  2. Add the recipient/s
  3. Create an Agreement

You can create “groups” (called Recipient Sets) of recipients, with multiple recipients in each group. You can then indicate if you want all recipients in a group to sign, in which case they will be asked to sign in order, or just one.

Let’s look at the basic steps to create a form like the following that will allow a document to be sent to multiple signers.


  • you could also do some or all of these steps in a workflow if needed.
  • Your smartobject names and methods may differ from those below. If you followed the naming of your models using the API names then the smartobject names should match.

The first we will do is to upload a document.

You should have a “TransientDocumentId” SmartObject with an UploadDocument method (otherwise find your SmartObject that has this method). This method accepts a File_Name and File (document).

The output from this method will be a “TransientDocumentId” text property. You will need to store this somewhere for later use.

Next, you will need to add the recipients. This step involves serializing each recipient to a typed array and then adding these recipients to a Recipient Set. Note that the following steps will result in a single “Recipient Set” containing all recipients, with only one required to sign. If you need all recipients to sign you will need to create a “Recipient Set” for each recipient.

If you are using a list for recipient emails, loop through the list and add each recipient to a typed array (using a data field to store the updated value).

Finally, create a Typed array of RecipientSetMembersInfo and store in a data label.

The next step is to create the FileInfos object that stores the documents. Call the Serialize Add Item To Array method of the FileInfos SmartObject passing in the document id obtained earlier, and store the output in another data field.

The next step is to create the DocumentCreationInfo using the Serialize method on the DocumentCreationInfo SmartObject. Check the API Reference for valid values for Signature Flow and Signature Type. Store the output in a data label.

Next, you need to create the AgreementCreationInfo using the Serialize Method of the AgreementCreationInfo SmartObject. Pass in the DocumentCreationInfo created in the previous step, and store the output in a data label.

Note that some of these SmartObject methods could be chained together to reduce the number of methods called and make the process simpler. I have chosen to do each step individually to make it easier to describe each step.

Finally, create the Agreement. This will send the document for singing. Using the AgreementCreateResponse SmartObject call the CreateAgreement Method, passing in the AgreementCreateInfo created in the previous step. You can store the output from this method if necessary.