Quick disclosure before you scroll: both tools below run on a real employer's brand assets and business data, so what you're looking at is sanitized. Brand names are Brand A / Brand B, the logo is a placeholder mark, and the address, phone number and contract-number prefix are all fake. The screenshots are real though, actual captures of the sanitized files, not mockups I drew to look convincing. The logic, the numbers, the versions: all of that is exactly what shipped.
So, about this series
I'm the in-house designer for a small retail business with two product lines under different visual identities. Design is my actual job there. Code isn't. But here's the thing I kept noticing: most of what actually slowed the team down wasn't a design problem at all, it was a small, boring, well-defined software problem wearing a design costume.
So I stopped waiting for someone else to fix it and started directing Claude to build single-purpose tools instead. I define the problem, the constraints, and exactly how it should behave. The AI writes the code. I test every single version against how the tool actually gets used in the wild, and I push back hard when it doesn't hold up. That's the whole method, and it's the same method both times below.
Two tools have shipped so far. There will probably be more while I'm still there, which is why this page is built to grow instead of getting rebuilt from scratch every time. Consider this a running log, not a closed case.
Chapter 1: the tool that gave me my Tuesday nights back
Picture the setup: two brands, same company, completely opposite personalities. Brand A is loud and colorful. Brand B is sober and expensive-looking. Both need fresh social posts every single week, and here's what nobody tells you about that job: the creative part was never the hard part. I could design a post in my sleep. The problem was everything around it, the stock check, the ERP sync, the SEO, the five other hats I wear on any given day. A five-slide carousel built by hand in Illustrator had to fight for time against things that were, frankly, on fire. Posts went out late, or they went out fast and wrong.
I looked at the two "obvious" fixes and rejected both. A template tool with team seats charges for the features that matter and, worse, leaves every freedom open that I specifically needed locked shut. A template suggests a default. It doesn't stop anyone from wandering off it. And doing it by hand forever wasn't a plan, it was just me, indefinitely, never sick, never busy, never gone. What I actually needed was our own Canva, with the brand guidelines built into the walls instead of taped to the fridge.
The calls I made, and why
- One file, not an app. Double-click to open, copy to a shared drive, no service that can quietly die on a Tuesday. The trade-off, and I made it on purpose: no autosave, no two people editing at once, and shipping an update means swapping a file. Fine by me.
- A closed palette. No hex field, anywhere. Not being able to leave the brand guidelines isn't a limitation I settled for. It's the entire feature.
- The tool's own interface wears the brand it's building for. Switch to Brand A, the whole UI turns loud and yellow. Switch to Brand B, it goes dark and serif. Seeing the palette while you compose catches the mistake before you make it, not after.
One small detail I'm genuinely proud of: the checkerboard motif you see in the background came from an old Illustrator asset shipping as six full-color files weighing 5.9 MB combined. I dug out the one tile that actually repeats and rebuilt it as a single 28 KB layer that recolors itself for any palette, light or dark. No reason to redraw what already existed.
Nine versions later, here's what actually mattered along the way. Version 1 covered the whole cycle (pick, write, frame, export) before I let myself add variety, because a half-finished tool doesn't get used, it gets abandoned politely. Version 4 added the interior and closing slides and automated the slide counter, because someone (often me) kept typing slide numbers by hand and skipping one. Version 5 caught three brand-consistency slips just by watching the tool get used: a price badge sitting on top of an ornament on one brand, a checkerboard too small to read, a product photo getting its head cropped off. None of these were code problems. Every one of them was a rule that worked for one brand and got applied to both without anyone checking. And version 9, the last one, added a randomizer across 30 contrast-checked color pairings plus a full post generator pulling from 31 pre-written posts. That's the actual answer to the actual problem: a slammed week doesn't produce a perfect post, it produces a rushed one, a random one, or nothing. Now it produces something, every time.
How I know it actually works
Every version runs an automated check across all 38 brand times template combinations: does it render, is any field left empty. The 30 color pairings are all audited against WCAG contrast, so the ones that fail never even get offered. Every pre-written post gets checked against a template that actually exists for its brand. I don't ship on vibes.
Full honesty on that 15-minute number: it's a feel, not a stopwatch reading. I've never timed it properly, because in this role I get interrupted mid-task more often than not, juggling three or four jobs at once. Which, if you think about it, is exactly why this tool needed to exist in the first place.
Chapter 2: teaching a spreadsheet's job to a machine that never gets tired
The store rents out costumes, and every single rental needs a signed contract. That used to mean paper filled out by hand, then later a spreadsheet someone had to edit, calculate, and print fresh for every customer. The pricing itself is sneakier than it looks: the daily rate changes the longer you rent, and the shop is closed two days a week, so "days the costume was out" and "days you actually get charged for" are two different numbers. Every contract ate into selling time, calculator in hand, customer standing right there watching you do math.
A generic rental SaaS was never going to reproduce a legal document the team had already fought to get right, in its exact paper layout, with its exact clauses. What the shop actually needed was the same document it already trusted, with the machine doing the arithmetic and the human still making every real decision: negotiating, agreeing, signing.
The calls I made, and why
- Automate the math, never the decision. The per-day price calculates itself. A discount negotiated with a customer stays behind a collapsed dropdown instead of sitting in a field anyone could nudge by accident.
- The smallest backend I could get away with. The contract counter runs with no server at all by default. Only where several people genuinely needed one unique number on the same day did I add anything, and even then it's not a database, it's a 30-line PHP file with file locking, sitting on hosting the business already pays for.
- Sensitive data handled by simply not digitizing it. When a deposit is guaranteed by card, the printed sheet gets blank lines for the card number, expiry, and security code. No input field, anywhere. The salesperson never types a customer's card details. Only the customer writes them, by hand, on paper, the way it's always been done.
The pricing engine was the trickiest part to get right, and I mean that as a compliment to how deceptively simple it looks: 100% the first day, 50% each day after, except "day" quietly skips the two days the shop is closed. Rent something from Saturday to Tuesday and it bills as a single day, not four. I checked the formula against a real example the team handed me (one item at 30€ a day, two days, 45€ total, the exact numbers in the screenshot above) before I trusted it, not after.
Before every release, I run the entire form headless in a browser-less DOM (Node plus jsdom) and watch what the console actually says. It's saved me more than once, and it's simply part of the process now, not a reaction to anything going wrong.
Where these stop, honestly
- Neither tool saves anything between sessions. That's on purpose: no accounts, nothing to migrate, nothing to quietly corrupt.
- No two people editing the same file at once.
- Both exports lean on an external library loaded from a CDN.
- These tools kill the busywork. They don't replace judgment. Good copy, a fair negotiated discount, a signed contract: still very much a human's job, and I wouldn't want it any other way.
If you made it this far: thanks for reading a case study about a costume shop's Tuesday like it was a heist movie. That's kind of the point. Most of the good design work I do never touches Figma, and I think that's worth saying out loud instead of hiding it below the fold.