Just two weeks ago I had a pleasure to talk about jBPM (both v5 and v6) at Magnolia conference in Basel, Switzerland. This was a great event that I recommend everyone that is interested in CMS.
Together with Espen from Magnolia team, we made a really nice
presentation about both jBPM and Magnolia Workflow that utilizes jBPM. Here you can find the presentation:
The Red Hat UK SA team has been working at a demonstration that shows how different Red Hat projects can be brought together to form one big solution. As part of this, they created a demo that shows a Car Insurance Policy Quote process:
It asks the user for input (driver information and car information and does various calculations in between to calculate the policy risk and price, using a decision table. It is using JBoss BRMS 5.3.1 (which includes support for jBPM5) on top of EAP6.
Derek created a small video showing this in action as well:
The sources can be found here. Eric Schabell also extracted the policy quote process and packaged it inside his demo framework here.
Mauricio and Esteban have been working hard on their latest book on jBPM and today, their jBPM5 Developer Guide has been released !
I believe Mauricio and Esteban have done a good job in including a lot of valuable information for people with different backgrounds. They start with an introduction to BPM in general, give an overview of how to model processes using the BPMN 2.0 standard, show how to do all of this with jBPM and then go even further by showing more complex examples that for example include business rule integration, etc.
You can get both as a eBook or printed (which includes a free eBook as well) from Packt Publishing here.
I'm even able to offer you some discount codes, 20% off for the printed version and 25% off for the eBook. I think that's a very nice gesture of Packt Publishing, showing once more they try to support open-source with benefits like this. Note that they have a limited validity for use till 1st Feb, 2013.
In order to apply the codes, you will need to:
- Visit the Packt website and log in to your account (non-registered
users will be required to create an account first)
- Open the book-page
and add the book to cart
- On the cart check-out page, enter code
in the Enter promotional code box and then Update
cart
Mauricio and Esteban are doing a presentation on jBPM and the book they wrote about it on a London JBug in December 12!
While the first part will mostly focus on the core BPM features, the second part will also show some of the more advanced integration with business rules and complex event processing.
So if you're in London on December 12th, and looking for an interesting presentation or talk afterwards about jBPM, or just looking for a place to eat some pizza and drink some beer ;), register now !
There's even a chance to win a copy of the new book already !
We are proud to announce the release of jBPM 5.4.0.Final.
The bits were ready more than a week ago already (and looking at the download statistics quite a few of you already found them ;)), but a busy travel schedule made it difficult to complete the work and announce everything. But here it is !
The jBPM installer is probably the best way to get started. Download the full installer and follow the documentation here to walk through some of the most important components.
So what's new?
Simulation
We've added simulation capabilities to the web-based process designer, that allows you to simulate how a process might behave at runtime. This includes the addition of various simulation-related properties (like resources and duration-related attributes for tasks, and probabilities for diverging gateways etc.). Our implementation is based on the specification created by the BPSWG (Business Process Simulation Working Group).
Based on these properties, you can run a number of instances of your process and:
Use the path finder to look at all identified paths
Look at the generated charts containing information about minimal, maximum and average completion times, etc. using (horizontal and vertical barcharts, pie charts or tables.
Check the timeline to get an overview of all the recorded events
Maciej did a blog recently on the ideas and concepts behind it, and Tihomir did a blog, including a 12-minute video, that shows simulation in action.
Local task service
When human actors participate in a business process (also known as human workflow), a task service is used to manage the life cycle of the tasks (claiming, completing, task lists, etc.). While we supported the use of a centralized task service (using HornetQ for remoting), we now also support a local version that runs as a simple Java component next to the engine and all the work it does is synchronous and nicely integrated with the transaction of the process engine.
org.jbpm.task.service.TaskService taskService =
new org.jbpm.task.service.TaskService(
emf, SystemEventListenerFactory.getSystemEventListener());
LocalTaskService localTaskService = new LocalTaskService(taskService);
LocalHTWorkItemHandler humanTaskHandler = new LocalHTWorkItemHandler(
localTaskService, ksession, OnErrorAction.RETHROW);
humanTaskHandler.connect();
ksession.getWorkItemManager().registerWorkItemHandler(
"Human Task", humanTaskHandler);
Spring
We have improved our Spring support, where you can use a Spring configuration file to configure your environment and inject a ksession and/or task service into your application code. For transactions, it integrates with the Spring transaction manager, supporting both JTA and RESOURCE_LOCAL with shared entity manager factory (emf) or shared entity manager (em).
JPA2
jBPM runtime persistence can now also use JPA2 for persistence. That means it is completely independent of the underlying persistence provider (we use Hibernate by default but other persistence providers should be possible as well). You can use Hibernate4 with JPA2 for even better performance. For all the details on how to do this, here's a link to a persistence configuration file for both JPA1 and JPA2.
Some of the other features
Improvements on some of the BPMN 2.0 constructs in the core engine, related to error events, terminating end events in sub processes,
Introduction of a business calendar related to timers etc.
The ability to start a process by name, which will automatically start the latest version of that process.
We created separate wars for EE6 (AS7) and EE5 (AS5) to avoid a lot of manual dependency management. JBoss AS 7.1.1 is now the new default application server in the installer.
Improved support for invoking web services from inside your processes.
A database-backed solution for managing which users are part of which group (UserGroupCallback).
When configuring handlers for domain-specific services, the ksession is automatically injected as an optional constructor parameter in the handler configuration file.
The details on all fixed issues and new features can be found in detail in JIRA.
In case you missed the emails, I'm doing a webinar presentation July 16th, 2012 on "jBPM 5: Build intelligent business processes".
Join this webinar to get the lowdown on
jBPM 5 from Kris Verlaenen, Red Hat’s jBPM 5 project lead. While you’re
at it, learn how to build intelligent business processes by leveraging
the combined power of business rules, business events, and processes.
Popular jBPM 5, now part of JBoss Enterprise BRMS
jBPM 5—one of the most popular open source BPM/workflow solutions on the market — is being productized as part of JBoss® Enterprise BRMS, which injects intelligence into static business processes.
jBPM key functions and future direction
Adopted by many enterprises for its lightweight footprint, embeddable
engine, and ease of use, jBPM takes these unique characteristics to the
next level by adopting the popular BPMN 2 standard—the choice of
standard for modeling and native execution. Check out this webinar to
learn about jBPM 5’s key functions and future direction, including:
BPMN 2-based process modeling using rich web-based designer and Eclipse editor.
Human interaction based on the WS-HT standard.
Process monitoring and debugging.
Support plan through JBoss’ enterprise product.
Date: July 16, 2012
Time: 16:00 UTC / 12 noon (New York) / 6 p.m. (Paris) / 9:30 p.m. (Mumbai)
jBPM was a big part of the JBossWorld keynote demo this year! The demo featured the JBoss Toy Store, a simple shopping cart application. You could use your mobile device to order various products (from phones to shirts), and a jBPM process was used to handle and manage the orders, all running in the cloud (on OpenShift).
The full video of the keynote is available below (you can skip to 14min30 if you immediately want to skip to the demo itself, which in total takes about 20min), this blog will explain some of the details on how jBPM was used to achieve this.
Whenever a new order was placed (either through one of the mobile clients or the web-based client), a process described the life cycle of the order. The process itself is shown below. The process itself is modelled using the BPMN 2.0 standard (both the visualization and the XML format used to store the process) and was defined in the web-based designer.
After some initialization, a Risk Assessment was done to decide whether the order was high or low risk. This was modelled using a Business Rule Task, that in this case used a web-based decision table to make the decision. In the demo, we simply look at the amount of the order, to decide whether it is high risk (larger than or equal to 500$) or not (less than 500$), but this could easily be extended with more complex logic.
All orders needed to go through a first Review (where a sales representative would manually check whether the order was valid and would accept or reject the order, for example to get rid of fake or unwanted orders etc.). High-risk orders would undergo an additional Vice President Review (our VP really wanted to keep control of the company). In the demo, the VP (played by Jay on stage) automatically rejected orders above 3000$ (just to make sure our participants needed to play smart to win ;)). Both review tasks were modelled using a User Task and contained various details on who to assign the task to, the data associated with the task, etc. After the review(s), the order was then either shipped (which we modelled using a domain-specific Service Task), or a rejection email was sent (using the out-of-the-box Email Service Task).
People in the audience were invited to participate in this experiment and put in orders. A leaderboard was used to show the overall progress. This showed the total amount of orders per person, and some dials and charts showing the order transaction rate, order backlog (orders still being processed), etc. The data was collected by listening to and/or querying the jBPM engine and/or task service.
We used a process monitor to visualize where all the orders were waiting. The number on top of each node shows how many orders are currently waiting there. This view is actually the web-designer that we extended with this monitoring information (that was updated every few seconds from a REST service that would provide the necessary information). We're working on getting this integrated in the project by default as soon as possible.
In the demo, we played out a scenario where a lot of the orders got
stuck in the VP Review (as Jay wasn't able to approve all the incoming
orders fast enough), generating a huge backlog. It's kinda difficult to explain, so I suggest you just take a look at the demo to see how it played out ;) By changing the business logic on the fly, we then allowed better throughput (and yes, we also used a bot to help Jay a little with approving all these orders more quickly, but everything was real, no cheating ;)).
Some technical details:
Everything (web-based designer + guvnor repository, jBPM engine, dashboards and process monitor) was running in the cloud (on OpenShift), on AS7. The laptops simply used a web browser to show the web-based apps running there.
The jBPM engine was embedded as part of the shopping cart application, and was invoked whenever a new order was retrieved, or when any of the review tasks were done. One session was used to handle all requests.
The engine was configured to user persistence (using Hibernate4 / JPA2 and an H2 in memory database)
The changes done in the application and by the jBPM engine were combined in one user transaction.
The default task service (that comes with jBPM out-of-the-box) was used to manage the task lists and the life cycle of each tasks. We used one local task service (running next to the engine) to make sure these changes were also done in the same transaction and avoid remote communication.
The source of the demo application is available here. You can download and run the application on your own laptop, or even push it to OpenShift as well.
We really enjoyed creating and doing the demo, and we hope so will you!
jBPM 5.3 has just been released. It includes a large amount of smaller improvements and fixes, and also contains a few new bigger features as well:
We would like to introduce our new Eclipse editor for defining business process in Eclipse (using the BPMN 2.0 standard). This editor will offer support for the full BPMN2 specification, and currently offers support for at least the same constructs as the previous plugin. We will continue to extend it over time with all the other constructs the jBPM core engine already supports, but we would like to hear your feedback as well !
A first version of the form builder has been released as well. This form builder allows you to create and edit your forms (for tasks and processes) in a graphical way, using drag and drop. It supports the usual components like labels, text fields and areas, buttons, etc. but already has support for various layouts, scripting, building your own components, etc. [Note: this first version is currently only supported on FireFox but we're working on adding support for all other browsers as well]
The web designer received a lot of love as well, with new features like user-friendly property editors, color themes, a dictionary, inline form editing, etc.
The jbpm-human-task module has been split up in a jbpm-human-task-core module and sub-modules for the different transport protocols available (hornetq, mina, jms), and a separate war that can be deployed in the application server (and is made easily configurable now). The installer now uses the war (with HornetQ) by default.
Integration between the jBPM console and Guvnor has been upgraded, to support new packages being added in Guvnor, removal of processes, etc.
Lots of persistence improvements to better support different databases, and we're using a new serialization technology (Protobuf) to better support upgrading / migration in the future.
You can download the release here (if you're not sure what you're looking for, downloading the full installer and then following the installer chapter to set up your environment and run through the tooling with a simple example is probably a good idea), or browse the documentation and javadocs.
I'll be giving a presentation on the JAX conference this year in Germany. I'll be giving an overview of not just business processes, but also business rules and complex event processing, and how they all come together in the JBoss BRMS / BPMS product. So if you're already planning to go to that conference, make sure to add it to your time planner and I hope to see you there :)
Business Processes, Business Rules, Complex Event Processing with JBoss
JBoss's Business Rules Management System, BRMS, integrates various community projects such as Drools and jBPM bringing together a unique combination of business processes, business rules and complex event processing, unavailable elsewhere in the industry. Delivered in a single open source distribution and accessible from a common set of authoring tools, with JBoss BRMS customers can combine business processes, business rules and event processing in support of a broad range of decision management and process driven applications. This session explores the use cases for the BRMS, the benefits for the customer, and we will walk through many of the new features now available to enterprise developers. The discussion will center around the many powerful solutions that can be built leveraging rules, complex events, business process automation and the combination of the three. A special focus will be on the new BPM features that are coming with the integration of jBPM5 / BPMN2.0 into version 5.3 of BRMS.
The team is proud to present the next release of jBPM. jBPM is an open-source business process engine, supporting BPMN2. I think we have a few very nice new features in this release, with for example
the domain-specific service repository: import existing services from a repository (e.g. Twitter integration etc.) and start using them in your processes
support for the lightning-fast JBoss AS7: install your applications on AS7, which is now the default application server in the jbpm-installer
A full list of features is added below.
You can download the artefacts here. Documentation can be found here.
To get started, it is probably best to download the full installer and follow the installer documentation, to guide you through the tools with a simple example. You can also import the examples module to have look at the numerous examples included in there.
We'll be updating some of the documentation and adding some quick starts and more examples in the next few weeks, so stay tuned!
Have fun!
Release notes
On top of some optimizations, bug fixes and small improvements, these are the most important new features in jBPM 5.2.0.Final.
Core engine
domain-specific service repository: the ability to import domain-specific services from a repository so you can immediately use them in your processes, e.g. twitter integration, FTP, web or REST service, etc. This is ideal for non-technical users to integrate with external services
improved persistence support for multiple databases and backwards compatibility
jbpm-test: new module that offers improved support for JUnit testing of processes, including the automatic setup of the necessary datasources and services on the fly
support for Java7
Installer
added support for JBoss AS7, which is now used as the default application server in the jbpm-installer
Web-based designer
Integration with the domain-specific service repository
Visual Process Validation: new features allows users to visually validate their processes at edit time
Ability to view the process in ERDF, JSON, PDF, PNG, BPMN2, and SVG formats
New Process Information section: contains information about the process, such as name, creation date, version, etc
jBPM 3.2 Process Migration: new feature allows users to migrate existing jBPM 3.2-based processes to BPMN2
Ability to import existing bpmn2 processes straight into designer
Ability to create "sharable" process image, PDF, and ability to generate code for embedding designer in custom applications
Support four boundary events
Visual support for Text Annotations, Groups, and Lanes
Support for sub-processes
Update to latest Guvnor
Human task service
introduction of the task service interface, and interface to interact with the (default) human task service (independent of the underlying communication pattern and technology)
user group callback: easily integrate with your own service for user / group validation and user-group-management (which users are part of which groups)
local task service: a local implementation of the task service that runs locally, next to the process engine, and (re)uses the same transaction of the core engine
human task service war: deploy the human task service as a service on your application server
jBPM console
updated to latest version of the JBoss BPM console
console synchronizes with the process definitions (and other assets) from all packages in the Guvnor repository
updated BIRT reporting to latest version
Eclipse plugin
jBPM perspective: Eclipse perspective that simplifies workspace configuration
Bruce Silver did a blog recently, wondering whether any tools already exist that truly support executable BPMN 2.0. He defines supporting executable BPMN 2.0 as not just following the graphical notation guidelines (that are probably not that different from BPMN 1.x), but also supporting the underling XML serialization. And not just the basic high-level elements, but also the details that are necessary to come to executable processes, like process data, data mappings, service interfaces, etc.
I believe that jBPM satisfies these requirements!
As of jBPM 5.0, we are now using the BPMN 2.0 specification, not just for the visual representation, but also as the underlying XML serialization. And it's more than an import/export format, it is the representation that our tools use to communicate with each other (instead of using yet another proprietary model for that). This means that you can round-trip your processes between your developers (using the Eclipse-based editor integrated in their development environment) and your business users (using the web-based designer) based on the BPMN 2.0 XML.
And yes, unlike some other vendors, we're following the BPMN 2.0 specification as close as possible, and avoid using custom extensions (whenever not necessary). This for example means that we use BPMNDI for storing the diagram information (i.e. location and size of the nodes etc.), like this (click here to see the full process):
jBPM already supports a significant subset of nodes (and other elements) that you can use to model executable processes. To get an idea of what this looks like using BPMN 2.0 XML, simply browse through the examples module. A full list of supported elements and attributes (which is very similar to the Common Executable subclass, but extended with a few more elements) is added as part of the documentation here.
And finally, our new Eclipse-based editor is almost ready, and that supports the full BPMN 2.0 specification, and uses the BPMN 2.0 XML to store these process models. You can for example download the BPMN 2.0 examples (that are included as part of the specification) and open them up, as shown in this screencast.
So who says there's no tool that supports executable BPMN 2.0 ? :)
(If you want to help out and contribute to jBPM, read this blog all the way to the end, as we're looking for community assistance here!)
Using jBPM5, you can introduce your own domain-specific services in your processes. By defining your own services, they show up as custom service tasks in the graphical process editor. For example, if you would like to send tweets inside your business processes, a special twitter service task can be defined, as shown in the following screenshot.
Configuring domain-specific services has become even easier now, as we now allow you to import services like this from a service repository. You can just browse such a service repository and import the services you would like to use inside your processes. These will then automatically be added to your palette. You can also import a default handler that will be used to execute the service (although you're always free to override the defaults, for example for testing).
The import wizard is created as part of the latest version of the jBPM Eclipse plugin (and will be part of the next release, or you can already try it out by installing the latest plugin from the latest update site). It supports both repositories that are on your file system, or URL-based.
Click on the image below to see a screencast where we import the twitter service in a new jBPM project and create a simple process with it that sends an actual tweet.
[Note that you need the necessary twitter keys and secrets to be able to programatically send tweets to your twitter account. How to create these is explained here, but once you have these, you can just drop them in your project using a simple configuration file.]
We're building a service repository that contains predefined services that people can use out-of-the-box if they want to: http://people.redhat.com/kverlaen/repository. Currently it only contains a few services but we will migrate all existing services there over time.
And this is where we are looking for contributions! There are tons of interesting services and excellent projects that we would like to integrate with. We would like to offer out-of-the-box integration with a lot of those, by defining them as domain-specific services and adding them to the service repository, so people can import them in their processes. So if you would like to contribute integration with a service like that (e.g. facebook, google maps, etc.), or even your own project, let us know!
After the success of previous JUDCon conferences in for example Boston and Berlin, JUDCon is now visiting London! JBoss developers will be coming to London at Park Plaza Victoria on October 31st and November 1st. The first day, there is a "Rules, Workflow, SOA and EAI" track, including for example:
I'll be speaking about jBPM5, but there will be a lot of other interesting presentations about a ton of different JBoss technologies as well, given by core developers themselves.
Whenever human actors participate in business processes (for example using the jbpm-console), forms can be used to show information to these users and/or ask for additional input. For example, the performance evaluation example that is included in the installer uses a simple form (as shown below) to ask the user to fill in some data related to his performance evaluation.
jBPM5 allows you to define these forms yourself, using a HTML template approach, so that they can be used in the console.
We've also been working a Form Builder, a web-based application that also allows business users (and not only developers) to create these forms using a visual editor and drag-and-drop. Mariano has published a blog including a cool demo that shows the progress so far.
Not only is the form builder nicely integrated into the existing tooling, it also allows you to generate default forms based on the process definition (based on the expected input and output parameters of the user tasks or process). The user can then customize the generated form and start using it in the console almost immediately.
(double-click on the video or on this link to see a larger version)
I can only say congratz ! :)
Note that we still need to integrate most of this into our codebase, but we already wanted to share what's coming.
Most of you probably know that JBoss Application Server 7 has recently been released in the community. Due to its lightweight and modular approach, concurrency and much more, the startup time has descreased significantly, which is always nice to hear for developers! Although I still have to figure out how to get a cup of coffee in only 3 seconds now ;)
During my holiday break, I took some time to play with it, and see how difficult it would be to get jBPM5 running on AS7. It took me some time, but in the end I managed to get the jBPM console running on AS7. I'll describe the steps I took to get there now, but we'll try to get this integrated in the installer in the near future, so other people can start playing with this stuff more easily as well (any volunteers?).
I started with downloading JBossAS 7.0.0.Final and took the jBPM 5.1.0.Final jbpm console wars as a starting point.
Biggest change probably is the fact that as7 ships with JPA2 and hibernate4, while jBPM is still using JPA1 and hibernate3. Due to it's modular design, we can however still run hibernate3 applications on as7, we just need to add these dependencies ourselves now (and exclude hibernate4).
Add the following jars from the jBPM runtime to the WEB-INF/lib folder of the server war: hibernate-core, hibernate-entitymanager, hibernate-commons-annotations, hibernate-annotations, dom4j, javassist
Make sure to exclude the hibernate4 jars, by adding the following WEB-INF/jboss-deployment-structure.xml in the server war:
I got an error with my persistence.xml and JPA2 so I disabled JPA2 scanning by commenting out the JPA module (org.jboss.as.jpa) and subsystem (urn:jboss:domain:jpa:1.0) in the standalone.xml configuration file.
Data sources are no longer specified by dropping a *ds.xml in the deploy folder but as part of the configuration. In configuration/standalone.xml, add the following datasource:
Notice that we also changed the jndi name of the datasource as we need to use one of the known domains (jboss in this case). This means you also need to change the name of the datasource in your persistence.xml.
The security configuration is also different, you should now add a security domain in the standalone.xml and copy the users.properties and roles.properties file in the WEB-INF/classes folder:
public class JBPMTransactionManager implements TransactionManagerLookup { public Object getTransactionIdentifier(Transaction transaction) { return transaction; } public TransactionManager getTransactionManager(Properties properties) throws HibernateException { try { return (TransactionManager) new InitialContext() .lookup("java:jboss/TransactionManager"); } catch (NamingException e) { throw new RuntimeException(e); } } public String getUserTransactionName() { return null; } }
There is another persistence.xml file in the jbpm-human-task jar (which is also bundled in the server war) which actually shouldn't be there, and is picked up by as7 at deploy time, so you should just delete that persistence.xml file (as for example discussed in this blog).
Finally, there was a problem in the FormProcessingFacade of the bpm console code. It was no longer picking up correctly when a form was sending data as plain/text, as there were now new properties in the media type related to encoding that made the equals fail. So I had to change line 228 in FormProcessingFacade to this (checking only for plain/text mediatype and simply ingoring properties:
Ok, this might sound a little scary, but don't worry, you won't have to do all this manually yourself, once we update the build to generate as7-compatible wars and update install script, it should be able to handle most of this! I just wanted to share this with anyone who might be trying to do something similar.
Still need to check how to deploy the BIRT reporting engine on as7 and then the jbpm-console is fully functional. Tihomir has already looked at deploying the designer on as7 and generated a customized war in the build for that.
As already mentioned in the jBPM 5.1 release notes, there is now a new jbpm-examples module that contains a set of sample BPMN2 processes that show how to model and use some of the features, like how to do looping and multi-instances, human task management and task forms, etc.
You can simply import the jbpm-examples folder in Eclipse to take a look at the processes and test and debug them using the associated Java main classes or junit tests.
The largest set of processes is probably the BPMN2 junit tests. For most of the BPMN2 constructs that are currently supported, there are probably one or a few tests that show how it works. On top of that, there are a few larger examples that show some more advanced features, like:
looping
multi-instances
human tasks (including user / group assignment, delegation, forms, etc.)
process + rules integration (see part 2)
The jbpm-examples can be found as one of the artefacts in the download section. There is a separate chapter on these examples in the documenation. And the sources can be found here.
SwitchYard is a lightweight service delivery framework providing full lifecycle support for developing, deploying, and managing service-oriented applications.
You mean like an Enterprise Service Bus (ESB)? Yeah, kind of. At it's core, SwitchYard provides an embeddable services runtime with limited dependencies, allowing you to deploy and run services where you need them. The main difference between SwitchYard and traditional ESB offerings is that we are trying to make the runtime a transparent detail in the service lifecycle. SwitchYard aims to keep you focused on your services by providing tooling to help define, test, and manage the important details of a service - it's contract, policies, configuration, composition, and management . After all, the least important detail of your service is where it runs.
Good news, as this next-generation ESB will already offer jBPM integration in its 0.2 release, where SwitchYard services can easily be invoked from inside a jBPM process, as a domain-specific service.
For more information, check out the Wiki document and the associated example about the SwitchYard BPM component.
Thanks to OSDE we now have a 2 day workshop planned in Argentina, Buenos Aires, half June, with nearly all the core Drools and jBPM developers. A MUST attend event for any developer in South America.
We are just finalising locations, agendas and speakers, we'll give more firm details later, but initially the line up is as follows:
Where: Argentina (Buenos Aries) Date: 16-17 June (Thu/Fri)
Speakers: Mark Proctor - Group Lead and Drools co-founder Kris Verlaenen - jBPM Lead Edson Tirelli - Drools tech Lead Geoffrey De Smet - Planner Lead Michael Anstis - Business Tooling tech lead Ray Ploski - Solutions Architect
