I Just Automated My Way to a Personal Day: Here's the Zapier + BQE Core Magic That Did It

How I cracked BQE Core's beta Zapier integration (and the workaround that saved everything)

Warning: This is a highly technical post. If you're a BQE Core user, it's a must-read. If you know a BQE user, send this to them. If you don't use these products, you may want to glance through and note some questions to ask your time and billing software vendor.

Last week, I showed you how I automated project number generation and got pretty excited about using those numbers for three BQE Core purposes: creating clients, creating projects, and creating retainer invoices.

This week, I want to walk you through exactly how I did that—and the beta integration workaround that made it all possible.

The Vision: Complete Client Setup Automation

Picture this: A project moves to "Owner Architect Contract" status in our Dubsado CRM system. With Zapier as my bridge, automatically, BQE Core creates the client record, sets up their project using automated project numbers, and generates a retainer invoice ready to send.

For how I set up reliable automated project numbers see last week’s Substack post.

That's not a someday goal—that's what's running in our office right now.

When BQE's Zapier integration moved into beta this summer, I knew this was my chance to build something that would save us the 45 minutes we spend on every new client setup.

The first build was elegant in theory: one smooth automation that handled everything in sequence. My mental blueprint was going to be Status Change Trigger → grab project number → set up client → set up project → set up retainer invoice. Easy peasy lemon squeezy.

Between creating the BQE Core client and the BQE Core project is where the dream faded. To set up the project, I needed to link it to a BQE Core client .

Here’s the step that required a workaround. To set up a project, I need the Client ID. The Client ID - that long UUID string - should have worked perfectly but, alas, did not.

The Communication Breakdown

Zapier was happily texting BQE Core with the UUID data, while BQE Core was basically responding "New phone, who dis?"

Zapier was happily texting BQE Core with the UUID data, while BQE Core was basically responding 'New phone, who dis?”

So I started trouble shooting. Here’s what didn’t work:

Passing the UUID straight from the previous step - BQE kept treating it like a wrapped object instead of plain text

Using human-readable fields instead - BQE requires the true UUID, not display names

Adding a Find step to re-hydrate the data - Still inconsistent UUID formatting issues

Adding delays thinking it was a timing problem - Helpful for race conditions but didn't fix the core issue

Then I hand-typed the UUID directly, and it worked perfectly. That's when I knew: this wasn't a logic problem, it was a translation problem.

Here's what was happening: Zapier was sending the UUID wrapped in JSON formatting like {id: 12345}, but BQE Core expected plain text like just 12345.

The classic API miscommunication: Zapier enthusiastically packages data in JSON format while BQE Core just wants a simple, clean UUID.

Let me pause here because I had to look these up too. A UUID (Universally Unique Identifier) is just a really long string of numbers and letters that serves as a unique ID for each record—think of it like a social security number for your client or project. JSON is how computer systems package data to send it around—imagine wrapping a gift in multiple boxes when all you needed was to hand someone the gift directly.

You don't need to understand the technical details to use this workaround. I barely understand them myself, and it works perfectly.

The solution was making Zapier Tables the helpful intermediary—taking Zapier's complex message and presenting it to BQE Core as clean, simple text. Instead of garbled digital messaging, someone simply walks over and hands BQE Core exactly what it needs on a clean piece of paper.

The workaround that saved everything: Zapier Tables became the helpful intermediary, handing BQE Core exactly what it needed in a way it could receive it.

The Simple Solution

This is what keeps me excited. That table I used last week to keep old project numbers stable when I created new ones? I thought to myself, "Maybe I just add another column there for the UUID, use that table column to hand the message to BQE Core."

Instead of complex digital messaging, what if someone simply walked over and handed BQE Core a clean piece of paper with exactly what it needed? No formatting confusion, no translation errors—just clear, simple information.

And it worked! Hallelujah!

Zapier Tables became that helpful intermediary, taking Zapier's complex message and presenting it to BQE Core in the plainest possible terms. BQE Core finally gets exactly what it expects, every single time.

How I Set Up the Complete Automation

The Prerequisites: You need automated project numbering first. This entire workflow depends on reliable project numbers. If you don't have that yet, see last week's post and build that foundation first.

The 15-Step Process That Actually Works:

1. Dubsado Status Change → Triggers when project reaches "Owner Architect Contract"

2. Status Filter → Only proceeds for the right project status

3. 30-Second Delay → Critical pause for project number assignment

4. Format Last Name → ALL CAPS to match with our table structure

5. Connect to Project Number Table → Access last week's numbering system

6. Get Client Record from Table → Retrieve project data

7. Find Client in BQE Core → Search existing clients and capture UUID

8. Store Client UUID in Tables → The workaround that makes everything possible

9. Create Project in BQE Core → Uses stored UUID for proper linkage

10. Store Project UUID in Tables → Sets up invoice creation using the same workaround

11. Create Retainer Invoice → Uses both stored UUIDs

12. Send Basecamp To-Do → Notifies team to email invoice

13. Date Formatter → Timestamps for logging

14. Update Notion Tracker → Records automation metrics

15. Webhook Logging → Backup tracking

The Key Workarounds That Make It All Work

UUID Storage Strategy: Steps 8 and 10 are the magic. I need the client UUID to create the project, then I need the project UUID to create the invoice. Both times, I store these in Zapier Tables as plain text, which strips away Zapier's JSON formatting.

Timing Is Everything: That 30-second delay in step 3 isn't optional. BQE Core needs processing time between operations. Beta software, beta timing requirements.

Invoice Creation Reality Check: No matter how clean my mapping looked, test runs always failed. Zapier threw errors that didn't match reality. I finally realized: sometimes the live zap works even when the test doesn't. I had to publish it and run it with live data before I got my first real success.

The most cryptic error? "Cannot read properties of undefined (reading 'split')" actually just means "You forgot a line item." That error message tells you nothing useful, but now you know.

Small Details That Save Sanity:

• The "Duplicate Project" error message is harmless when you're testing with the same data twice—safe to ignore

• The Client field is optional on invoices since BQE ties it back through the project anyway

• Delays helped stabilize the overall workflow but didn't fix the UUID formatting issue

The Learning Compounds: When I hit the UUID problem this week, the solution was already in my mind from last week's table work. Nothing's wasted. Nothing's wasted. Nothing's wasted.

The Results

Time savings: 45 minutes becomes 2 minutes per new client.

Consistency: Every client gets identical setup with no missed fields.

Scalability: Uses the same Zapier Tables foundation from last week—no additional tools needed.

The personal day I just earned: At 15 new clients per year, that's 10.75 hours I'm getting back—a full personal day, plus change. That's my Labor Day weekend, extended by automation.

What would you do with an extra day off that you actually earned instead of borrowed?

My Suggestion for BQE

If you're with BQE Core and reading this, here's my suggestion for the next iteration: make the Zapier integration handle UUIDs in JSON payloads natively. Right now, BQE Core expects plain text UUIDs, but Zapier often wraps them in JSON formatting. The workaround works perfectly, but native JSON payload support would eliminate the need for intermediate storage and make the integration seamless.

In the meantime, if you're one of the 50,000 BQE Core users, here's the workaround: Zapier Tables. You get up to five tables with your under-$20 monthly account, and it's well worth it. I didn't even need a new table—just added two columns to last week's project number table.

The Zapier Tables Value Proposition

This is a perfect example of how learning compounds. Last week's table solution became this week's breakthrough. When you invest in understanding one piece of automation infrastructure, it pays dividends across multiple projects.

The Bottom Line

Beta software comes with learning curves, but early adopters get the efficiency gains while everyone else figures it out later. This automation is running reliably in our office right now, built on the foundation of last week's project numbering system.

Get this up and running now and lead the pack, or watch from the back while everyone else enjoys the efficiency gains.

Elizabeth Harris is the Director of Professional Polish at Kevin Harris Architect and believes that boring systems enable exciting possibilities. When not coordinating bowling shirts for AIA Baton Rouge bowling afternoon, she handles payroll, professional liability insurance while ensuring Kevin looks as good as he drafts. Subscribe for more insights on building systems that work even if you are a boomer.

All illustrations created with ChatGPT Model 5.

---

For Subscribers: The Complete Implementation Guide

Ready to build this exact automation? Below the paywall, I'm sharing the field-by-field setup, screenshot walkthroughs, and troubleshooting guide that turns this explanation into your working system.