If We Don't Use It, It'll Be Blank
One of my favorite pieces of client feedback this week was one sentence long, and it asked us to take something out.
We've been building a planning app for an event management agency. A few sections of each event, like AV and food and beverage, had small on/off toggles. The idea was that if an event didn't need AV, you'd switch that section off and it would disappear.
The owner sent over a quick screen recording. Her take: get rid of the toggles. Just show those tabs at the top all the time. If an event doesn't use one, it'll just be blank.
She was right, and I love getting that kind of note. Every toggle is a small decision you're asking someone to make, every time, on every record. In this case the payoff for that decision was close to nothing. An empty tab doesn't hurt anyone. It just sits there and tells the truth: nothing here yet.
When we design custom apps, there's a pull toward adding controls. A setting feels like flexibility. But for a small team running real operations, flexibility you have to manage is often just more work. Blank is fine. Blank is honest.
If you're working with a developer or evaluating software right now, it's worth asking about every on/off switch you see: who flips this, how often, and what happens if it's just always on? You'll be surprised how many of them exist because someone imagined a problem that never shows up in real life.
On to this week's newsletter.
1. Renewals that only change two things
Most of our week went into an operations app for a scaffolding and equipment rental company. A big chunk of their work is permits, and permits renew on a cycle.
Before you automate anything, it's worth asking a plain question: what actually changes from one renewal to the next? We walked through it with their team. The answer was two things: the customer's cycle and the permit fee. Everything else carries over.
The fee has some logic to it. Permits inside the downtown business district cost double what they cost outside it, and there are different permit types on both sides of that line. So the real work is getting the fee table right once, and then letting the renewal run.
That's a pattern I look for with every client. When a recurring task only changes in one or two predictable ways, it's usually ready to automate. When it changes in ten different ways depending on who's handling it, you've got a process conversation to have first.
2. A Reinstate button instead of a Delete button
We also redesigned how contracts get cancelled in that same app. It sounds small, but it's the kind of thing that quietly causes a lot of problems.
There was a Delete button in places where nobody should really delete anything. A contract that's live and installed in the field shouldn't vanish because someone clicked the wrong thing. And when a cancelled contract came back to life (it happens, clients change their minds), there wasn't a clean way to bring it back.
Here's where we landed:
- Active contracts: no Delete button at all.
- Pending contracts: Delete becomes Cancel, which marks the contract as cancelled instead of removing it.
- Historical contracts: no Delete either, but cancelled ones get a Reinstate button that moves them back to Pending.
We went back and forth on the label. Reactivate, Un-cancel and Reinstate were all on the table. We picked Reinstate because it says exactly what happens, and it reads clearly to someone in the office who isn't thinking about software at all.
My general rule: in an operations app, almost nothing should be truly deleted. Make it easy to undo, and keep the history.
3. A pipeline you can read at a glance
Contracts in that app now sit in four tabs: Active, Closing, Historical and Canceled. Closing is the new one. It holds contracts that have expired but haven't been fully billed yet, so they don't drop out of view before the money side is wrapped up.
We also built past-due notices that pull a statement for each contract, so the team can see exactly where an account stands without rebuilding the picture in a spreadsheet.
The goal is simple. The people running the business should be able to open one screen and know what's happening. If they have to export, filter and pivot to answer "what's still open," the app isn't done yet.
A good test for any dashboard or list view: can someone new to the team look at it for ten seconds and tell you what needs attention today? If not, the screen is showing data, not answers.
4. One-page contracts that stretch when they need to
The client asked for their contract PDFs to fit on a single page. When a contract spills onto a second page, the cost breakdown gets split up and it's harder to see everything at once.
We're building the layout to fit standard jobs onto one page with tighter spacing, and to grow to a second page only when the scope of work is long. Legal-size paper is our fallback. It's a small change, but it's the document their customers actually hold in their hands, so it matters.
5. Edge cases, one at a time
Here's a fun one. A line item described a piece of equipment by its measurements, something like 7' 2", with the apostrophe for feet. That was the first time that format had come through invoice creation, and it tripped it up. We fixed it live, during the call, and pushed the update before we hung up.
People sometimes ask why we don't try to catch every possible weird input up front. My answer is that you can't predict them all, and trying to usually means building a lot of code for problems that never show up. I'd rather handle the real edge cases one by one as they appear. Each week the system gets a little quieter, and every fix is one that actually mattered to someone.
How-to: give every recurring task one home
This one came straight out of a client conversation this week, and it applies to almost every small business using more than one tool.
In the rental app, renewals advance a cycle number. If a renewal is created inside the app, the app knows the contract moved to the next cycle. If someone creates that same invoice directly in the accounting system instead, the invoice shows up, but the app never learns the cycle moved. The next renewal in the app can then bill the same cycle again.
Nobody did anything wrong there. Two tools were both allowed to do the same job, and they didn't agree.
Here's how to check your own setup today:
- List your 3 to 5 most common recurring tasks. Think renewals, invoices, reminders, onboarding steps.
- Next to each one, write the single tool where that task is supposed to happen.
- If the answer is "it depends" or "either one," that's your next thing to fix. Pick one home, and have the other tool read from it instead of doing the job itself.
It takes about 15 minutes, and it'll save you from the kind of mismatch that only shows up at billing time.
One question for you
That's it for this week. What's one setting, toggle or field in your tools that nobody on your team actually uses? Hit reply and tell me. I read every one.
And if you'd like to talk through simplifying one of your own workflows, grab 30 minutes with me here: calendly.com/patrick-univium/30min
Talk soon,
Patrick