Passthrough APIs and API monitoring

Passthrough APIs provide a way of more easily configure API calls to be forwarded to backend system and ways of monitoring these calls

  • Passthrough API functionality to enable users to easily configure existing API’s to be governed by Frends API Management without having to have an underlining Frends process attached to the API.
    • The passthrough API will have simplified configuration capabilities to modify:
      • HTTP Headers
      • Authentication methods
      • URL paths and parts
  • Improved API Monitoring capabilities
    • Introduce new API Monitoring views to show more API relevant data such as HTTP response codes as well as better ways to view the overall API health and execution statistics

100 %


 In progress

 Passthrough APIs and API monitoring 100% Done Passthrough APIs and API monitoring 0% In progress

Business Automation Portal

The Business User UI is an entirely new Frends feature, where a second simplified user interface of Frends is deployed alongside the existing main Frends user interface.

The goal of the Business User UI is to enable a no-code business user experience to discover pre-built integration flows from a library of templates, configure those integration flows, and to take them into use in the underlining main Frends tenant.

 The Business User UI capitalizes on the established Frends Templates feature, facilitating its use for business users.

 Additionally, the Business User UI can be utilized to offer an embedded iPaaS experience for ISV/SaaS partners of Frends. This is achieved by developing a designated number of templates that connect to their solutions or offering value-added services to their end customers through Frends.

The Business User UI will support the following use cases and functionalities:

  • Business User onboarding and registration
    • Utilize an identity management system chosen by the customer
  • Existing integration discoverability
    • See and search for integration and API templates published for usage in the Business User UI
  • Business User organization and user management
    • Configure template visibility and usage based on user roles
    • Create and manage organizations and user groups within the Business User UI
  • Integration monitoring
    • Provide business users with simplified monitoring tools and reports to keep track of the integrations in use
  • White-labeling
    • Enable customers and partners to to make lightweight white-label customization such as altering fonts, colors, logos, etc.

39 %


 In progress

 Business Automation Portal 39% Done Business Automation Portal 8% In progress

Decision Model Notation (DMN) Support

We are introducing a valuable enhancement to the Frends Process Editor by incorporating Decision Model and Notation (DMN) functionality. DMN provides an efficient means of mapping data and decision-making, as described in detail here.

Key Enhancements:

  1. DMN Shape Integration: With this feature, we are introducing a dedicated DMN shape within the Frends Process Editor. This shape will allow users to create input maps following the table structure outlined in the Wikipedia article.
  2. Mapping to Frends Variables: Users can easily associate DMN inputs with various Frends variables, streamlining the data mapping process.
  3. Output Generation: The result of the DMN shape will provide corresponding outputs based on the input configurations ready to be used in following integration tasks and steps.

0 %


 In progress

Frends LLM Agent to Operate Frends

We are excited to introduce an AI assistant, powered by the Frends Large Language Model (LLM), to enhance the ease of operating Frends. This AI assistant is designed to access Frends APIs, streamlining various operational tasks as well as providing an intuitive natural language interface for data inquiries.

Key Highlights:

  1. Administrative Automation: The AI assistant is tailored to simplify administrative tasks within Frends. It can be configured to be accessible exclusively to administrators or have the capability to impersonate users when making requests, if feasible.
  2. Scheduled Actions: Users can leverage the AI assistant to schedule specific actions, for example activating or deactivating a Process within an Agent Group at predefined times. This feature adds a layer of automation to routine tasks you perform in Frends.
  3. Tenant Queries: Users can also utilize the AI assistant to obtain information and answers related to their Tenant, enhancing their ability to manage and understand the platform.

0 %


 In progress

Frends LLM Code Generation for Code Shapes

We are introducing an advanced feature within Frends that enables users to create Code shapes efficiently through natural language prompts. This enhancement streamlines the process of writing C# code to perform complex integration tasks within your integration processes.

Key Enhancements:

  1. Contextual Information: System prompts are integrated to provide contextual details for process configuration, including environment variable names, process variables, trigger variables, and access to task results.
  2. Seamless Integration: When opted in the Process Editor seamlessly connects to our LLM service (Azure Open AI) for effortless use.
  3. Tenant-Specific Configuration: For security and flexibility, each Frends tenant will utilize it’s own dedicated instance of the LLM model for context and session security.

0 %


 In progress

Long-Running Process Support

An extension to current Frends functionality which allows multiple Frends processes to be chained together in the same process definition by configuring an identification or correlation variables that links the independent process parts together.

An example long-running process functional description:

Process Part 1:

  • Triggered with a schedule
  • Retrieve a file from an SFTP server
  • Write file to a local folder
  • Save OrderID to be the correlation ID of the long-running process
  • OrderID is parsed from the file name transferred with the SFTP transfer

Process Part 2:

  • Establish a file trigger that looks for a fille with the same OrderID present in a different folder
  • Read in the new file and transfer it to a separate SFTP server

Any amount of time can pass between Process Parts 1 and 2.

0 %


 In progress

API Policies and Private Application registrations

API Policies

We are introducing Unified API Policies, designed to centralize and streamline access management for all API’s while preparing for the upcoming release of the Frends API Portal.

Key Enhancements:

  1. Unified Policy Configuration: With Unified API Policies, you can easily configure access restrictions and throttling for all your APIs through a single, user-friendly mechanism.
  2. Throttling and Access Control: Tailor API Policies to meet your specific needs. Define access limits and throttling rules to ensure optimal API usage and prevent abuse.
  3. Adaptable to Any Authentication Method: API Policies are versatile and can be applied to APIs regardless of the authentication method used, providing consistent control and management.

New Authentication Method: Private Application Registration

Additionally we are introducing a new authentication method to work with the reworked API Policies: Private Application Registrations.

Key Enhancements:

  1. Secure Authentication: Private Application Registrations supersede API Keys, offering a more secure and modern authentication solution.
  2. Static JWT Tokens: These tokens are essentially static JSON Web Tokens (JWT) containing user-provided data about the API consumer, alongside digital signatures to ensure data integrity.

77 %


 In progress

 API Policies and Private Application registrations 77% Done API Policies and Private Application registrations 13% In progress

API Portal

A completely new Frends web application that is deployed alongside the main Frends User Interface that is meant to provide a unified API Developer on-boarding and discoverability experience to both internal and external API consumers.

The API portal will support the following use cases and features:

  • API Consumer registration and on-boarding
    • Utilizing an identity management system chosen by the customer
  • API Products
    • Create and manage API Products in the API Portal that are available to be consumed by the API users
    • API Products are a combination of existing API’s either directly in Frends or managed as passthrough API’s using the Frends Passthrough API Management functionality
  • API Discoverability
    • Publish API Products you have configured using the API Portal
  • Lightweight CMS
    • Create API marketing and help content using markdown to publish on the API Portal
  • Whitelabeling
    • Enable customers and partners to provide lightweight whitelabelling customizations to change for eg. fonts, colors, logos and so on.

0 %


 In progress

E2E Integration Test Automation

An extension to the current Unit Testing features of Frends which enables users to create, configure, save and manage integration test scenarios that are attached to a specific integration process.

From a practical perspective this would mean that the User can “paint” a section of an integration process and select to create a test scenario based on the selection by providing the needed variables and test messages as well as the end result assertion for the test scenario.

The E2E Integration Test Automation would include the following features:

  • Select which parts of the process are to be utilized in the test scenario
  • Provide values for needed variables within the selected scope of the test
  • Attach an assertion mechanic in the end to determine if the test is successful or not
  • Create multiple tests on the same process
  • Attach descriptions and other metadata to the test scenarios
  • Execute the tests manually or with automated rules
  • View the test execution history and statistics

0 %


 In progress

Frends LLM Based Automatic Task Configuration

Building on the previous feature of LLM Code Generation we are also introducing a feature that allows users to configure Tasks seamlessly through natural language prompts. This simplifies the process of configuring Task parameters, creating low-code mapping configurations and utilizing Task results and other variables when configuring Frends tasks.

Key Highlights:

  1. Effortless Task Configuration: Users can effortlessly configure Tasks by describing the required functionality for the task using plain language, eliminating the need for manual configuration.
  2. Contextual Continuity: This feature retains the chat context, enabling users to iteratively enhance Task configurations within the same conversation as well as test out their configuration at any time.
  3. Tenant-Specific Configuration: For security and flexibility, each Frends tenant will utilize it’s own dedicated instance of the LLM model for context and session security.

0 %


 In progress

Frends LLM Process Documentation Generation

We are introducing a powerful new capability within Frends that enables users to generate process descriptions and documentation with ease, using the Frends Large Language Model (LLM). This feature simplifies the process of creating detailed descriptions for your Processes.

Key Highlights:

  1. Description Creation: Users can initiate the process by simply clicking a button to have the Frends LLM generate an initial Process description and documentation based on the BPMN Process designed, variables and Tasks used as well as any user provided documentation.
  2. Fine-Tuning with Additional Prompts: After receiving the initial response, users have the flexibility to provide additional prompts to further refine and customize the generated description.

0 %


 In progress

Request a feature

Found a bug? You can report it here.

Vote for a feature

Possibility to jump to an error from the process instance view

It would be good if it were possible to jump to a specific error from the process instance view and not have to go through (for example) the parent process, then the subprocess and then that subprocesses subprocess to find the error.

Support for private NuGet package registries

As a developer I would like to be able to add private/corporate NuGet package registries in Tasks -> NuGet sources.

In our company, we plan to develop custom Frends tasks, for our internal needs, having some domain-specific logic and possibly dependencies on our other internal libraries, services etc. We cannot push our NuGet packages to public registries and currently the only way to use our custom tasks is to import the packages manually.

Clearer input type selector

As a developer it would be nice to see directly which type is selected for a field (text, JSON, expression...) with one look. F.ex. different background color

Tags -information to Frends API

As a Frends API consumer, I would like to get information about the tags of a Process.

Improve IDisposable developer experience

Currently, developers need to remember to manually toggle "Dispose at the end of the scope" for all task elements, whose result is IDisposable. This is very error-prone, because users of Frends tasks often don't know about the internals, such as which types need to be disposed. Even task developers can occasionally just forget disposing when using their own tasks.

My request is that Frends removes this footgun by somehow automating the toggle. Below are some possible solutions:
1) Make the toggle true by default.
2) Interpret some data annotation (provided in the task's C# source code) to mean that the toggle should be on by default.
3) When the task is imported, check whether the task's return value is IDisposable and set the toggle according to that. Although this doesn't work for tasks whose return type is upcasted to object, it's sufficient for most users.

As a developer I would like to be able to list environment variables that are no longer in use

Cleaning up old environment variables that are no longer in use in any process/subprocess requires a lot of manual work. Could there be some mechanisms to filter the list of environment variables, for example a prefefined "Not in use in any environments", which would leave only those environment variable groups & variables visible, which are no longer in use?

As an operator I want to know visually which Environment is selected

You should be able to assign a color for an Environment, which would be shown as the background color for the navigation bar, so an operator knows which Environment is current selected.

As a developer I would like to differentiate between technical and logical errors for Process results

When Process has been successful, it is marked with green icon. When it has failed, it is marked with red icon. We have encountered that we would need another icon to indicate cases where - in the technical perspective the Process has passed and - in the logical/validation perspective the Process has failed. One example of this is that integration itself works as it should but there is invalid content in some field. For example ERP returns an error of an invalid cost center. Then it would be great to be able to mark Process instance in some way in order to ease the error finding. Because in some cases persons who are using external systems that send data to ERP ask integration people what's wrong.

Allow linking to specific environment variables

As a developer, I would like to share URLs to the environment variable page that expand a specific environment variable group, expand a specific environment and/or focus/scroll to a specific environment variable in that environment.
More specifically, the following URLs should work (URL structure not really important, just illustrating the use cases):

Furthermore, navigating the environment variables page should automatically update the current URL (probably using history.pushState) to the selected environment variable group so that the URL can be easily copied.

As a developer I would like to edit process schedules straight form the process list

It would be a great QoL improvement if we could see and edit process schedules without needing to publish a new version of the whole process. Currently you can not even see when the process will trigger without opening the whole process in the editor. Scheduling should be done outside of the actual process.

Webhooks from Frends

As a manager I would like get notifications when something has been changed in Frends configuration such as process is deployd to production, or new Agent is Added in Frends. All Frends had to do is ability to send http request of when something happens. I can then use e.g. Frends to create nice Slack etc. notification from that.

As a developer I would like to search for item in for/which loop which has not errored, but has a problem with parameters inside

Some cases the problem is not that the loop errors, rather than a specific item in the for loop that has to be found to see what happens to it.

As a developer I would like reorganize subprocess parameters

Allow drag-and-drop, or some kind of buttons, to reorganize the parameters for a subprocess. Sometimes you add a new one later on that should be grouped with parameters other than the last ones.

As a developer I would like to have changelog + comments functionality expanded


  • Changelogs are useful way to document and get information about project’s history: why and when something has happened. This functionality is well implemented currently for Processes. But there is no changelogs available for example for User Management, API Keys + Rulesets and Monitoring Rules. Also even though Environment Variables have a pretty good version history, it could be even more informative. --> By extending changelog functionality, all important Frends changes would have an option to include a descriptive comment of the change. Changelogs would offer a wider view of what have happened in Frends.


  • Expand changelog functionality of Environment Variables
  • Comments as a new feature: When making a change, comment could be added to include info about the change for example Jira ticket id etc. Similar like is currently used in the Process editor. Comment would be also displayed in the Change Log.
  • Show changelog on group level (In addition to an individual environment variable): Fields to be displayed: Environment, VariableName, PreviousValue, NewValue, Modifier, ModifiedAt, Comment. --> This would provide an easy way to have an overview of what have happened on a group level.
  • Add changelog functionality to following areas
  • User Management
  • Api Keys + Rulesets
  • Monitoring Rules

Launching parts of a process

Would be nice to have capability to:

  • launch process from certain point;
  • resume processes from certain point (of failure for example with params);
  • launch single tasks from UI, like REST/SQL tasks (similarily to what you do with postman or curl on desktop;

As a developer I would like to see the source code for a Process easily

It would be nice to be able to download the source code and the Process package for a Process. This could be possibly added to the Process version history dialog

As a developer/operator I would like to be able to get Agent statuses through the Management API

For monitoring Agent statuses automatically it would be nice to have an endpoint on the Management API to be able to query the status of Agents. The result could contain the following data:

  • Agent name
  • Last update
  • Last status
  • Last error

At the same time the event log could have a separate end point with the following data:

  • ID
  • Event hash (not sure if this is necessary)
  • Agent name
  • Level
  • Message

As a developer I would like to use async/await inside of a code shape

Currently it is not possible to use asynchronous calls inside of code shapes due to us wrapping the code inside of an action. But if you would like to use an async method, e.g. await Task.Delay(1000), you can’t do that and have to block the thread, which is bad.

Currently if the Process has any async Tasks it is executed asynchronously, so we could add a similar feature to code shapes to mark them as async if they contain the await keyword

As a developer I would like know when a Task is being deprecated or reaching it's end-of-life

It would be nice if we had a public listing of Task EOL dates and some description/explanation. This could be refreshed daily for the and shown in the UI if you’re editing or creating a Process that is using a Task that has a known EOL.

It could be possible add information about Task deprecation to the Tasks portal, but that might not be as discoverable as in the UI.

On further review this would be best implemented by using the NuGet deprecated field, but that is currently not supported by Azure DevOps NuGet feeds. Please upvote the feature request here if you find this feature necessary:

Don't show email address on every page

As a normal internet user I don't want show my email address too often. Unfortunately Frends will show it always, all the time in every page. Therefore it shows on screenshots, screen share etc.

It could be replaced with for example a 👤 .

Frends UI "Last changed" widget

It would be helpful to have a widget that shows "last changed" integrations in dashboard.

Orderable Subprocess input parameters

Currently, the input parameters for a subprocess are stored in the order in which you create them. It would be beneficial to have the ability to order them either by drag and drop or in alphabetical order.

Tags in Enviroment Variables

As a administrator it would be nice to be able to Tag Environment Variables, this would allow quick filtering and restricting access to edit only certain values.

As a developer I would like to be able to switch into "simple GUI" and fit more details in the screen

The current user interface style has quite a lot of whitespace (for example columns are taking more space than their contents is, UI elements have a lot of space around them etc). Some users may feel this increases user friendliness and ease of use. However, some users might prefer "tight/compact" UI, where more data is shown in screen. Could there be a toggle which allows user to choose "relaxed & visually attractive vs. compact & simple" user interface? This could be a similar per user toggle like dark mode.

As a developer I would like to deploy version of a process/subprocess to multiple agent groups at the same time

If process/subprocess is deployed to many agent groups, user is required to perform multiple deploy activities for getting the change updated to all required environments. Easier solution would be to allow user to select multiple agent groups at the same time from the deploy dialog.

gMSA support for agent

Running agents on-prem with gMSAs (group managed service accounts) eases management of user accounts and is more secure as the password management is automated.

Currently the installer does not allow empty passwords as it internally always calls "sc.exe" with "pw= " no matter what. Pretty much the only major change that would be required is to allow setting the password to null and removing "pw=" argument in this situation. (The gMSA account will need "run as service" privilege on the server, but iirc sc.exe should not return errors even if the said privilege has not been set).

As a developer I would like to have more advanced search functionalities in the process editor

For example possibility to list all references for a certain variable or environment variable. Maybe also a free text search against all the editable sections inside a Process (including element names, all the configurable settings of an element, code statements etc.).

The search functionality and the results could be in a separate window somewhere inside the Process editor, maybe included in the Toggle Minimap etc features section in the lower left corner. Results could be shown as a list including the element name and the name of the config setting of the element which matched the search. Also total count of matches could be displayed.

After the search, Process editor could automatically highlight all the elements that matched the search. And by clicking a result in the search list, Process editor could automatically adjust the element in the center of the canvas, open the config settings of the element and highlight the setting(s) that matched the search.

As a developer I would like to edit the name of environmental variables and update the reference in each process where it's used

I've not yet found a good way to refactor the environmental variables when you for example realize a spelling mistake in a group or on the variable itself. Or maybe you just find a more suiting name of the variable over time. I think it would be a great addition to be able to edit the variable/group name, and then cascade update each reference to the variable in all processes where it's implemented.

As a developer I would like to find where environment variable is used inside a process

It is easy to find process where environment variable is used. But in process it might be a bit tricky, specially if process contains dozens of tasks. Is it possible to add environment variables to find?

Agent should support also other databases in addition to SQL Server

Currently the only officially supported database for the Agent is Microsoft’s SQL Server. It would be beneficial and more cost effective to also support other SQL databases, such as PostgreSQL or MySQL which do not require a separate license.

As a developer I would like to have a preview of task settings

As a developer I would like to have two task windows open at the same time side by side, similar to when you have a task selected and you open e.g. snippets from the side. It would make life so much easier when you need to copy and move parameter values to another task block. Clicking on the background may close both for ease of use.

As a developer I would like to bookmark a part of a process in the edit view

Could there be a point or some mark that indicates what will be in view (by default) when you open the process edit view? Like some mark that indicates this mark is the left upper corner of the default view / what someone opening the process in editing view will see first?

Could the canvas be slightly gray in the area that will be the default view when opening the edit view of a process? Then developer knows that they can have the important part of the process in view immediately when opening the process.

As a developer I would like to have option to automatically validate incoming request based on OAS on API Trigger

What: API Trigger could have a boolean setting “ValidateInput” for enabling incoming requests validation (+ maybe also a sub Boolean setting for not allowing whitespacecharacters for string parameters?). Validation would be done for all the parameters specified in the OAS including for example path and query parameters. For Post requests validation would include also the payload. Validation would be done in a similar way as is currently done with the jsonschema task: Datatypes and required fields would be verified. API Trigger would return a new object called “InputValidation” in case of ValidateInput would have set to true. Validation object could have for example IsValid Boolean + list the failed parameter info. Frends could either 1) Directly return HttpStatusCode 400 + errormessage to caller or 2) In the Frends process, custom process logic could be implemented against InputValidation object, where InputValidation.IsValid could be checked and process execution could proceed or a custom response returned.

Show the task alongside bpmn label

As a developer it would be nice to know which tasks is used in bpmn block in smaller font next to label of block (REST/SQL.. etc.).

As a developer I want to give Process variables a description

Having descriptions for Process variables makes them a lot easier to use them and would be pretty necessary when using them for Process Templates

As an administrator I would like to have an Admin page where I can see information about the status of the platform

There is a need for an Admin page where an admin could see relevant information about the status the platform.

Information that could be shown:

  • Service Bus status
    • Queue lengths
  • Database status
    • Size used/quota
  • Logs
  • Etc to be added

As a developer I would like the parameter type to be visible all the time

A common problem is that the editor type is left as Text instead of Expression which causes the Process to end up in an error. As a suggestion the type could be left visible all the time instead of just when hovering over the field with the mouse cursor.