Paragon vs. Prismatic: Which Code-Native Approach Should You Pick?

Our team often gets asked how Paragon differs from Prismatic, particularly in our code-based approaches (Paragon's framework is called Paragraph). As the Director of Product at Paragon, I've had the opportunity to deeply consider how we can best solve the needs of modern development teams, and have deeply evaluated the differences between Paragon and Prismatic's approaches.

This memo is focused on the differences between our architecture, key features, the developer experience, and overall design considerations. My goal is to provide you with the insights needed to make a more informed decision for your integration needs.

Architectural Approaches: A Deeper Look

Prismatic: Lowering to JavaScript

Prismatic employs a low-code approach where workflows created in their visual builder are lowered to a JavaScript representation. This compiled result runs in a Node.js environment, essentially creating a single running program for each workflow.

In practice, this means:

• Each block in the Prismatic builder compiles to JavaScript code.

• The entire workflow becomes a single Node.js script.

• Execution is limited to the capabilities and constraints of a single Node.js process.

This ‘lowering’ approach is why integration logic written in Prismatic’s JavaScript representation cannot be re-compiled into the low-code editor.

Paragon: Lifting to a Workflow Engine

At Paragon, we use a Typescript-based framework called Paragraph, which is lifted into a sophisticated workflow runtime. Instead of compiling to a single script, our approach preserves the workflow construct, which allows for much more granular control and functionality at the workflow level.

Our architectural approach involved:

• Defining workflows in a task orchestration framework (Paragraph).

• Lifting this definition into our workflow runtime.

• Managing execution as a series of discrete steps rather than a single continuous process.

Design Considerations for Paragraph

When we initially built Paragraph, we were inspired by several key concepts:

Infrastructure as Code

We drew inspiration from tools that allow developers to define and manage infrastructure through code, which brings the benefits of version control, code review, and automated testing to infrastructure management. These are all things we brought into Paragraph.

Collaboration Between Teams

We recognized the need for a solution that could bridge the gap between developers and other stakeholders in the integration process, be it technical product managers or support teams (when it comes to debugging). Even though we believe that engineers should own the core development of integrations, we saw consistently across our customers that multiple teams were using Paragon.

Flexibility and Scalability

We aimed to build a system that could be extended to support even the most complex integration logic, but more importantly, could scale to support our enterprise customers’ usage.

Key Advantages of Paragraph

In terms of the implications of our lift approach with Paragraph, there are a few reasons why we believe it is a fundamentally better than Prismatic’s code-native framework.

Efficient Data Handling

Unlike Prismatic's approach of running everything in a single Node.js process, Paragon's workflow engine is designed to handle data in streams. This makes it suitable for integrations involving large datasets, as we can process large volumes of data without loading everything into memory at once. For example, when syncing millions of records from your customers’ CRMs to your data warehouse, Paragon can stream the data in chunks, processing and transforming it on the fly. This not only reduces memory usage but also allows for real-time processing and faster overall execution times, especially for data-intensive integrations.

Fine-grained Task Prioritization

Paragon allows for detailed control over task priority within a workflow, whereas in Prismatic, you're generally limited to prioritizing entire workflow instances. This granular control is particularly useful in complex integrations. For instance, in an order processing workflow, you could prioritize payment processing steps over less time-sensitive tasks like updating inventory records. This ensures that critical operations are completed first, improving the overall efficiency and responsiveness of your integrations.

Durable Execution Snapshots

Instead of a single long running script, Paragon takes snapshots of inputs and outputs for each step. This is powerful for a few reasons:

• Rate Limiting: If an API rate limit is hit, Paragon will pause execution and resume exactly where it left off once the limit resets.

• Error Handling: If an error occurs, you can fix the issue and resume the workflow from the last successful step, rather than starting over.

• Auditing: You have a clear record of what data was processed at each step, which makes debugging and compliance much easier.

These smart rate limiting and workflow suspension features are supported out-of-the-box, whereas with Prismatic, you’d have to write all of this logic yourself which can be extremely complex.

Extended Runtime Capabilities

While Prismatic workflows are typically limited to 15-minute runs, Paragon can handle long-running processes by suspending and resuming workflows as needed. This is a fundamental architectural difference that provides significant benefits for complex or time-consuming integrations. For instance, if you're migrating years of historical data, or processing a large backlog of records, Paragon can handle this over hours or even days if needed. The workflow will automatically suspend when it hits platform-imposed time limits, persist its state, and then resume when it's able to run again. This happens seamlessly without any need for the developer to manually manage this process or write custom code to handle long-running jobs.

Dual Representation

One additional benefit of our ‘lift’ approach is that any changes made in Paragraph is reflected and maintainable in the workflow editor, and vice versa. This unique bilateral representation between code and visual environments bridges the gap between developers and anyone else that may touch integrations, whether it be a technical PM who may want to understand or even tweak the logic, or support staff who need to debug issues for users.

Of course, all of the changes made by the less technical team members will still be version controlled and code reviewed by engineering, mitigating risk of unvalidated changes going into production.

Type Safety

Since Paragraph is a Typescript framework, it provides type safety which reduces potential errors and the introduction of unvalidated code. So while it's true that you can write any code you want in Prismatic's code-based framework, you have to carry the cost of validating and maintaining that code.

Summary of the Advantages

If you’re a team of one or are building an MVP of an integration that has low usage, you may not find value in many of these differences.

But in production and at scale, these advantages come together to make Paragon a more flexible, scalable, and more enterprise-ready platform, better-suited for complex, data-intensive integrations.

Example: Handling rate limits

Just to make it even more tangible, I think it would be helpful to go into a real-world scenario in more detail: encountering Salesforce's rate limits during a large data sync operation.

With Prismatic's code-native approach, you may need to:

1. Implement custom logic to track API calls.

2. Manually pause the script when limits are approached.

3. Store the current state and schedule a new run.

4. Restart the entire script from the beginning, skipping completed work.

That is a lot of custom logic your team will need to write just to ensure your background jobs are resilient.

On the flip side, with Paragon:

1. The workflow engine automatically tracks API calls.

2. When a rate limit is encountered, the workflow is automatically suspended.

3. The exact state of the workflow is preserved.

4. After the required wait time (which could be hours), the workflow resumes exactly where it left off.

Some Disadvantages with Paragraph

All of those fundamental advantages aside, I think it's important to be transparent on the potential drawbacks with our approach with Paragraph:

1. Complexity: Using Paragraph will require your developers to learn our syntax. As a result, Prismatic's JavaScript-based approach may allow for a shorter learning curve, especially for simpler use cases. But while there is a learning curve, due to the bidirectional nature of our approach and the built-in Types Paragraph provides, we’ve found developers to pick it up quite quickly.

2. Future Parity: Certain features, such as fine-grained sync between our code and visual editors, are still in active development and there will be certain capabilities (such as complex configurations) that will be possible in Paragraph that we may not support in the visual editor. For these edge cases, we plan to make certain components view-only in the visual editor.

3. Debugging Complexity: Our distributed approach to workflow execution can sometimes make debugging more challenging compared to single-script solutions. As one example, we parallelize executions in Fan Out steps which allows for concurrent iterations through an array, but can add complexity to our logs. For that reason, we are making concerted efforts to improve the Task History experience for these scenarios.

4. Reusability Model: While Paragraph offers robust reusability within its framework, some users might find Prismatic's ability to call workflows via API endpoints more intuitive for certain use cases. That said, this is solved with our Request Triggered workflows, and we are also evaluating native steps to ‘call another workflow’.

Conclusion

Choosing between Paragon and Prismatic isn't about selecting a universally better platform. It's about finding the solution that best aligns with your team's skills, the anticipated scale of your integrations, and whether you want non-engineers to benefit from the tools provided.

If you’re looking for a code-based approach that is familiar and quick to pick up, and your integration use case is low-volume, Prismatic is a very valid choice.

But if you're looking for a platform that can support integrations at production-scale, and preserves the benefits of a visual workflow editor/debugging log for your product and support teams, we believe Paragon offers a much more future-proof choice.

If you want to dive even deeper into this, feel free to book a call with us - happy to share more around our philosophy and future roadmap.