Frends roadmap

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

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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 👤 .

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

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.

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.

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.

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.

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).

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.

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.

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?

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 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.

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.

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.

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.).

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

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

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.

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.

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

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

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.

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?

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.

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.

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):

• https://tenant.frendsapp.com/EnvironmentVariables/MyEnvVarGroup
• https://tenant.frendsapp.com/EnvironmentVariables/MyEnvVarGroup/Development
• https://tenant.frendsapp.com/EnvironmentVariables/MyEnvVarGroup/Development/MyEnvVar

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.

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.

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.

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.

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.

Why:

• 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.

What:

• 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

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;

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

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

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

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: https://developercommunity.visualstudio.com/t/mark-packages-as-deprecated-in-azure-artifacts/1267756