App development
Applications in Quickbase are created through configuration, not code. They're represented by metadata and schema. Our platform then interprets and runs this metadata and schema in memory.
Quickbase does not generate or compile code, and there's no build stage for application development. Applications on Quickbase are always live and running. If you've added users to start using the app, it's considered to be in production.
Our platform automatically handles the infrastructure and guardrails for applications. Each application runs with full available resources, meaning builders do not need to provision anything.
While the Quickbase infrastructure autoscales and builders do not need to worry about traditional infrastructure considerations, you can do things to optimize Quickbase applications. See Scaling Quickbase in this guide.
Versioning
Since Quickbase applications are configured, not coded, there's no need to track and control changes made to source code. However, there are multiple options for versioning and rollback.
Application restore services
All customer applications are automatically backed up on a regular basis. If needed, app restore services are available as:
- Data restores
- Table overwrites
- Complete app rollback
These restore services include both data and schema. Most schema changes are reflected in our audit logs.
Solution versioning and rollback
You can also manage versions for your schemas. Most large-scale Quickbase deployments connect several applications and pipelines (automated workflows). Use Quickbase to group applications and pipelines and manage their schema together. This helps ensure consistent state across each component.
We also let you snapshot your schema before deploying a major change and roll back to a previous version whenever you need to. These versions include schema only, giving you more granular control over your applications.
Change management & environments
Sandbox
The Quickbase Sandbox capability is built with business developers in mind. Because of this, it is different from traditional development sandbox environments used by professional software developers.
The sandbox feature is a lightweight change control mechanism. It is a safe development environment separate from, but contained within, the app. App builders can use it to make, test, and review changes before publishing to all users. IT and business developers can work together to set up a change management process using Sandbox that minimizes risk.
A Quickbase best practice is to use Sandbox for business-critical applications that require more control over who makes changes and what changes are made. However, many applications developed with Quickbase do not need separate development environments. These applications benefit from limited friction in the development process. IT administrators can specify which applications must go through the Sandbox change process. Please see this blog post for more information on when you should develop in a sandbox vs production.
Solution APIs
Quickbase also supports grouping related applications and workflows into Solutions.
Our Solution APIs allow you to create environments where you can manage changes of a solution as a single unit to ensure consistent state across related components, all while keeping in compliance with your app development and data governance policies.
QA & testing
Applications continue to run as schema changes are happening. Because of this, built-in platform guardrails can stop builders from making problematic structural changes. This means there is less opportunity for technical issues.
Even with these guardrails, some structural changes might impact application performance. You have the option to have Quickbase optimize poorly structured report filters and searches that may slow your application down. It also includes the following tools to help test and improve your app:
- Performance Analyzer: helps builders analyze application response time, so they can identify problem areas
- Performance Optimizer: identifies, and if you want, applies app changes to improve app performance and scalability
- Performance Insights: finds more complex performance hotspots, so you can make those changes as needed. This feature provides a prioritized list of issues and makes specific suggestions for addressing each one. App builders use these data-informed recommendations, combined with their knowledge of their unique business process, to determine when and how to implement these changes.
Quickbase automatically cascades structural changes made to the app. When names of application elements, like fields and tables, are changed, Quickbase makes the updates in other affected places, like forms, reports, formulas, and references.
Quickbase also provides the following tools to help you understand the impact of changing something like a field name:
- Field usage reports
- Formula syntax checker
- Field dependency diagrams
- Table relationship diagrams
- Search & replace terms in the schema
You can also test the impact of changes to specific roles and users using the Test as User and Test as Role functionalities.
Experienced developers use our API for advanced functional app testing. Our API exposes extensive details about application schema. Developers can use these details to run test cases against an app regularly.
Additionally, our Solution APIs enable you to create test environments where you can develop and test schema changes before deploying them to production.
For workflows built using our Pipelines feature, a live panel displays each step and its results as it completes. This enables easy testing and troubleshooting.
Collaborative development
Quickbase’s single development environment supports all developers and teams. Both business users and IT can work together to build. That's because they're working on the same application creating a common metadata representation of the app.
Professional developers can also collaborate and add value by extending applications. This is done through APIs and custom interfaces.
You can also use our application sandbox or solution APIs to create separate environments for an app – one for development, one for testing, etc. And this gives you great flexibility by doing things like granting some users permission to modify schema in development but not in the live app.
Application security guardrails
Quickbase provides granular, role-based access controls (RBAC) at the account and application level. For a comprehensive view on Quickbase permissions, see our User & Access Management page.
Quickbase provides powerful security guardrails to support application development. Account administrators separately control who is allowed to take the following actions:
- Create new applications
- Modify the schema of an application
- Invite users to an application
Breaking these three abilities out as separate controls allows for flexibility in collaborating to develop an application safely.
These are other security guardrails Quickbase provides. As an administrator, you can:
- Control who is invited to applications by allowing only account administrators to invite new users to your Quickbase account. This helps IT teams control who has access to their account, and it’s also useful for controlling license costs.
- Control which users may clone an application template from the exchange. Or, you can choose to hide the exchange completely.
- For workflows built using our Pipelines feature:
- Control which users are allowed to build pipelines
- Control integration channels that are available to each user. This allows you to disable integrations not approved by IT and creates a barrier if a user has not been trained or given sufficient permissions within a specific system.
- Manage API access to the platform via user token controls
- Specify which apps must go through a Quickbase Sandbox change process to control who can make changes and what changes can be made to critical apps.
- Control whether generative AI features are available at the platform level