Decide Low-Code or Code-Native
The Prismatic low-code designer and code-native SDK are both great tools that you can use to build, test and deploy integrations. When using the low-code designer, you build integrations by adding triggers, actions, loops and branches to a canvas. When using the code-native SDK, you write TypeScript code to define your triggers and flow logic.
Depending on your team structure, technical expertise, and the complexity of the integration you are building, you may choose to use one or the other. Let's look at a quick comparison, with more detail below:
| Topic | Low-Code | Code-Native |
|---|---|---|
| Build method | Integration builders add triggers, flows and steps to an integration using the low-code integration builder. | Integration builders write triggers and integration logic in TypeScript using the code-native SDK. |
| Flows | A low-code flow is a sequence of steps that run in a specific order specific order. | A Code-Native flow is a JavaScript function that executes when the flow's trigger is invoked. |
| Config Wizard | Config wizards are built within the low-code builder. | The config wizard is defined in TypeScript using the code-native SDK. |
| Testing | Integrations are tested from within the integration designer. | Integrations can be tested within Prismatic, or locally through unit tests |
| Step results and logs | Step results for each step are collected and stored and can be viewed later | Code-native integrations are "single-step", and logging can be used for debugging |
| Best fit for | Hybrid teams of developers and non-developers | Highly technical teams who prefer code |
Low-code and code-native flows
A low-code flow is a sequence of triggers, actions, loops, and branches that execute in a specific order. For example, a flow might fetch a set of records from an API with a built-in action, loop over the records with a loop step, make a decision about each record with a branch step, and ultimately send relevant records to another third-party app with an HTTP step.
A code-native flow is comprised of some metadata about the flow along with a couple of functions that are defined using TypeScript.
When a code-native flow is run, your onTrigger function is called to generate a response to the caller, and then your onExecution function is run.
Rather than a low-code loop, you can write native TypeScript for, forEach or map functions.
Rather than a low-code branch, you can reach for an if/else or switch/case statement.
It's important to note that code-native flows do not have "steps" in the same way that low-code flows do. You can think of a a code-native flow as a single-step flow, where all of your flow's logic is defined in a single TypeScript function.
Regardless of your choice, both low-code and code-native integrations can be added to your integration marketplace and deployed in the same way - your customers won't know the difference.
Low-code and code-native config wizard
The low-code config wizard is built in tandum with your integration. Connection config variables are automatically added when you add a new component to your integration, and additional config variables and data sources can be added to the config wizard as needed through the UI.
The config wizard for code-native is defined in TypeScript. You can define your own required connections, config variables and data sources, and these config options will be presented to customers deploying your integration in the Prismatic UI in the same way that low-code-designed integrations are. Additionally, after publishing your code-native integration you can preview the config wizard in the Prismatic UI to ensure that it is working as expected.
Testing low-code and code-native integrations
Testing of low-code integrations is done through the Prismatic UI as you build your integration. You can view logs and step results from executions, and send data to your test triggers from third-party apps to simulate real world usage.
You can also test code-native integrations in the Prismatic web app. After publishing a code-native integration, you can run tests in the Prismatic UI to ensure that your integration is working as expected.
In addition to in-app testing, you can write unit tests for your code-native integrations. Unit tests allow you to test your integration's logic in isolation, and can be run locally or in a CI/CD pipeline.
Step results and troubleshooting low-code and code-native integrations
Low-code integrations are comprised of steps, and the results of one step can be referenced as input by a subsequent step. Each step's results can be viewed in the Prismatic UI. So, if an instance of one of your integrations fails, you can view the results of each step to determine where the failure occurred.
Code-native integrations do not have steps in the same way that low-code integrations do. When a code-native integration fails, you can view the logs in the Prismatic UI to determine where the failure occurred. As you build a code-native integration, we recommend including logging statements in your TypeScript code to help you troubleshoot issues. You can drive logging output from a boolean config variable, so that you can turn logging on and off as needed.
When to use low-code vs code-native
You may want to reach for the low-code designer when:
- Your team is looking to save dev time and has non-dev resources that are technical enough to build integrations.
- It is important to your non-developer team members to have a visual representation of the integration.
- You would like your customers to build their own integrations using embedded designer.
You might want to use code-native when:
- You have a highly technical team that is comfortable writing TypeScript.
- Your integration requires complex logic that is easier to write in code.
- You want to unit test entire integrations rather than individual actions and triggers.
- You want to use a version control system to manage your integration code.
Low-code and code-native FAQ
Can I use both low-code and code-native integrations in the same account?
Yes, you can build both low-code and code-native integrations in the same account. Some integrations may lend themselves to one or the other, and both low-code and code-native integrations can coexist in your integration marketplace - your customers won't know the difference between a low-code and code-native integration.
Can I use existing components in a code-native integration?
Prismatic offers hundreds of built-in components to connect to a variety of third-party apps, and you can [build your own]custom-components/writing-custom-components.mdx) components using the component SDK.
Currently, you can use connections, data sources, and triggers from existing components in a low-code integration, and support for referencing existing components' actions in code-native integrations is coming soon.