Jestor vs AppSheet: The best alternative to AppSheet 2023
AppSheet is one of those tools that many companies naturally evolve into using. With the prevalence of spreadsheets in offices (and the rise of Google Spreadsheets as an alternative to Microsoft Excel), it is only expected that companies start looking to their complex, often constantly breaking spreadsheets and figuring it out there must be a better way to input and search for data than rows and columns.
This need was only made more important by the increasing usage of smartphones as a work tool. The smaller displays and absence of physical keyboards have only made it harder to keep working with spreadsheets with the same efficiency as before.
The huge appeal of AppSheet then comes with the fact that you can use something that was already being used or very easy to start (spreadsheets), and turn it into a mobile friendly application that is easy to use.
One has to wonder, however: is this enough to transform spreadsheets into real databases, or will they still be a source of pain even in this new format?
We made a Jestor vs AppSheet comparison to show you some key points that will help you decide whether AppSheet is truly the all-in-one tool for you, or whether you should stick with a different solution.
Jestor vs AppSheet comparison summary table
|Pricing||🟡️||✅||– AppSheet: charges per user.|
– Jestor: has both usage-based and user-based pricing, meaning companies can choose the model that best fits their business model.
|Pricing similar plans (15 users 09/27/22)||🔴️||✅||– AppSheet: $150 Core Plan|
– Jestor: $80,00 Builder Plan
|No-code Automations||🟡️||✅||– AppSheet: hard to set up automations, with few possibilities.|
– Jestor: 17 triggers and over 30 actions, with operations/specific automations. More being developed.
|No-code Integrations||🔴️||✅||– AppSheet: no native no-code integrations. |
– Jestor: 18 active integrations, more being developed. It includes Slack, Gmail, Twilio, and more.
|Low-code||🟡️||✅||– AppSheet: no dedicated low code area, but allows for running scripts in automations. |
– Jestor: feature-rich developer area.
|Low-code Apps||🔴️||✅||– AppSheet: no custom pages through native development. |
– Jestor: back-end/front-end customizable pages.
|API||🟡️||✅||– AppSheet: REST API with no structural power. |
– Jestor: REST API.
|Permissioning||🟡️||✅||– AppSheet: formula-based approach to permissioning. |
– Jestor: advanced permissioning with custom business rules.
|Workspaces||🔴️||✅||– AppSheet: no workspaces. |
– Jestor: custom, connected workspaces and bundles.
|Dashboards||🟡️||✅||– AppSheet: hard to setup dashboards with pre-set components. |
– Jestor: apps with 28 different components, ranging from analytical to integrations and operational/interactive.
|History Log||🟢️||✅||– AppSheet: exportable activity log with usage and structural actions. |
– Jestor: exportable history log with usage and structural actions.
|Mobile||🟢️||✅||– AppSheet: simple interface with heavy mobile focus.|
– Jestor: customized experience for each app developed and mobile native navigation without feature loss.
|Forms||🟢️||✅||– AppSheet: customizable form views. |
– Jestor: custom apps and forms with connected data.
|Buttons||🟢️||✅||– AppSheet: customizable buttons that allow for pre-defined actions. |
– Jestor: buttons for navigation, data input, and automations.
|Chat||🔴️||✅||– AppSheet: No dedicated chat feature. |
– Jestor: Slack-esque chat.
|Tasks||🟡️||✅||– AppSheet: records as tasks.|
– Jestor: dedicated, contextual tasks that can be assigned to users, tables and records.
|Data Structure||🔴️||✅||– AppSheet: AppSheet connects to external databases and spreadsheets, which means it cannot enforce correct data structure.|
– Jestor: database that ensures correct data structure and allows powerful automations, allowing for correct n:n auxiliary tables. Single source of truth.
|Real time data||🔴️||✅||– AppSheet: AppSheet has to sync with an external database.|
– Jestor: always updated with the latest information. Everything is real time.
|Performance||🔴️||✅||– AppSheet: complex structures usually rely on performance-draining features such as virtual columns.|
– Jestor: fast and snappy database designed for a smooth user experience.
|Kanbans||🟡️||✅||– AppSheet: kanban views with no drag and drop. |
– Jestor: has customizable kanbans with optimized process oriented features such as conditional fields.
|Views||🟢️||✅||– AppSheet: multiple customized views per table. |
– Jestor: multiple customized views per table.
|Fields||🟢️||✅||– AppSheet: 35 fields, most for basic input. |
– Jestor: 33 fields, with technical fields (such as Query, which runs an SQL query), and even integrated fields (such as Address, which integrates to Google Maps to search for a location).
|Conditional Fields||🟡️||✅||– AppSheet: confusing setup for field conditioning.|
– Jestor: has conditional fields with nested AND/OR conditions.
20 reasons why Jestor is the best alternative to AppSheet
1. Jestor has Conditional Fields
AppSheet has a way to set up conditional fields, albeit a convoluted sort of way. You can set up formulas that define if columns or views will be displayed upon certain conditions. While that works for specific scenarios, it is not user-friendly at all: it often involves using complex conditions and formulas that most non-technical individuals would not be able to pull off on their own.
The reliance on spreadsheet-like formulas to trigger certain behaviors is a common theme of AppSheet, and the absence of dedicated UI for setting up those features can be detrimental to building the apps.
Simply put: it’s kind of hard to do it on your own.
Jestor has a visual, easy to use conditional fields feature that allows you to determine when a field should either:
- Appear or be hidden.
- Be required or optional.
This means that you can set up, for example, a Recruiting structure where an applicant has to provide a diploma only for certain positions, or hide the Social Security Number field when a contractor is a Corporation instead of Individual.
Also, these conditions can be nested and complex, following OR and AND structures up to three levels of rules.
This ensures that not only you’re able to create a list or kanban that holds all the information you need, but that only shows and requires certain data in specific scenarios. And better yet: you can do this with just a few clicks, instead of having to create complex formulas.
In other words, apps are easier to build and easier to use, minimizing mistakes.
2. Native no-code automations
AppSheet allows for automations by using its Behavior and Automation features. It’s easy enough to use: all you have to do is mostly set up the automation trigger (for example, when a row is added) and then select your action (for example, send a notification).
It’s possible to tinker a bit with these options, as well. For example, you may create an automation that runs whenever there’s a change, and then write a formula to judge whether the automation should be activated.
The problem is that there’s not a whole lot else you can do with the standard automations. It is possible to run scripts as one of your actions, which opens up a whole array of options for tech-oriented individuals, but that sort of defeats the purpose of having a no-code platform for simple tasks.
Jestor on the other hand has a wide array of native no-code automations, both generic and specific/niche. You can not only create a Billing record when a Sale is Won, but create monthly installments from that sale, take items sold from inventory, and generate a custom QR Code to direct the customer somewhere else, among other uses.
It’s also possible to string as many actions as you like in one single automation, and even use the result of an action in the next action. This means you can run sequences instead of simple one-offs, like: if a record is created, send a POST call to an external platform and, depending on the result, create another record.
3. Variety of No-code integrations and Webhook
Aside from the connection to spreadsheets and databases AppSheet relies on as data sources, AppSheet has no no-code integrations to other platforms.
Integrations are either done through the API or through its general purpose webhook automation action.
Jestor also has a good number of integrations, and is constantly developing new ones. Not only does it connect with some popular tools such as Slack, Discord, or Google Sheets, it also integrates with communication tools like Twilio and marketing tools such as Mailchimp.
This wide variety of integrated tools paired with the power of its native no-code automations allows Jestor to be at the center of operations, effectively allowing it to be the single source of truth that connects the whole ecosystem together and fully automating any process that a team may need to work on.
4. Apps and dashboards that pull data from anywhere
Dashboards, or analytical features in general, is one of the areas in which AppSheet oddly suffers the most. While the platform has a good deal of different views with a mobile friendly UI, the fact that the dashboard is mainly a combination of these views severely limits its usefulness. It feels more intuitive to just add those views directly to the app instead of using the dashboard, mainly because it’s easier to set them up and edit advanced configurations.
Most notably, the dashboard view detects your data and tries to suggest appropriate views so all you need to do is add the desired options, but it ends up frustratingly hard to do something that isn’t what the platform is recommending.
Aside from the number of building blocks available, two main things differentiate Jestor’s apps the best alternative to AppSheet dashboards:
- Jestor’s apps allow you to pull data from anywhere inside Jestor, not only a specific table or base. This means the finance team can pull information from the sales team’s tables to build their indicators and charts, for example.
- Jestor’s components are not only analytics-inclined. While there are charts and indicators, there are also interactive components such as order generator, forms, dynamic search filters, and even kanban views.
Those two items combined allow for Jestor’s apps to behave less like a simple dashboard attached to a base, and more like central hubs where data can be used as desired, and operational tasks can be performed. For example, you can have a CRM with charts, contact lists, and a kanban view all in the same place, an HR hub to see all information related to an employee, or even a form that automatically subtracts items from stock.
Also, a huge advantage to Jestor’s apps is that components are set up in a more visual way through a very standardized user interface. This means it’s always easy to set up what you need, regardless of where you are in the platform, and the nature of the information you’re looking at.
5. No-code Roles and Low-code Profiles
AppSheet allows you to apply filters based on user information to define whether a user has specific powers in an app.
These settings provide a decent amount of control. For example, you may define that only Admin users can have access to some information, or you could set this filter for users with a specific email address.
Because this uses the same formula approach as other AppSheet features, it is reasonably flexible, as long as you know the proper syntax for what you’re trying to achieve.
The downside, however, comes in two parts:
- Certain access levels that are trivial to set up in other platforms is harder to do here.
- Complex permissioning leads to complex formulas, which can be harder to understand and may break upon certain changes.
In Jestor, there are two better alternatives to AppSheet: no-code Roles and low-code Profiles. They both customize the same access levels, but with varying degrees of possibilities.
Roles let you assign Jestor-wide powers with an easy to use interface, allow you to bestow 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.
Profiles allow you to create more intricate permissioning rules, such as: Junior Salespeople can only see clients with potential under $5,000.00, or leads that they created themselves.
One huge upside of having custom low-code Profiles is that you can create a super intricate access level that follows dynamic rules and filters, then concede this access level to multiple users and still have them see different things based entirely on your specifications. This eliminates manual work and a lot of menu fidgeting that usually comes with other software access level controls.
Also, because this is set up as a JSON file, it’s way easier to understand and set up Jestor profiles than relying on AppSheet’s formulas.
6. Kanbans and Views
AppSheet allows you to create kanban views, just as you would any other view inside the platform. Other examples of views you can create include calendars, cards, and maps. There’s a whole array of different ways to see the data which can prove useful and more intuitive than spreadsheet-like views.
That being said, they feel somewhat limited upon further inspection. For example, kanbans don’t have drag and drop functionality, something that is a given in most other solutions.
As such, some views end up feeling less like productivity tools, and more like reminders or data searching tools.
Jestor allows you to create custom kanban, table, task and record views directly on the tables themselves. It allows you to have as many views as you want to, so you can switch between them to focus on the most important data in any given situation.
A huge advantage Jestor’s kanbans and views have over AppSheet is that they feel more optimized for desktop use, having a lot of the functionalities you would expect from a productivity or business tool, and still keeping those when using the mobile version.
7. Data Structure
Being a tool that you plug into an external database, AppSheet has little power to enforce correct data structure.
Worse yet, most of the times you will be using AppSheet as a front-end application for a spreadsheet, and this implicates in all the problems you would run into when using spreadsheets alone, that is:
- No relational or connected data: AppSheet tries to create connections between tables through Ref columns, but that’s a visual feature. No real connection is done on the database itself.
- Easy to break structures: companies often find that a typo, dragged cell, added column, or wrongful deletion break the spreadsheets intended purpose. By using spreadsheets as a database, you’re keeping these vulnerabilities into your solution.
- Performance issues: spreadsheets are not an efficient way to store data, and companies often run into issues such as slow to open or process files.
In many cases, instead of having dedicated features to connect or filter data, you will need to use complicated formulas to achieve similar results.
Jestor, being a database itself, has none of those problems. Because data is in the platform itself, you have:
- Dedicated features that leverage the power of a relational database.
- Robust and reliant structures.
- Optimized performance.
Because Jestor enforces correct data structure, there’s clarity to every structure. This means the software always “knows” what to expect, allowing for more complex and useful automations.
Organized data also means Jestor can be (and is) used by many companies as a single source of truth.
We encourage companies to take our data structure courses to understand how to better approach database building.
8. Real time data and synchronization
This is one of the areas in which AppSheet suffers the most. As data is not in AppSheet itself, it has to sync up with external sources to update data.
There are basically three standard ways of synchronization:
- Syncing when the app starts up.
- Syncing if it’s the first time the app is opened on a device.
- Delayed synchronization, which means the user has to manually activate synchronization.
- Automatic synchronization, which means information is updated every time the user performs an action on a record.
You can also have automatic updates, in case a different user updates data. But this only runs once every 30 minutes, which means there’s a great amount of time in which a user will have out-of-date information.
It doesn’t take much to see that you can run into severe operational problems with conflicting or delayed information, especially when running processes with more than one team member. For example, one person may take an item from stock, and other users may only see this change thirty minutes later.
Jestor, on the other hand, always has current, synchronized information. As soon as a record is created or updated, this information is readily available for other users, with no other action required.
This means users don’t have to worry about manually syncing their apps, and rest assured that the number they see when opening a record or app is the most recent and correct information, making collaboration and company-wide processes reliable.
9. Better Performance
Because AppSheet is typically using an external database (usually a spreadsheet), you may run into a lot of performance issues that other platforms, which use their own databases, won’t have.
Not only that, because a lot of AppSheet’s features are reliant on formula validations, you may find that a lot of things take longer to process in AppSheet than if they were native features.
For example, it is a common occurrence to use virtual columns in AppSheet. These are fields that don’t really exist in the database, but that will run operations or store virtual data, usually to be used in formulas.
As apps grow, it’s common for the usage of virtual columns to increase. As they are usually more performance-draining than just having the data in the database, performance is impacted.
In Jestor, Jestor itself is the database. This alone allows it to optimize usage and data processing, allowing for better performance.
Aside from that, dedicated features and real data connections make it so it’s not necessary to create a lot of workarounds when designing a process: which means there’s no need for something like a virtual column to fetch or process information.
This more efficient way of organizing data drives up Jestor’s performance, providing a faster and smoother experience for complex applications.
10. Mobile app retains the same functionalities
AppSheet’s main appeal is transforming spreadsheets into easy to use mobile apps. As such, using an AppSheet app on a smartphone is a pleasant experience. Navigation, reading, and updating data is certainly easier than opening a spreadsheet directly into a mobile device’s smaller screen.
While apps can feel somewhat simple, they get the job done. One downside of AppSheet, however, is that to make full use of it you’re going to need to set everything up on your desktop, as building takes place inside the app editor.
In Jestor, the mobile app is the best alternative to AppSheet cause it adapts features for verticality and usability. More important, however, is that the mobile app retains the same functionalities and operations-oriented design of the platform. This means there’s a wide array of things you can do aside from filling and moving records around.
Apart from perfectly mirroring desktop use, bridging the gap between mobile and desktop users, one huge advantage of Jestor is that all the building features you’ll be using to build your solution are also designed for mobile use. This means you can download the app and create everything without needing to hop to a different device.
Building in the mobile app is just as pleasant as the desktop experience.
11. Jestor has native and customizable forms
In AppSheet, form is just another view. It’s easy to add to your app, and will follow conditional rules you have set up for the data.
Jestor’s forms are a component of the apps. This means you can customize it just as you would any other app: apart from the form itself, you can have pictures, embedded videos, charts, and even buttons to open WhatsApp conversations.
The form itself allows you to not only create records in a table/kanban, but create connected data at the same time. For example, if you have a form for New Client, you can also add sections to add as many Contacts as you want, and this information will be created in Jestor already connected correctly.
12. Most familiar and simpler API
AppSheet has a simple REST API, one of the most common technologies used in cloud SaaS platforms. This means that developers are almost guaranteed to understand how the API works and have no trouble developing ways to integrate with AppSheet.
However, AppSheet’s API is fairly limited in scope. You can manipulate records/rows (that is, create/update/delete information), and run certain pre-defined automations, but apart from that, there’s not much else you can do. There’s no structural power involved, meaning you can’t update your app dynamically if the need arises.
Jestor also uses a REST API, which is immediately the best alternative to AppSheet cause it’s familiar to most developers or tech-oriented team members and more robust. This means that anyone familiar with integrating platforms can most likely hit the ground running.
Not only that, but Jestor’s API is full of structural endpoints, which means creating fields, tasks, or even fetching nested structures is possible and fairly easy to do. So whether you’re trying to quickly create a previously designed data scheme or to keep a table’s structure automatically updated, you’re most likely covered in any scenario you may come across.
13. Jestor has Low Code and Developer tools
AppSheet has no dedicated low-code or developer area. The closes you’ll come to it is using scripts in automations, which will let you create low-code scripts to run automations between Google products.
Jestor, on the other hand, has a feature-rich development environment that allows developers or tech-oriented individuals to create complex and unique solutions to their problems.
The development area encompasses:
- Triggers: you can create custom low-code automations called triggers. They’re lines of code that will run whenever the trigger you set up (such as After a record is created in Receivables) is activated. This allows you to create a plethora of complex automations that no-code automations are too generic to do, such as running financial predictions or treating data before sending a POST request.
- There’s a wide variety of native methods that allow you to fetch and manipulate data inside Jestor, as well as specific things such as cURL requests or creating files.
- Pages: you can create fully customizable (back-end and front-end) pages inside Jestor, allowing for custom built interfaces for specific processes. More on that in the Pages section of this comparison.
- Back-end functions: you can create back-end functions that will behave similarly to triggers, but can be invoked in other situations, such as through a webhook or in the middle of a trick.
- Styles/CSS: you can create CSS styles to be easily accessed when creating Pages, facilitating the process of creating customized interfaces.
- Profiles: you can create access levels that follow custom permissioning rules. More on that in the Permissioning section of this comparison.
- Webhook: you can create incoming webhooks that either create records directly into a table or run custom functions from the data you receive, which can be particularly useful to integrate event-heavy platforms, such as PMS’s.
Coming soon to Jestor:
- Python and other languages.
- Better UI and UX, including IDE.
14. Interactive Fields
There are currently about 35 fields (or columns) in AppSheet. Most of them are very basic input fields, such as text or numeric fields, and they don’t really set AppSheet apart from other similar tools.
Because of AppSheet’s nature, this is also only a way to enforce input in the app itself. If you’re using a spreadsheet as a database, it will still retain its “anything goes” nature when it comes to what you can write in a cell.
Jestor currently has 33 fields. As well as direct data input fields, there is a better alternative to AppSheet with more interactive fields (such as Checklists or Buttons), technical fields (such as Query, which runs an SQL query), and even integrated fields (such as Address, which integrates to Google Maps to search for a location) as well.
15. Chat behaves more like Slack
There’s no dedicated chat feature in AppSheet.
Jestor allows you to comment on records and tag other users. However, Jestor operates more like a chat section than a card history. In this manner, Jestor’s chat behaves more like Slack. It’s possible to open a record and see the comments, but also check out Jestor’s chat section and see ongoing conversations, with read and unread messages, and use tables and records as channels.
16. Dedicated Feature for Tasks
AppSheet takes a records-as-things-to-do approach to tasks. The platform encourages the user to create task databases, and to sort through tasks just as it would with any other database, using custom fields. Another way the platform encourages users to manage tasks is through creating to-do lists in pages.
Apart from that, there’s no real task-oriented feature in the platform.
Jestor, on the other hand, has a dedicated feature for task management. Tasks are not the records themselves. Rather, tasks can be assigned to users/groups, as well as to tables or specific records. This means Sale #0352 is not a task by itself, but can have many different tasks attached to it, with varying deadlines and owners. Tasks can be checked by record and table, and users have their own My Tasks section where they can see their pending tasks (with overdue and approaching deadlines given priority).
As with other parts of Jestor, task creation can be automated as well.
17. No-code Buttons
You can create custom buttons in AppSheet by using the Actions inside the Behavior section of the platform. This allows for the user to create buttons that will trigger certain predefined actions, such as opening an edit form, or quickly deleting the record.
Jestor allows you to create three types of buttons:
- Buttons that add connected records (for example, add an Apartment record to the Hotel record you’re currently seeing).
- Buttons that navigate to a link, which can also be used to open pre-filtered apps.
- Buttons that run standard no-code automations, such as send an email, remove an item from stock, or even start a shift on a timesheet (marking the current time).
These buttons can be accessed not only on the tables and kanbans, but in app components as well, allowing users to create a more intuitive experience (for example, a green button that approves a payment request, and a red button that denies the request and sends an email to the requestee).
18. Organized Workspaces and Bundles
There’s no dedicated workspace feature in AppSheet. As the platform’s assumption is that you’re creating a focused app dedicated for specific uses, everything you create in an app is present as an item of the navigation bar.
This can quickly get cumbersome, as indicated in the preview of the screenshot below.
Jestor has a different approach than AppSheet: instead of having singular apps, Jestor is a single source of truth where you can have many different tables, views, and apps at the same time. For this, it allows you to create workspaces, which lets you organize data better.
An app or table can be in more than one workspace at the same time. This means the same database (such as Clients) can be shared between many workspaces. There’s no need to pull the information through blocks or components. Two workspaces can be present in more than one place at the same time.
Jestor is the best alternative to AppSheet cause it also has Bundles, which is like a dedicated app with its own navigation bar, making mobile use and ultra focused operations easier for the end user.
19. Non-local Custom Pages
AppSheet has no low-code custom pages feature.
In Jestor, you can create customized pages by providing the back-end and front-end codes directly into the development area, which is stored and run entirely by Jestor, and effectively allowing you to make a new second-level interface for a specific process or need.
As a lighthearted example, here’s a Flappy Bird-esque game running on a Jestor page (code by w3schools).
20. Hybrid combinations of Pricing Models
AppSheet’s pricing model is user-based. That is, you’ll always pay a monthly fee for the number of active users you have on the platform. As such, users can seriously impact your billing, even if they perform only an action or two daily.
Jestor has pure usage-based plans, as well as user-based plans and hybrid combinations, which is already a better alternative to AppSheet. Big operations can have as many users as they need without paying extra for it, and small scale teams can purchase a few users if it’s more economical for them. This freedom and flexibility ensures that you can always find the plan that makes most sense for your needs.
There are some places in which AppSheet has some advantages over Jestor.
- AppSheet currently has more views, such as gallery and deck views.
- AppSheet allows you to use a pre-existing spreadsheet as a database, without need for importing data.
- AppSheet lets you create standalone apps to install in Android smartphones.
Why Jestor is the best alternative to AppSheet?
AppSheet is a great way to quickly create apps from previously existing spreadsheets. If what you need is to create a standalone app and wish to use Google Spreadsheets as your database, it might be a good solution for you.
However, by focusing more on being a front-end for your spreadsheets than a full, self-contained solution, AppSheet inherits a lot of the problems spreadsheets have.
Not only that, its overreliance on formulas in most of its features make it more difficult for non-technical users to create more complex solutions in the platform. It can also feel like you’re creating a series of workarounds, instead of using true, dedicated no-code features.
There are quite a few ways in which AppSheet may prove not to be the ideal solution for you. Some less than ideal aspects of it may hinder your use:
- Synchronization issues for operations that need real time data.
- Lack of integrations.
- Limited no-code automations.
- No dedicated tasks structure.
- No chat or comments feature.
- No low-code tools.
- Non-scalable data structure.
In Jestor, you have a wide array of features that will not only cover your table needs, but can be used or adapted to any process in your company at any size, from an individual freelancer to thousands of employees. From back office to field ops, you’re covered no matter the problem you’re trying to solve.
Schedule a meeting with our team here to understand why Jestor is the best alternative to AppSheet and why many companies are migrating from AppSheet to Jestor.