Bubble vs Jestor: Build Internal Tools Faster & Cheaper

As business processes rise in complexity, so does the need for better solutions increase. While there are a lot of good off-the-shelf solutions in the market encompassing most of the troubles companies go through, there are many times in which standardized solutions are not going to cut it. Frequently processes grow to be so unique that you need tools that are flexible, and people with deep enough knowledge to solve arising edge problems.

And this is where opportunities arise! There’s a growing market for customized solutions that not only solve a specific problem (like managing deals with a CRM,) but solve them for niche industries/situations (for example, a CRM for photographers.) More often than not, those specific markets may not be large enough for big software companies to step in, but there’s enough demand to let small companies and knowledgeable individuals thrive. By creating their own solutions, they can sell access to their own custom applications and generate a steady stream of revenue.

A common hindrance, however, is having the technical expertise to build an app from scratch. From having enough coding skills to create the app itself to having enough cash to take the chance and invest in infrastructure, building an app the “traditional” way is just not viable most of the time.

This is where no-code/low-code tools come in. No-code platforms allow users to create their own custom apps for a fraction of the cost and time without relying on coding. They come with pre-packaged tools which can be used to transform business expertise into proper software, and later into income.

In this article, we’re going to be comparing two popular no-code tools for designing business-oriented apps: Jestor and Bubble. 

What is Jestor?

Jestor is a no-code platform that empowers companies to build fully customized internal apps for any business need. Whether you want to create a custom CRM, manage projects, streamline support requests, or bring together unique automations, Jestor provides the tools to build exactly what your company needs, without having to write a single line of code.

Unlike traditional no-code platforms that may primarily focus on web applications or customer-facing solutions, Jestor helps you by providing prepackaged tools to manage all kinds of operational processes, bringing enterprise-grade solutions to builders while still keeping ease-of-use.

With advanced automations and dynamic features (such as kanban boards, calendars, dashboards and more), you can assign tasks, connect data across different teams, trigger custom actions, and deeply tailor each workflow to bring your app idea to life. More than just the basics, Jestor provides advanced capabilities like conditional fields and colors, customizable forms, centralized communication, and out-of-the-box templates for quick setup.

From Customer Service to Project Management, HR to Finance, Jestor lets you create powerful solutions to fit every department, making it the ultimate no-code platform for those who want to transform their business knowledge into end-user apps.

Jestor is a competitive choice for those who want more than simple app-building: it's designed for those who understand that business rules and expertise are where the real value of a solution lies, and want the best features to put that into a single package.

What is Bubble?

Bubble is probably the one of most popular no-code tools for building software. With a huge emphasis on designing interfaces and creating packaged apps, it’s a tool designed for those who want to maximize control over every step of the software development process.

This high degree of freedom is achieved by placing focus on an element-based approach to building apps: Bubble is less about having pre-packaged solutions (such as kanban boards or forms) and more about designing the interface first with basic elements (rectangles, input boxes, and so on) and then configuring what each of these elements is going to do.

This approach, however, is not without its problems. While there’s technically no coding necessary for creating an app in Bubble, having to set up specific behavior for every element can require overcoming a steep learning curve (as well as getting tiring as the app’s complexity grows over time.)

While this in no way diminishes the platform’s capabilities, this flexibility/ease-of-use tradeoff is something that one must keep in mind when deciding whether Bubble is the right tool for their endeavor. As you may find from the following topics of comparison, it is something that will permeate your experience with the platform regardless of what you’re trying to build.

Comparison

Let’s suppose you want to build an app for business processes. In this case, which one would work best for you: Jestor or Bubble? We’ve separated this rundown into relevant categories so that you can decide for yourself.

Ease of use: Jestor

Highlights:

• Smoother learning curve.
• Prebuilt components for internal tools common use cases.
• Functional from the get-go.
• Less interface building freedom.

Jestor’s approach to building app is very straightforward: as value in business software is derived more from rules and expertise, Jestor provides prebuilt solutions that one can use to create their own apps with just a few clicks. If a builder needs a kanban board to manage a process or bar charts to visualize data, they’re no more than one click away, and can even be built directly from the Action Bar, which is visible at all times.

Because of this, the time it takes for a user to have a fully functional app is shorter than if one were to design every bit of the platform from scratch. As most of an app’s behavior is often pretty standard (such as a form’s Submit button saving data into a database,) Jestor saves time by having all of this back-end logic baked into the components themselves. However, this does not mean one cannot customize behavior at all. There are plenty of customization options, both functional and aesthetic, that are available in these components. For example, one might choose to redirect someone to a different page after submitting data in a form, or maybe send a copy of the submission info to the user’s e-mail address.

All of this “back-end/front-end” logic is already set up automatically and all the user building the app has to worry about is creating the databases and app pages with the selected components. This way, they can have an app that works in mere minutes, and then spend the rest of their time perfecting the app’s logic (such as automating or creating the best possible arrangement of information) or design (by resizing/reordering components and choosing colors and images.)

That being said, because of this design decision, Jestor will be inherently less flexible than Bubble design-wise. However, for those who are focused on making the most polished MVP possible that can potentially be scaled and used to generate revenue as soon as possible, Jestor becomes a very solid choice as it will look like a professional looking app right out of the gate.

Ease of use: Bubble

Highlights:

• Very steep learning curve.
• Most basic things have to be built from scratch.
• Going from functional to pleasant can take an immense amount of time.
• Bubble’s community can help with onboarding.

When talking about using no-code platforms to build apps, the first thing that will come to mind is: how easy is it to build a fully functional app? For Bubble, this is a complex question, as it will depend a lot on what you’re trying to build. However, no matter how simple the app you’re trying to build is, there will still be a steep learning curve to be conquered. That’s because almost everything in Bubble has to be built from scratch, from interface to behavior. 

For example, let’s say you need something as simple as a form to register new clients. As expected, you will need to design every aspect of the interface: you will need to create a rectangle to be the “body” of the form, and then all the input boxes to receive the information (like name or address). Then, you will need to add another shape for the Submit button. 

Another step is creating the database that will receive the information from the form. In this case, you will need to go to the Data section of the platform and create the Client database, as well as creating every relevant data field to receive the information from the form.

All of this is something you’re probably already expecting. However, those are only the first steps into building the form. The next step is to set up the behavior in the form itself. You see, all of the behavior you expect from a form (clicking on the Submit button, saving the data onto a database, and even cleaning up the input fields afterwards) has to be set up on Bubble. While this provides for a lot of flexibility (after all, a button may do many things), it also makes progress into building things pretty slow: not only because it takes some time to learn, but also because even after you know what you’re doing, it will still take some time to set up the proper configurations for every feature of your application.

And this is only talking about forms, which are pretty basic/straightforward when it comes to usage. If you need more complex things like calendars, kanban boards, or gantt charts, things are going to become increasingly harder to set up. 

That’s because Bubble is not a no-code platform that comes with pre-packaged solutions, but pure building tools. As such, it will give you the tools to build mostly anything you want, but it will not necessarily be easy to assemble features, even ones one would take for granted in process management tools.

And even if you do manage to get a specific feature working, there’s still going to be the fact that getting something to work doesn’t mean it’s going to be pleasant to use. Animations and behavior in general are totally different beasts that will still need to be mastered. 

Bubble does have a way to get around that in the manner of plugins, but we’ll get to that later.

One thing that Bubble has going in its favor, however, is its huge community of users. There are a lot of forum posts and YouTube videos that can guide you on how to create specific things. However, it’s important to understand that even with external help this is still going to be a big undertaking, both in terms of time and effort.

Automations and Integrations: Jestor

Highlights:

• Around 400 automations and integrations native to the platform without having to code.
• Prebuilt integrations with the most commonly used software.
• Low-code features to build custom automations.

Jestor understands that often apps cannot stand purely on their own and need to integrate with different solutions used by clients. For example, a client may want to integrate their Google account so that they send e-mails via their own mailboxes, or maybe they want to upload new leads directly to a Mailchimp maillist. Having this in mind, the platform boasts a lot of different integrations with external platforms, which are powered by its wide array of different native automation tools.

With around 400 ready-to-use automations and integrations, Jestor allows users to combine internal actions (such as creating cards, or doing something when a card reaches a certain stage) with native integrations to popular tools. This means that doing something powerful (like having a user click on a button and generating a PDF from a Google Docs template and sending said document for signing on Docusign) is surprisingly trivial to do in the platform, with users only needing to connect their accounts and setting up the information to be used/retrieved from those external platforms. 

As such, users will not need to veer into technical territory by having to code their own automations or incur additional costs by having to hire freelancers or buy prebuilt plugins. They can tap into Jestor’s library of automations and see which ones work best for them as soon as they create their accounts.

This, however, doesn’t mean that all Jestor offers is prebuilt automations. More advanced users can use Jestor’s low-code area to create custom scripts to run their very own specific automations (with varying degrees of complexity) and set them on specific scenarios, such as when a record is created or when a button is clicked. This allows users to have enough flexibility to cover most use case scenarios, even more niche ones like integrating with less known software or with their own, non-public databases.

However, automating via low-code is just an additional feature, and by no means required. As it is, Jestor provides enough native automations and integrations that more business-oriented individuals can quickly get apps off the ground with plenty of interconnectivity between their most used third-party platforms.

Automations and Integrations: Bubble

Highlights:

• Good amount of automations for internal things (like alerts and log in events.)
• No native, prebuilt integrations with external platforms.
• Some low-code functionality through custom plugins.

Bubble’s approach to automations and integrations is the same approach it takes for any of its apps’ behaviors: workflows. Basically, the idea is that any time you need something to happen (such as sending an e-mail, or automatically creating a record in a database,) you will need to set up its corresponding workflow.

That is a sensible approach, and honestly how you would expect such a feature to work in the platform. It also has a nice way of presenting the information, and users who are familiar with automation tools such as Zapier will probably be familiar with how to set up automations here as well.

With that being said, let’s dive into the extension of the no-code features present in workflows.

As for the internal automations themselves, they are capable enough to cover a good number of cases. While the list of actions is not exactly earth shattering, it does provide enough functionality to cover the most common use cases. For example, if I want to send an e-mail when a new Lead is created, or if I want to create a record in Accounts Receivable when a Deal is closed, I’ll be able to do this easily through the interface.

The issues start to appear when we start talking about integrations. 

As of now, there are currently no native integrations in Bubble’s basic toolkit. This means that, if you want your app to communicate with external platforms, you will be needing to rely on Bubble’s API call action. 

For a good number of use cases, this will be fine. However, it’s important to note that:

1. Not everyone knows how to use APIs, so that’s another technical skill that needs to be conquered before 
2. Some third party applications do have very simple to use APIs, and simple API calls will work fine here. However, as things get more complex, do expect the difficulty of building an app to rise exponentially. For example, setting up an OAuth process for integrating Google Accounts (and then refreshing tokens periodically) will be a barrier too great for some users to surpass.

Another way to bypass the simplicity of Bubble’s native platforms is through the acquisition of custom plugins in their marketplace or through the use of third-party solutions like Zapier. However, while they may provide users with the connections they need, they can also incur in extra costs, which is something one must keep in mind when first building their app.

We would like to point out that Bubble also has low-code features: users may create plugins that run custom code, either on Bubble or by connecting with an external server. This greatly expands Bubble’s capabilities to interact with external platforms. However, this is a solution that is only really feasible for already technical-savvy users, which may defeat the purpose of using a tool like Bubble in the first place.

Business Oriented Solutions: Jestor

• Designed for business processes.
• Most common use cases available in all plans.

As Jestor is a platform designed to build apps focused on solving business problems, it has the advantage of understanding what are the most common problems faced by companies, and then being able to provide the tools that are most commonly used to solve such problems.

For example, many companies like to use custom solutions when it comes to sales, having CRMs that are more adept at managing their sales processes. With that in mind, it’s also common knowledge that most CRMs use kanban views to manage deals in a chronological/stage-by-stage manner. So, as that is a pretty common use case scenario, Jestor comes with prebuilt kanban boards. But, not only that, it also comes with arguably one of the most advanced, flexible kanban boards in the market, with everything from conditional colors and fields to custom buttons and hidden stages.

And that’s just one example of a business oriented tool that Jestor offers in a very powerful manner: Jestor’s forms have a lot of features that you will not commonly find in other similar applications, either in a prebuilt or even in a build-from-scratch manner.

Charts, dashboards, calendars: a lot of features that one would expect to use when building their own custom applications are already baked into the platform for no extra cost. Better yet, most of those are available in the most affordable plans as well. 

Jestor is a platform that will not only make it easy for you to design process management apps, but will make it so your app has access to some of the most powerful features in the market. 

Business Oriented Solutions: Bubble

Highlights:

• Common features have to be built from scratch or downloaded as plugins.
• Plugins for business oriented solutions are often paid.

This area is probably where Bubble is going to perform the worst in this comparison. As Bubble’s focus lies on providing users with a toolkit of extreme flexibility but not with prepackaged solutions, using Bubble to create a custom business-oriented application is going to have a lot of drawbacks because businesses have come to expect fairly advanced features right from the start, taking for granted the amount of work it takes to have them fully functional and easy to use.

To better elucidate the types of features that businesses expect but that Bubble does not provide natively, we can point to:

Kanbans - They are often the backbone of companies, and it’s hard to imagine the most common business processes (CRM, Approval Processes, Recruiting) without relying on kanban boards in some manner. 

Calendars - They are often employed in date-reliant processes (like Payables or Onboarding) and can be used in anything from Finance processes to Marketing.

Gantt Boards - They are often used in Project Management, as they are probably the best way to visualize planning (as well as easily seeing if things are going according to schedule.)

Dashboards - Along with kanban boards, dashboards are ubiquitous as they provide instant insights on the health of the company, as well as being the best way to present relevant data to those who are not present in day-to-day operations.

All of those (and more) are things that are going to be expected as a bare minimum from a business-oriented app, but that are not easily made in Bubble. In fact, some of those are not going to be possible without plugins, either done by yourself (which means coding) or by others (which may mean incurring in extra costs.)

In short, this means some fundamental features are either going to take long to develop or be costly, and sometimes both at the same time if you want to set your app apart.

Cost: Jestor

• Granular usage-based pricing makes costs more transparent.
• Diminished need for upfront investment.

Jestor’s pricing for usage-based plans is pretty straightforward: there’s a flat monthly fee for each builder account based on selected plan (which defines which features are available,) and then usage-based fees based on the consumptions of certain metrics/resources.

As it is, users may see this as a pretty similar model to what Bubble offers. However, there are a few differences to keep in mind.

The most important one is that Jestor’s usage-based fees are broken into more criteria: there’s not a single usage unit that is shared among all resources, but there are different usage metrics based on different parts of the platform being used. For example, no-code automations are charged separately from low-code features, which are also accounted for in a separate metric from AI features.

As such, though it may look more complicated on a first analysis, it also means it is pretty easy to understand what exactly an account is consuming. For example, a builder may estimate exactly how many no-code automations they are going to use in a month, and it then becomes clear how much they are going to spend in that regard. 

Another very important thing to note is that Jestor does not count log-ins and general access to the app itself as one of its usage-based metrics. This means that the mere act of having clients log into your app will not incur additional costs, which is great as that is one of the trickiest things to estimate.

Finally, as Jestor has a lot of native automations and integrations, as well as prebuilt components, it doesn’t rely on the acquisition of plugins for specific features and lessens the need for third-party integrating platforms such as Zapier or Make. This means that the points mentioned above are most of the time all you need to invest into Jestor to have a fully functioning app.

Cost: Bubble

Highlights:

• Workload caps of its plans makes initial price estimation tricky.
• Plugins can scale upfront and recurring costs.

Bubble’s pricing is based on a combination of a flat fee plus usage-based pricing. This means Bubble will charge users based on the plan (which comes with a set of features and usage caps) and an additional fee based on how much the app is exceeding its standard usage caps.

As it is, it looks pretty promising for new users: the plans are reasonably priced (the most basic paid tier being only $29/mo when billed yearly, and the recommended plan being $119/mo.) 

Some of the usage-based fees are also pretty straightforward: for example, each app has a storage limit (like a cloud storage solution,) and users are charged on exceeding storage. 

One of the main issues here is that the main usage-based fee comes in the manner of workload units: a unit designed to measure how much processing Bubble has done on your app’s behalf. The problem here is lack of specificity: workload units can cover anything from workflows to users accessing your app. As such, it can be very difficult to gauge exactly how much an app is going to cost or scale as time goes on. 

Another issue here is Bubble’s reliance on plugins. 

As we’ve said before, Bubble doesn’t come with a lot of end-user features prebuilt right out-of-the-box. The user is expected to set up every feature from scratch, from designing the interface to setting up behavior. However, there is a plugin store where users can handily download prebuilt features that other users have submitted, such as calendars or forms. Such plugins can either be free or paid, with varying quality.

This is how Bubble’s ecosystem thrives: there are a lot of more technically inclined users who can code features and upload to the store to earn income, and other users may then use such solutions to better their own apps. 

As you can probably imagine by now, the problem here is that a lot of features that are commonly used on process management solutions are paid. Gantt charts, kanban, calendar views: lots of features people expect from a functional app are not part of Bubble’s standard toolkits, but things you have to code yourself or buy from third party developers.

As a result, you may end up with a steep upfront cost to build a prototype (if the plugins are charged as one-time upfront fees) or you may end up with an app that is costlier than expected to maintain on a month-by-month basis (if they are charged as recurring fees.)

It’s also important to point out that here you’re not buying a solution from Bubble itself, so there’s no guarantee that it’s going to be properly maintained further down the line. If a plugin you were using stops working, you may need to acquire a separate one, incurring in more costs.

Finally, keep in mind that Bubble’s nature of needing to set up a lot of custom interfaces and workflows means you will spend a lot of time before having a functional app.

With all of this considered, it may be hard to estimate how much an app is going to cost you, or even how much you will need to invest in order to have a functional MVP (minimum viable product.)

Fields and Data: Jestor

• 50+ types of fields.
• Fields can be for data entry or with dynamic features.
• True connected data.

As a platform that is designed with ease of use and specific functionalities in mind, Jestor has a very optimized-for-use focus when it comes to databases.This means not only does the platform has a very efficient way of structuring data for scalable processes, but also that it has a very wide array of different prebuilt data fields covering a lot of different scenarios, from common to niche.

For example, as of the writing of this comparison, Jestor allows users to create more than 50 types of different data fields in its databases. The data fields that can be created right from the interface range from standard, expected types of information (such as numbers, dropdown lists, text and so on) to specialized fields such as signatures or YES/NO checklists. This means that, with just a few clicks, users can create data fields that are features unto themselves, from how they work to how they look.

Not only that, but fields in Jestor are not only relegated to storing data. There are also dynamic fields such as formulas (which allow users to create custom SLAs depending on ticket parameters, for example) or goals (which allows users to see a progress bar dictating how much time they have to solve the ticket or how far along it currently is toward completion.) Users may even use Timer fields to track how much time they spent on a specific task of the ticket, which can be useful when something requested is billable by the hour. 

On a final note, Jestor’s quality as a relational database with true connected information means connected data is not only possible, but useful. These connections are not only links to other records (such as selecting specific clients from a Client database,) but also usable information when automating processes. So, if you have a connected Client to a Project, you may automate an e-mail to be sent to the client’s e-mail address without having to fetch that information manually or replicating that data to the project itself.

Fields and Data: Bubble

Highlights:

• Only 11 types of fields (with numbers and dates taking up about half of that list.)
• More advanced data fields need to be built on top of the basic fields.
• Connected data, but harder to use information.

Bubble allows for users to create 10 different types of static fields plus a connection field. Those are the data fields that you’re going to use when saving and editing information from your app (such as, for example, saving data from a form submission.)

The standard data fields are somewhat basic, but get the job done: you have a text data type, a numeric one, dates and date ranges, binary 1/0, and so on. 

The thing is, if you need anything more advanced than that, you’re going to need to build your own custom input in the interface builder, and then create the logic communicating the information from the interface to a compatible data field.

For example: suppose you need to mark something as Favorite, and you want to do this by clicking on a star icon. In that case, you will need to create the star icon in the interface, and create a workflow such that the star icon changes in color when it is clicked, as well as saves the value “1” in a binary field. While this does not sound complicated, it is still a good amount of work to get a pretty basic new field going. And, the more complex a new field is, the more work/difficulty in building it.

Another issue is that while Bubble does allow for connections between databases (such as letting you connect a Supplier to a Payable,) it does not automatically pull information from connections for data viewing or automating: this means that using connected information (such as Supplier’s email) also demands a certain amount of effort and technical expertise.

Access levels and Permissions: Jestor

Highlights:

• Easy to set up customizable permissions.
• Enterprise-grade, granular access levels through Advanced Permissioning.

Jestor, as a business oriented platform, already has permissioning tools built in not only from an app building perspective, but also from an end-user perspective. Builders can quickly create granular access levels that will limit what users can see and do within their apps.

It does that by setting permissioning around two things: Seats and Roles. A Seat is a system-wide permission that defines the user type: Builder, Member, or Viewer. While builders can customize the platform, Members (the most common type of user) can only use what’s been built, and Viewers can access and view but not interact/edit data in the app.

After a seat has been defined, users must also be set into Roles, which are basically the custom set of filters and rules imposed on said users. As an example, you may define the Role of an HR Analyst and make it so they cannot delete employees, or make it so they cannot see employee’s social security numbers. Basically, this makes it so that most data filtering rules are possible to be quickly set up with Roles. 

Not only is this Enterprise-grade level of permissioning not something that you would usually find in no-code app builders, but it’s also baked into the platform itself. This means users only need to learn how it works to get things started, which is much, much faster than building their own custom permissioning tools from scratch.

Access levels and Permissions: Bubble

Highlights:

• High versatility for creating Roles.
• Role functionality must be created from scratch.

As it is becoming a theme of this comparison, data permissioning is also something that must be created from scratch in Bubble. While there are some permissioning options for app editors (such as allowing/not-allowing a specific builder to edit registered data,) anything regarding end-user themselves has to be set up from scratch.

For example, if you want to create User Roles (like Finance Analyst, or Marketing Manager), you will need to create an object for such roles and data fields that flag which parts of your app they should have access to. Then, you need to go to each part of your app and set up how data or features behave based on the Role assigned to a user.

While this means that there is a lot of versatility in how you can set up permissions, this also means that it takes a lot of work to get a fully-fledged permissioning system going, no matter how simple it is. Even for something as simple as checking to see if a user’s role has access to Payables, for example, will take a lot of menu hopping.

If you need something even more complex than data filtering (such as access to specific, custom built features of your app,) then this setup is also going to be even more complex and time-consuming.

While in no way this means Bubble is bad when it comes to permissioning (in fact, it’s one of the most adaptable tools out there,) it does mean that one of the most critical parts of app-building (determining who can have access to what and when) is also going to be one of the less straightforward and most complicated things be set up, and one that users will have to take the most time to get right and avoid errors.

Flexibility: Jestor

Highlights:

• Less flexible when it comes to interfaces.
• Still a lot of customization to be made while keeping the design level of a final product.
• Easier to get a cohesive app going.

As we’ve mentioned before, Jestor approaches app building from a different philosophy than Bubble. While Bubble focuses on creating interfaces and setting up all the back-end workflows and internal logic from scratch, Jestor focuses on providing prebuilt components and features that are common to business oriented apps so that building apps is fast and easy.

Because of this, Jestor is not as flexible as Bubble when it comes to designing interfaces. While Bubble provides enough flexibility that apps can be designed in such a way that any element (buttons, forms, etc) are in any shape imaginable, Jestor provides prebuilt pieces that already have their own predetermined design, while still letting users customize these components within certain parameters.

Even so, Jestor still provides a lot of flexibility when it comes to design and how the app will work. That’s because while it does only provide prebuilt components, it has a large variety of those. As such, even navigation is customizable, with top, bottom, and side menus all included as selectable pieces when building an app.

This positive side to this app building philosophy is that not only are apps quicker to build, they are also cohesive by default. Every element is designed to work well with each other, which means that users can focus on building functionality while being assured that the end product will look good once everything is assembled. This means that apps will look more professional with less effort involved, while builders can still have their own identity engraved in the app with certain customization settings, such as by providing custom logos and colors. 

Flexibility: Bubble

Highlights:

• Totally customizable interfaces with element/shape drawing.
• Harder to set up, but overall more flexible.

When it comes to flexibility, this is an area where Bubble really shines. Because Bubble’s approach to building apps is letting users draw elements/shapes and assign behavior to them, this means that every little detail from the interface can be exactly how a user wants it. 

To put it in better words, because there is no “form” prebuilt component for building forms, a form’s appearance is not bound by predefined standards. While in most tools you will have a standard form with some customization options (such as colors and company logo,) in Bubble you can draw whatever shape you want and then create a form submission behavior in it. As such, nothing prevents a user from creating a star-shaped form, for example.

However, this flexibility does not come without drawbacks. As features must be done from scratch, this means that everything (from navigation to inputs) must all be set up independently, which means that as apps grow in size, they will grow even faster in complexity, as you will need to adjust every page and feature that interacts with new parts to be adjusted as well.

Continuous Upgrades: Jestor

• The platform constantly rolls-out end-user updates.
• Your app increases in value delivered to the end-user automatically.

Jestor is a platform that not only provides you the tools for building apps, but also actively takes part of the end-user experience. What we mean by that is that a Jestor-built app will always have certain features built into by default. For example, every Jestor app comes with task management and internal communication features.

Those are features that would not be easily built by the builders, but are things that are often valued by companies and teams when deciding on whether an app is good enough for them. So, Jestor provides this to all accounts as standard features that are independent (but can be attached to) the apps that the builders develop. 

In practice, this means that, as Jestor continuously develops user-centric features and upgrades, apps previously built automatically receive updates, enhancing user experience. For example, when the Chat feature got the audio and AI transcription enhancements, all apps got those enhancements without having to set up new configurations or fiddling with the app structure.

This is the way Jestor found to make apps increase in value over time automatically, so that builders could focus on new apps or processes while still providing a sense of continuous development to their own users.

Continuous Upgrades: Bubble

Highlights:

• The platform itself gets new features and plugins from the community.
• Your app does not necessarily get better with updates.

Bubble operates in a separated app and platform logic. Bubble itself is one thing, the app you’re building is a different thing that must be deployed. As such, this means that any upgrade that Bubble itself receives does not necessarily reflect as an upgrade on your app to your end-users.

That’s because Bubble’s inherent upgrades are regarding its building toolkit, and there’s no inherent Bubble feature that is available to people using your app. As we’ve established before, any feature of your app must be set up and designed by you. So, while Bubble’s upgrades may expand the number of things you can build, you users will not have access to them until… well, you build them. 

This is an important point because not every no-code platform operates on the same logic employed by Bubble. For example, some no-code tools do offer prebuilt features, such as internal communication functionalities or task management areas. Not only are those features provided to every app (which means every new feature is readily available for every user,) but this also means that upgrades/enhancements to those features are automatically deployed to every one. So, if the platform’s task management section gets new features, your app immediately gets enhanced as well.

While it’s important to note that this is not necessarily the best setup for everyone (some companies/individuals do, in fact, prefer their apps to be “frozen” until they modify it,) there are those who prefer for their app to be automatically upgraded as soon as new features roll-out, without extra cost or effort necessary.

Which works best for you?

As a lot of things go, it entirely depends on your needs.

With Bubble, you have an extremely flexible tool that allows you to design the interface exactly the way you want. This means users that manage to master it and dedicate enough time to it can end up creating apps just the way they envisioned, at least from an interface/design perspective. However, this extreme flexibility comes with the clear drawback of demanding a lot of effort not only for the initial implementation but also for maintaining and expanding the app’s features in the future.

Jestor, on the other hand, is fast to build and easier to maintain. Most commonly-used features that are expected by companies (like kanban boards, charts, forms) are already prebuilt and can be deployed with a single click, while still allowing for a good degree of customization. While not as interface-flexible as Bubble, it makes up for it by allowing processes to be built in mere minutes as a lot of the platform’s behavior is already prebuilt, which means builders can optimize their time by focusing on providing value through formalizing business knowledge and not necessarily through tech set up. Not only that, but as a hybrid between app building platform and end-user interface, Jestor will also roll-out upgrades/enhancements automatically, making preexisting apps increase in value over time.

If what you envision is an app with a very specific look and being able to change every detail of the interface, Bubble may be the best tool for you. If, however, where you can bring the most value is through business knowledge and want to leverage it to create an app fast while still providing your own solution to your clients, then perhaps give Jestor a go.