Introducing Paragraph - Integrations as Code

Today, we’re excited to announce the launch of Paragraph - the biggest product update we’ve ever released since launching Paragon.

Paragraph is a new scripting language that provides a code-based representation of all Paragon integrations, workflows, and configurations, which can be synced to your git repository for version control and code review. This enables your team to ship product integrations more safely and reliably, as all Paragon integration development will run through your existing software development lifecycle (SDLC).

Paragraph Demo Video

To give you a quick preview, here's a video of our lead product manager, Ethan Lee, walking through the end-to-end developer experience with Paragraph.

We created Paragraph as the first major step towards our vision of Integrations as Code, providing developers with the flexibility of code while leveraging all the features of a managed integration platform.

This is the next phase of the Embedded iPaaS space.

The next phase of embedded iPaaS: Integrations as Code

The integration platform (iPaaS) space originated with products designed for internal automation, like Mulesoft and Zapier. These products abstracted the complexity of third-party APIs with pre-built connectors and low-code user interfaces, and were designed for business users to easily integrate internal tools like spreadsheets and CRMs.

The second phase of iPaaS began more recently with products such as Paragon, that applied the concepts of iPaaS to native product integrations. The resulting category, Embedded iPaaS, was created to help developers build native integrations into their product to easily integrate with their customers’ applications.

However, the low-code nature of Embedded iPaaS solutions required integrations to live entirely outside of developers’ SDLC. This not only requires developers to adopt a completely different process, but there is also no way to track changes or version control integrations, which presents a huge problem given that integrations are a mission-critical layer for SaaS products.

Paragraph, in conjunction with Git Sync, solves these problems in a way that allows developers to utilize Embedded iPaaS in a way that is native to their existing SDLC, without the limitations of low-code.

Introducing Paragraph

In designing Paragraph, we wanted to create a framework familiar enough for developers to quickly learn, while flexible enough to solve the hardest problems with integration development.

Low-code workflows have great advantages for developers building integrations - they’re easy to start using, inherently self-documenting, highly observable, and provide high-availability serverless runtime. However, they can also be limiting for developers who are used to the flexibility of developing in code - learning to use a low-code UI requires adopting a new process with more limitations than they’re used to.

Our first goal with Paragraph is to offer developers all the benefits of Paragon workflows, like managed authentication, pre-built integration connectors, and a serverless workflow engine, while providing the flexibility of developing in a familiar language - Typescript.

Here’s an example of a Salesforce integration workflow in the Paragon workflow builder, and how it is defined it Paragraph:

 define(
    integration: ISalesforceIntegration,
    context: IContext<InputResultMap>,
    connectUser: IConnectUser<IPersona<typeof personaMeta>>,
  ) {
    /**
     * declare all steps here
     */

    const triggerStep = new EventStep(event);

    const searchContactStep = integration.withIntent(
      integration.intents.SALESFORCE_SEARCH_RECORDS,
      {
        recordType: 'Contact',
        filterFormula: Operators.StringExactlyMatches(
          'Email',
          triggerStep.output.email,
        ),
      },
    );

    const checkIfExistsStep = new ConditionalStep({
      if: Operators.NumberEquals(actionStep.output.result.totalSize, 0),
      description: 'New Contact?',
    });

    const createContactStep = integration.withIntent(
      integration.intents.SALESFORCE_CREATE_RECORD,
      {
        recordType: 'Contact',
        'field-FirstName': `${triggerStep.output.firstName}`,
        'field-LastName': `${triggerStep.output.lastName}`,
        'field-Email': `${triggerStep.output.email}`,
      },
      
    );

    const updateContactStep = integration.withIntent(
      integration.intents.SALESFORCE_UPDATE_RECORD,
      {
        recordType: 'Contact',
        recordId: `123`,
        'field-FirstName': `${triggerStep.output.firstName}`,
        'field-LastName': `${triggerStep.output.lastName}`,
        'field-accountId': ``,
        'field-Email': `${triggerStep.output.email}`,
      },
    );

    /**
     * chain steps correctly here
     */

    triggerStep
      .nextStep(searchContactStep)
      .nextStep(checkIfExistsStep.whenTrue(createContactStep).whenFalse(updateContactStep));

    /**
     * pass all steps here so that paragon can keep track of changes
     */
    return this.register({
      triggerStep,
      searchContactStep,
      checkIfExistsStep,
      createContactStep,
      updateContactStep,
    });
  }

All Paragon projects, integrations, and workflows can be represented and developed in Paragraph, and integrations developed in Paragraph will compile to visual workflows in the Paragon UI.

This means that when using Paragraph, you can use the same managed authentication and integration connectors available in the Paragon workflow editor. For example, writing a request to Salesforce in Paragraph is as simple as:

We’ve found that Paragraph not only makes it faster and easier for developers to build integrations on Paragon, it also allows for powerful new implementation and design patterns.

One key design pattern is that of unification. Paragraph enables developers to define re-usable abstractions for business logic or workflows that can be referenced across multiple integrations, providing a unified integration development experience without the limitations of a unified API.

Git Sync

As part of our Paragraph launch, we built Git Sync. This enables all workflows, integrations, and configurations to be automatically synced to your git repository for version control and code review, enabling all Paragon development to run through your existing SDLC.

Any project changes made in the Paragon UI are automatically pushed as commits to the connected Git repository, and can be pulled into the corresponding Paragraph project. Vice versa, changes made to the Paragraph project are pushed as commits to the connected Git repository, and automatically synced back into the corresponding Paragon project.

The end result is a full bidirectional sync between development in Paragraph and the Paragon dashboard — with all changes tracked, versioned, and source controlled in your git repository.

Our team has been hard at work over the last year building Paragraph, and this is only the first step toward our vision of Integrations as Code. Today’s launch paves the way for us to reshape the future of integration development and unlocks more exciting possibilities in the future—especially with the recent advancements in generative AI. We look forward to sharing more updates on Paragraph and what we’re working on next.

Paragraph and Git Sync is now available in GA to all Paragon users - if you’re interested in learning more, check out our docs or schedule a demo with our team.

—

Thank you to our incredible team, our beta users who shared their feedback, and everyone else who helped make Paragraph possible.