Pipefy – When is it no longer enough?

When talking about organizing processes in pipelines, a lot of companies think of Pipefy (it’s right there in the name!) The tool can be quite handy when you have workflows with very clearly defined stages, and is clearly optimized to do so. From conditional fields to ease to pipeline continuity, Pipefy has a lot of tools that can help companies build their first systematic, teamwide workflows. 

However, there are also some limiting factors that can hinder scaling up processes, especially when you need complex automations, custom integrations, and in-depth permissioning controls.

We’ve written this article to highlight some of Pipeline main features and how they can help you–and when they may start letting you down.

Disclaimer: all information below reflects both Pipefy and Jestor as of the moment this article was published, and it only reflects my personal opinion and experience. 

Pipefy is Designed for pipelines (for good and bad)

Pipefy is a tool designed specifically for pipelines. As such, it’s designed with stage-oriented workflows in mind. 

For example, as soon as you create a new process (such as Recruiting), it is immediately created as a kanban board. This shortens the time spent building structures, as the overall structure is already pre-built from the get-go. 

Another way Pipefy shines in pipeline processes is with conditional fields. It’s very easy to set up a board so a field only appears to a user depending on how they have filled previous fields. For example, only showing the field “Number of Installments” if the payment method is “In Installments”.

Finally, another great feature for workflows is that fields are always attached to a specific stage. That means some fields are automatically hidden when a card is in a certain stage, which can be extra useful for ensuring ease of use. 

So, as you can see, Pipefy is a great tool if you’re trying to build workflows alone. However, that does come with certain downfalls.

Being a workflow oriented tool means it’s not a database oriented one. The platform will guide you to build the structure that best suits user input. However, while it’s quite easy to build a lot of superfluous fields and hide them as you wish (out of sight, out of mind), this tends to incentivize building structural behemoths with messy data. It’s not uncommon for Pipefy users to export their boards and find that they are basically single tab spreadsheets with tens or hundreds of columns, some of them barely filled out.

This means one of the central problems of spreadsheets–that is, hard-to-organize, difficult-to-automate data–is carried directly into your processes, even if they get a friendlier interface. So, even when looking at the table/database view of pipelines, info may not be readily understandable, dashboards may be hard to assemble, and automations may sometimes not be possible. In the end, processes may end up breaking as your company scales up.

Jestor, on the other hand, is a database-first process building tool. This means that, when you start out creating a process, you’re creating it as a database/table, and then work on shaping it into a workflow.

That said, it will not be as fast to get started as Pipefy when you’re trying to build a pipeline, and some features that the latter has are only really possible when the tool is designed specifically for that purpose. However, database-first mindset also ensures that you can build infinitely scalable processes that are fully automated, integrated, and organized. Many companies end up using Jestor as the core software of their company, pulling and orchestrating data from different sources and platforms, because Jestor’s focus on data structure instead of process linearization allows it to make any automation possible, regardless of the number of people or data workload involved.

All in all, this means Pipefy may be the best solution for smaller teams who want to focus on kanban optimization and don’t care about maintaining a tidy data history or integrating those processes into the backbone of the company. Other companies, however, may see a demand for more robust solutions.

Pipefy has Entangled, hard to use connected data

One other thing that may hinder a company’s ability to scale when using Pipefy is the manner in which the platform creates data connections. 

Simply put, Pipefy uses n:n (or many-to-many) connections when linking records. This means that on the same field in a Client card, for example, you may select many Deals cards at the same time. 

If this doesn’t sound so strange, well… it isn’t. It’s how a lot of no-code platforms allow for connections, including other known tools such as Airtable or ClickUp. The problem is: many-to-many connections are exactly why many processes break, even when users don’t realize it. 

Having these types of connections mean you can never be sure how many items you will have in a single field. A customer may have three different addresses, another one may have only one. So, when it comes to automating processes, there’s no way to standardize how you want to use that data.

For example, if I were to send an automatic e-mail to the first customer and want to use their home country, should I get the country value from the first, second, or third address? As you can see, having many end options brings ambiguity into the process, so you’re usually stuck with one of the following options: creating a process that may use the wrong values from time to time, or not even being able to create them at all.

In Jestor, however, all connections are made as 1:1 or n:1 connections. This means you can always follow connections and end up in a singular, final record. This means instead of ambiguity, connections bring clarity to the process. You can create an automation and rest assured that the end result will always be predictable, regardless of how many times you run the process.

This doesn’t mean it’s impossible to create n:n connections inside Jestor: you can do that with the use of auxiliary tables. And, when that happens, there are separate automations designed specifically for these cases. 

By “restricting” the way you can create connections, Jestor is able to guide you into creating more scalable structures, and ends up having more powerful and flexible no-code automations, ultimately giving you more freedom to use your data.

Pipefy has Little automation variety

Speaking about automations, there are two ways Pipefy lets you create no-code automations: in-built pipeline automations, and Zapier powered automations. 

The bulk of no-code automating power comes from the Zapier. If you’re not familiar with this tool, Zapier is an automation and integration platform that lets you create no-code sequences of events. For example, “When a row is created in Google Sheets, create a card in Pipefy”. It is a wonderful tool that makes your data a lot more powerful and is very intuitive to use. 

There are, however, two main points that should be brought up when discussing Zapier:

1. It is a separate platform with a pricing of its own. This means a low-to-moderate volume of automations will already incur in extra costs for your operation.
2. Zapier is not a Pipefy exclusive tool. This means any positive aspects of Zapier automating could be applied to any other software that is also present in Zapier’s ecosystem (including Jestor!)

Another problem with Zapier is that while it’s awesome to connect a lot of different platforms, it has to be somewhat generic. In-depth, contextual automations are usually not possible unless the platform you wish to connect has spent a lot of time creating different “Zaps”, which isn’t always the case.

That’s when in-built no-code automations come in. Luckily, Pipefy also has some of those. And, as far as pipeline automations go, it covers the most used event triggers and actions users may need. If you need simple event triggers and actions, such as “Create a card in the Billing pipeline when a Sales record goes to Won”, you’ll have no problems creating this through the automation wizard.

However, a quick test will also reveal that there aren’t a lot of things you can do with these in-built automations. With a handful of event triggers and actions that are mostly focused on creating or moving cards around, there’s no real way to treat data or create more complex processes than advancing workflows. This should come as no surprise if we remember Pipefy’s focus on being a pipeline manager. 

On Jestor, while you can use Zapier, you also have a good deal of in-built no-code automations called Tricks, which range from simple and generic to very specific, data oriented actions. For example, you may set an automation to run when a record is created in specific days and times, and update/create records, aggregate values from connected records, send Slack messages, or create tasks for team members.

Not only are there native integrations you can use however it fits your operations, but you can even create webhooks to receive data, and send information to external webhooks or endpoints with no-code tricks, effectively allowing you to connect to almost any other open platform.

It feels much like having an internal Zapier, but one that is included in the pricing and that allows for more complex automations, given that the same platforms holds the data and the automations themselves.

Pipefy has Simple, non-interactive dashboards

Apart from letting you create pipelines and databases, Pipefy lets you create dashboards to organize your data visually, with charts and numeric indicators to help you with quick insights about your processes.

A cursory tour, however, will show you that there’s not a lot of depth to this specific feature. As Pipefy does not focus heavily in data organization and analytics, the options are somewhat limited in what you can create and see here, with the aforementioned charts and indicators taking the front seat and not allowing for much customization.

One of the weakest points of the dashboards, however, may be the fact that they are not interactive at all. Using them feels much like constructing charts and tables in Excel: they’re something to look at, but not be used or interacted with in any capacity.

Jestor takes a whole different approach to dashboards by encompassing them in its Apps feature. 

Apps are basically sections of Jestor in which you can create components. These components can be what you expect from regular dashboards: charts, indicators, and filtered, smaller versions of pre-existing tables. However, in addition to these basic components, you have more advanced tools to build a command center for your operation: calendars, forms, shopping carts, and even custom filters that affect the other components.

Jestor’s apps are not only designed to condense information like a dashboard, but to create new ways in which you can interact with your data, and it does so by allowing most components to be interactive in some way or another. You can create a calendar to see incoming shipments, then click on a specific shipment and update its information. You may even create a table of projects with a chat component that allows you to comment directly into specific records.

With a higher degree of customization and interactivity, Jestor lets teams build not only workflows and databases, but custom ways to run processes that go beyond the moving of cards and filling out forms.

Average, but not stellar permissioning powers

There are two types of permissioning in Pipefy: company/member permissions and pipe permissions. 

Company permissions works by assigning roles to members, which range from Administrator (can do everything), to Member (can access all public pipes and has some editing powers in them), and Guest (can only fill forms to feed public pipes, but can’t see into the pipes, not even cards they created).

This kind of one-size-fits-all approach of having predetermined roles is very common in managing software, but can also be a headache when a company scales up and grows into a moderately sized team. It’s very common for companies to need roles that are somewhere in between the predetermined ones, and not being able to do so can cause issues that range from minor headaches to huge monetary costs.

Pipe permissions work by allowing you to assign extra restrictions for specific pipelines on top of the members’ assigned company roles, such as having Read-only permissions.

While pipe permissions allow for a bit more flexibility when defining permissions in your processes, they still keep the previous issue of being premade by Pipefy. This means that there’s little deviation you can take from what’s already there. If it doesn’t fit you operations, there’s little you can do about it.

In Jestor, there are also two kinds of permissions: no-code Roles and low-code Profiles.

Roles are custom permissions in which you assign Jestor-wide powers, such as creating new tables or customizing colors, as well as in-table permissions, such as defining which tables a user will have access to and whether they’ll have full access and powers in it, or a more limited scope. 

If you need even more flexibility, however, you can create custom low-code Profiles in which you can dictate everything a user can see or do inside your account. You want Clients to see only Purchases they have created? You can do that. You want Junior Salespeople to only see clients under $1,000 potential, not be able to see phone numbers but be able see (but not edit) e-mails? Also possible.

Profiles allow you to set any sort of rule or filter you may need for your users, allowing you to finely manage how people use your Jestor–preventing any mistakes that may arise from lack of control.

Non-conventional API on Pipefy

As most other SaaS platforms, Pipefy has an API you can use to integrate or automate processes in ways the standard, native automations and integrations may not be able to. Unlike most SaaS platforms, Pipefy opts for a GraphQL instead of a REST API.

There are advantages to this. GraphQL communication APIs are faster, and require only one query to fetch the information you may need. In contrast to this, REST APIs break the information into many endpoints, and you may sometimes need to make multiple calls to fetch specific data (for example, making a call to get a hotel guest ID, then using this information to get their previous reservations).

What we’re getting at is that GraphQL is an amazing piece of technology, and there are many upsides to using it. However, it’s not entirely without its problems.

The first problem is that most web applications use REST APIs. This alone makes integrating GraphQL APIs harder, as most developers will not be familiar with it and will need to spend some time studying it before being able to take advantage of it. As tech team hours are usually the most expensive hours in most companies, that can make integrating projects costlier than they need to be. This can be an even bigger issue when replacing talent within the company, as acclimating new hires with the schema can bring things to a halt.

The second problem is that introducing a new technology to the ecosystem will necessarily make maintaining the whole thing more complex and burdensome. Developers will need to write more documentation, and may need to create auxiliary structures just to make sure everything else communicates correctly with this one tool.

As you can see, this can be a bit of a hassle. 

Jestor, on the other hand, uses a REST API, which is immediately familiar to most developers or tech-oriented team members. This means that anyone familiar with integrating platforms can most likely hit the ground running. 

Using a more conventional API structure makes for less time spent conquering a learning curve and more time doing things that generate value for the company, as well as less overall complexity in the processes you need to build, both regarding creating these processes and maintaining them.

Jestor has a powerful API that lets you do anything you can do manually in Jestor (including structural actions such as creating tables and fields), and having a standard, familiar way to build your application is a great way to ensure your tech team is being as productive as possible.

Pipefy User based pricing does not encourage growth

Lastly, it’s worth discussing Pipefy’s pricing. It’s a very standard model, with multiple plans that will charge you different rates on a price-per-user basis.

Normally, you wouldn’t bat an eye on this model. After all, it’s how most SaaS companies charge for their services. However, this is not a good model for rapidly growing companies.

As of now, Pipefy’s cheapest plan costs US$22/user/mo. For a small team of 10 people, this means US$220/mo, regardless of how much each user contributes to or uses your Pipefy account. With companies that are scaling up, it’s very common for teams to go from 10 to 100 people lightning fast, with most of them being minor contributors to operations and internal processes. Ultimately, this means your software costs can increase tenfold, without your usage–and therefore the value you derive from the software–increasing at the same pace.

Jestor takes a usage-based approach to pricing. There are two things that define how much a Jestor account will cost you: the features you need and how much you’re using it. This tiered pricing ensures that Jestor’s prices will only increase if you’re actively deriving more value from it. That is: merely growing teamwise will not cost you extra, and as your operations (and revenue) scale up, then software costs follow accordingly.

Usage-based pricing has many other side benefits. For example, not having to worry about costs when adding new users incentivizes companies to add as many users as they need instead of sharing passwords (which is a huge security risk). It also makes it way easier to plan upgrades and budgets, and new hires can be added immediately without the finance team having to purchase new licenses. All-in-all, it makes your operation leaner, faster, and more secure.

To sum things up

As we’ve said, Pipefy is a great platform for process pipelines. As any dedicated tool, having a clear focus lets it excel at certain tasks, even if it has to make some sacrifices that impact using it for more general purposes. 

While it can be a great assistance in establishing workflow versions of spreadsheet-ran operations, or tightly crafted self-contained processes, it can start breaking down as you scale up and find yourself in need of more robust and flexible solutions. With the tendency to create messy data structures, low variety of automations and dashboards, and rigid permissioning system, you may find it better suited using it as an auxiliary tool for smaller teams than as the backbone and center of truth of your company.

If you’re looking for a general purpose, highly flexible, and enterprise-grade platform that can run anything from physical operations to high volume analytics, why don’t you give Jestor a try?