Josh Nerius

4 minute read

I’m always excited about every ServiceNow release, but Kingston brings some game changing stuff. This post is a high level overview of three new Kingston features that aren’t just ridiculously cool, they may just change the way you think about development in ServiceNow: Flow Designer, Action Designer and IntegrationHub. Note: for a deeper dive into Flow Designer, see Getting Started with Flow Designer.

That intro sounds like click-bait, but I don’t think I’m exaggerating. I’ll let you decide.

Flow Designer

Flow Designer provides a new way to add business logic to your applications using a natural language interface that minimizes the need to write code. The interface consolidates many of the automation capabilities of the platform into one place, and makes it much easier to build and visualize business processes.

Here’s what a simple Flow looks like.

k_overview_fd_sample_flow.png

A Flow is made up of a Trigger and one or more Actions.

In the screenshot, we see a Flow that will run when an Incident is created and the Priority of that incident is “1 b Critical”.

When triggered, the actions will be executed in order.

  1. Create a Freeform Visual Task Board
  2. Look up the board we just created
  3. Create a Card on the board

Triggers

Triggers determine when the flow will run, e.g. “When Incident is Created and Category is XYZ”. There are two primary trigger types: Record triggers and Scheduled triggers.

k_overview_fd_trigger_types.png

Record triggers execute when a record is created, updated or deleted and can include additional limiting criteria. Scheduled triggers execute on a scheduled interval.

Actions

Actions are self-contained blocks of reusable application logic. Some examples of what an action might do:

  • Create a record in a table
  • Look up a record in a table
  • Write to the system log
  • Ask for approval

Actions can also be more complex:

  • Create Emergency Change from Incident
  • Assign Incident to CI Support Group
  • Send Message to Slack Channel

Adding actions to a flow is easy:

k_overview_fd_add_action.png

Then, select an action:

k_overview_fd_add_action_select_email.png

Finally, fill out the inputs for the action:

k_overview_fd_add_action_email_inputs.png

Building Actions

Kingston ships with a number of default actions, but these are just the beginning. As a developer, you can build reusable actions of your own, allowing you to encapsulate business logic that can then be leveraged by anyone designing a flow. Flow designers could be other admins, other developers, or even a business process owner. They don’t need to be aware of the implementation details, just the inputs needed by the action.Actions are made up of Inputs, Steps, and Outputs.

k_overview_fd_action_outline.png

Inputs

Think of these like method parameters that allow users to pass values into the action. If we expand the Create VTB Card action in the flow we examined earlier, we see the original incident that triggered this flow is passed in to the action as an input (along with the board and lane this card should be created in).

k_overview_fd_vtb_card_action_detail.png

Steps

Steps are smaller units of application logic that execute sequentially inside the Action. In the Create VTB Card Action, there are two steps: a Script step and a Lookup Record step.

k_overview_fd_script_step.png

There are 13 step types ranging from simple record creation to Run Script, which allows you to build just about anything you can imagine.

k_overview_fd_action_steps.png

Outputs

When an Action is finished executing, it can pass data to future actions running in the same flow. This is accomplished with outputs.

k_overview_fd_action_vtb_card_outputs.png

The VTB Sample Flow used the output from the “Create Freeform VTB” action as an input in the “Create VTB Card” action.A future post will cover the process of building an action from scratch.

Spokes

A Spoke is a Scoped Application that bundles a set of related actions together. For example, the Visual Taskboard Spoke includes Actions to create various board types, manage VTB lanes, create/assign/remove cards, and more.Developers can build and distribute their own Spokes.

IntegrationHub

The same engine that powers the on-platform functionality described above can also be used to build actions that communicate with external systems. This is IntegrationHub.IntegrationHub ships with several integration Spokes built-in:

  • Slack
  • Microsoft Teams
  • HipChat
  • ServiceNow eBonding

REST Step

IntegrationHub also provides access to the REST step type, making it easy to make REST calls to external systems when building custom integrations.

Summary

I’m really just scratching the surface with this post, and the intent is just to make you aware of these new features. @dave.slusher and I will follow this up with a more detailed explorations of the core concepts covered here in the coming weeks. Stay tuned!

Additional Resources: