A Quarterly Maintenance Checklist for Canvas Apps

Most Canvas (Airdev) apps don't have a maintenance cadence. They have an emergency cadence - things go wrong, someone fixes them, normal life resumes. Then a year passes and the next emergency is the result of debt that nobody noticed accumulating.

The fix is boring but it works: run a quarterly maintenance checklist. Not a deep audit (we have a separate article for that), just a fast review of the things that quietly degrade between quarters.

This is the 15-item list we use with retainer clients at AppSavvy. Allow 3-4 hours per quarter and you'll catch most of what would otherwise become an incident.

How to use this list

Schedule a fixed half-day every quarter. Run through every item. For each one, mark it OK, noted (will track), or action (will fix this quarter).

Whoever does the maintenance reads the previous quarter's notes first. The point is to spot drift over time, not just snapshot the current state.

1. Bubble platform version

Bubble pushes updates regularly. Most don't affect your app; occasionally a change deprecates a feature you're using or fixes a bug you were working around. Read the Bubble release notes since the last quarter's review and note anything that touches your patterns.

2. Canvas framework version

If you're on Canvas v5, you're on a version that can't upgrade. Knowing this consciously - and revisiting it quarterly - is important so the "we should think about v6 soon" decision doesn't accidentally become "we've been on v5 for three years past the right moment."

If you're on v6 or later, check the Canvas What's New page since the last review.

3. Plugin updates and abandonment

For each plugin installed, check its last update date and whether the publisher is still active. Plugins go quiet often.

If a plugin you depend on has been silent for 12 months, either:

• Find a replacement before you have to find one in an emergency, or
• Decide you're maintaining it (which means cloning the plugin source or accepting it as legacy debt)

4. Workload Unit (WU) trend

Open the Bubble billing dashboard and look at the WU consumption trend over the last 90 days. Compare to the trend from the previous review.

A growing WU bill that's growing faster than your user base = either an inefficient workflow or a new pattern that's eating WU faster than expected. Either way, worth investigating before next quarter.

5. Slowest pages

For your top 5 pages by traffic, measure time-to-interactive in an incognito window with throttled "Slow 3G". Compare to the previous quarter.

Any page that's slower than three quarters ago = something has degraded. Usually it's an additional plugin, an inefficient new workflow, or data growth on a search.

6. Slowest searches

Open Bubble's debugger, step-by-step mode, on a few key pages. Note any database query taking more than 500ms. Track the slowest one quarter-over-quarter.

If the same search is consistently slow and the trend is worsening, it's a candidate for refactoring (index, denormalisation, or replacing with a cached structure).

7. Backend workflow queue health

Look at the API workflow queue. Specifically:

• Are there recursive workflows that have been running for more than 24 hours?
• Are scheduled workflows queued for execution that the team has forgotten about?
• Is the queue length growing over time?

A queue that's quietly accumulating is the start of a "we found out the daily digest hasn't fired for two weeks" incident.

8. Privacy rules sample test

Pick 2-3 Data Types that have privacy rules. Open them as a non-admin user via the data API and confirm you can only see what you should be able to see.

This is the cheapest way to catch privacy rules that "stopped working" due to schema changes or rule edits. Once a quarter is enough.

9. Authentication flow walkthrough

Go through the login flow as a regular user, including:

• Password reset
• Email change
• Account deletion (if you support it)
• Single sign-on (if you have it)

Authentication breaks subtly - a third-party integration changes, an email template gets edited, a plugin update changes behaviour. Walking through quarterly catches most of these before users do.

10. Email deliverability check

Send a test email through your transactional pathway (welcome, password reset, notification). Check:

• It arrives in the inbox, not spam
• The "from" address matches what you intend
• The links work and use HTTPS
• The unsubscribe footer (if applicable) is present and functional

Email deliverability degrades silently when DNS records drift, when senders get added to spam lists, or when your sending domain reputation changes.

11. Third-party integration health

For each external integration (Stripe, Mailchimp, the API you depend on most), trigger a known-good flow and confirm it succeeds. APIs change. The vendor's "everything's fine" status page doesn't always know about your specific integration breaking.

12. Bubble version control / version history

Quick check on Bubble's version history: are you regularly saving named versions? Could you revert to a known-good state if today's deployment broke production?

If the answer is "no, we don't really use version history", make a note to start. The cost is zero; the benefit is incident recovery.

13. User-reported issues backlog

Read your support tickets / customer feedback from the past quarter. Look for:

• Recurring complaints (same problem reported by multiple users)
• Performance complaints (a sign of a degradation you missed)
• Auth complaints (a sign of a flow break)
• Data complaints ("I can't see X" or "I see something I shouldn't")

The patterns in the support backlog are often the earliest signal of debt that needs attention.

14. Documentation status

Is your app documented? At minimum:

• A README-style "what does this app do, how is it structured"
• A list of the major Data Types with their purpose
• An authentication and authorisation overview
• A list of integrations and what they do
• A runbook for common incidents

If you can't find these docs in one place, fix that this quarter. The first time you need them is during an emergency or an engineer transition - exactly when there's no time to write them from scratch.

15. Quarterly retrospective: what changed?

Spend 30 minutes writing a quarterly note answering:

• What did we ship in the last 90 days?
• What broke in the last 90 days, and what did we learn?
• What's the biggest risk to this app over the next 90 days?
• What one thing would we tackle this quarter if we could only do one?

The quarterly note becomes the input to next quarter's review. Over a year you build a real picture of the app's trajectory.

What to do with the results

Once you've gone through the checklist:

• All OK or just noted: no action needed. Re-run in 90 days.
• 1-3 action items: schedule them into the coming quarter alongside feature work.
• 4-6 action items: allocate a focused maintenance week before the next major feature push.
• 7+ action items: pause feature work briefly. The debt is going to bite you within the quarter if you don't tackle it.

When to bring in outside help

Some action items are quick fixes anyone can handle. Others - privacy rule restructuring, framework upgrades, performance optimisations on critical pages - need someone who's done them before.

If your team is small and the action list is significant, a one-off engagement to address a specific cluster of items can be more cost-effective than your own team learning to do it from scratch.

What to do next

If you'd like an external review of your Canvas app, request a free Bubble app audit. The report covers the items most relevant to outside-observable health.

If you want a Canvas-experienced engineer to walk through your specific app, book a 30-minute discovery call. We offer maintenance retainers as well as one-off engagements.

Read next: The Canvas tech debt audit and Canvas performance optimisation.