Case Study

Building Gazette-Search: A Founder’s Build Log

My build log for Gazette-Search: the five-minute bar, the move from Lovable to Claude, the data crisis I found, the customer-ethics call I’m proudest of, and who’s using it now.

By
Russel Shalom Davis
·
July 5, 2026
·
22 min read
Building Gazette-Search: A Founder’s Build Log
Key takeaways
  • A collections insider set five minutes per search as the bar, after a pre-AI small team had failed to reach it; working alone with Claude, I built Gazette-Search to return matches in seconds.
  • A dashboard that said 0.3% gazette coverage was measuring the wrong thing, so write down what every dashboard metric actually measures before you need to trust it in a crisis.
  • When a product is defective, absorb the cost of the fix yourself: I gave 507 affected searches a free retroactive watchlist instead of sending one bulk apology email.
  • Credit packs plus an Enterprise tier fit a market where a lawyer runs three searches a year and a BPO runs hundreds of thousands a month, which no single subscription tier could serve.
  • South Africa's POPIA requires breach notification as soon as reasonably possible, and writing the breach runbook before any incident was the right call.
  • The most expensive bugs in a B2B product live at the seams between systems nobody owns, such as platform scratch space meeting a growing database or a PDF parser meeting scanned pages.

An associate of mine in the collections space had been watching me work on a concept. I showed him the prototype one afternoon, with the kind of energy you only have for the first SaaS you've ever built. His response, paraphrased close to verbatim:

"Unless you can get search results in under 5 minutes, my industry isn't interested. We've already tried to build something like this, with a developer, before AI, and it was a mess."

That's the inciting incident for this whole project. Not a market research deck. Not a competitive analysis. One industry insider, sitting across the table, setting a clear bar and quietly letting me know what had already failed.

It's also why this build log is worth your time if you run a collections agency, a BPO or a financial-services team in South Africa. The bar was five minutes. Searches now come back in seconds. And the story of how a one-person shop got from "interesting demo" to "30-year-old credit management firm on a three-month professional contract" runs through every interesting infrastructure problem a B2B SaaS can have.

What is Gazette-Search?

Gazette-Search is a search product for the South African Government Gazette that lets collections, legal and financial-services teams check ID numbers against deceased estates, insolvencies, liquidations, sales in execution and name changes in seconds.

I built it as my own product, separate from client work at BrandingLab. The Gazette-Search project summary has the headline numbers: 2.3 million gazette notices indexed, and 50,000 IDs bulk-screened in under 60 seconds. You can try it at gazette-search.com. This article is the founder's side of the story: what broke, what I decided and what I'd tell any team building a B2B product.

Why is five minutes the bar that matters in collections?

Five minutes matters because large South African collection agencies and BPOs run hundreds of thousands of Government Gazette searches a month, and every ID they can't clear is a case they can't close and a fee they can't bill.

They're verifying deceased estates. Insolvencies. Liquidations. Sales in execution. Name changes. Every uncleared ID is a recovery that doesn't ship. For this segment, turnaround time is the product.

The manual baseline is grim. Searches on government sites take hours, days and sometimes months. The official government source is technically online but sits behind a corporate authentication layer that rejects anything other than a live browser session, which makes it useless for programmatic search at scale. The most popular community-built mirror, which most previous attempts had been built against, had started returning broken files for parts of the archive. The legally clean public archive of historical issues was authoritative and complete, but frozen at 2021. Every existing access path was broken in a different way.

For due-diligence work, a false "nothing found" has legal and financial consequences a search engine isn't supposed to carry. A lawyer who closes an estate without finding an unfiled insolvency notice ends up in a courtroom six months later answering questions about due diligence they thought they'd done. A collections analyst who clears an ID against a stale dataset puts a recovery into a queue that should never have been opened.

That's the problem space. The associate had clocked it. So had everyone else in his industry. None of them had a working tool for it.

Why did I move the build from Lovable to Claude?

I moved Gazette-Search from Lovable to Claude because the hard problem was query design and indexing across millions of rows, and that needed repo-wide reasoning more than fast UI scaffolding.

One developer (me). One repo. A pragmatic web stack, the kind you ship in. I'm a designer who learned to ship, and I'm not a career backend engineer.

I started in Lovable.

Lovable is excellent at what it's built for. Fast UI iteration. Opinionated full-stack scaffolding. The kind of platform that gets a working web app standing in an afternoon. If you're building a marketing site, a dashboard or a structured CRUD application, it's a serious tool. (For how Lovable sites fare with AI search, see my comparison of vibe-code platforms for AEO.)

None of those strengths were the problem this product had to solve.

The challenge was to return matches against a database of millions of rows fast enough that a collections analyst doesn't notice the wait: sub-second in the happy path, in a tool a user might run a thousand times in a shift. That takes query design, index strategy and the kind of repo-wide refactoring an app builder isn't designed for. I battled to get the system to return results in time. Lovable was the wrong tool for that layer of the build.

So I switched to Claude.

Claude understood the goal in the practical sense: it could hold the whole codebase in mind. It walked me through database queries I'd designed without thinking hard enough about how they'd be searched. It found why a specific search was slow and helped me rebuild the index that fixed it. The engineering decisions stayed mine. The speed of working through them changed completely.

Hundreds of prompts later, over several months of iteration, I had a system returning matches in seconds. Against a 2GB database. From a single web instance. For a use case where the manual alternative takes hours, days, sometimes months. The bar was five minutes. Searches now come back in seconds.

This is what working with an AI assistant looks like in 2026, in my experience. The AI doesn't replace engineering judgement, and it doesn't write your architecture for you. It removes the cost of moving across unfamiliar territory. The bar my associate gave me was one a pre-AI small team had already failed to clear. A one-person shop with Claude cleared it. The honest summary: a small operator can now punch above his weight.

That distinction matters to me, because it's how I run every client build at BrandingLab too. If you've ever been quoted six months for a build that should take six weeks because the agency is staffing five people on it, you've felt the inverse of this principle.

How did I find out 29.6% of searches were coming back empty?

I found it six months in, when a misleading dashboard metric sent me digging: roughly 29.6% of historical searches had silently returned "nothing found" because some gazettes had never been read correctly.

Lawyers had searched for IDs and got "nothing found" on cases that were actually there. For due-diligence work, that's a defective product.

The first place this showed up was a dashboard that said I had "0.3% gazette coverage", which almost made me panic before I realised the metric was lying to me. The 0.3% was the share of total rows in the database that were gazettes, not the share of gazettes I'd processed. Each gazette spawns hundreds of child notices, so gazettes will always be a small slice of the row count by design. The real problem was buried one layer down, in a different table, where I hadn't been looking.

I almost trusted the dashboard. Since then I've written down every metric on every dashboard I run, and what it actually measures. That's a habit I owe to a near-miss on a Thursday morning.

The why was less mysterious than the what. The historical data source I'd been pulling from had become unreliable, returning broken or substituted files for parts of the archive. On top of that, the PDF parsing library I used couldn't read scanned, image-based PDFs at all, and a meaningful slice of the older legal gazettes are exactly that. The two failure modes overlapped, and the result was a real data gap I hadn't noticed.

The fix was honest work. I investigated every alternative source (official, community, archival, commercial) and most were broken in some way. One legally clean public archive of historical issues was authoritative and complete, just frozen at 2021. I migrated all historical backfill to that source and rebuilt the missing data. For everything from 2022 onward, the platform now runs a weekly fetch against the official source, matched to the Gazette's own publication rhythm of 52 issues a year. Data stays current without manual intervention.

So the archive that was 29.6% empty six months ago is now backfilled and kept current automatically. The next time I have a data-quality issue, it'll be a new one, not the old one.

I'm not bragging. Fixing the data source properly once meant I didn't have to fix it again.

What broke when I refreshed the data on a live product?

Refreshing the data underneath a live product nearly took Gazette-Search down five separate times, because the cloud platform's limits on CPU, memory, disk attachment and scratch space each failed in turn while paying users were searching.

Search itself was already returning matches in seconds. Keeping the data fresh was the hard part.

First try. I ran the data-recovery work inside the same machine that served search traffic. The recovery pegged the CPU. The health check (which was, in retrospect, running a heavy database query; never do this) failed. The cloud platform read the failed health check as a dead service and restarted the whole instance every 60 seconds. The recovery job never completed. The site flickered for an hour while users tried to search and got intermittent errors. The lesson: never put a database query in your health check. I now write this on a sticky note before every new project.

Second try. I made the health check stop doing database queries and moved the recovery work into a low-priority background process on the same machine. I hit the memory ceiling instead. The recovery job got killed silently every time, even after I upgraded the machine to 5GB of RAM. The old legal gazettes are giant scanned PDFs, and parsing them eats memory in ways no documentation warns you about. The machine was also serving live search traffic, and the kernel kept choosing the recovery process to sacrifice.

Third try. I tried to move the recovery work to a completely separate machine, sharing the database file with the live service. It turned out the cloud platform attaches a database disk to exactly one machine at a time. The path I was on was closed by a platform constraint I should have read about a month earlier. The lesson: sometimes the boundary is the platform, and your code is fine. The mental model of "I can just spin up another worker" assumes a degree of separation between compute and storage that doesn't exist on most managed platforms.

The resolution. I took the recovery off the cloud platform entirely. I downloaded the production database to my Mac, ran the recovery locally where there were no users to disturb and no platform limits to fight, then shipped the fixed database back to production through two new admin endpoints I built for the purpose. It took an evening to wire up and a weekend to run. It took a lot longer to accept that the right move was off-platform after I'd spent so long trying to make on-platform work.

The kicker. After the recovered 2.6GB database went live, the whole site started failing every request with a 502 error. Searches returned what looked like JSON to the browser but was actually HTML. The cloud platform's working scratch space had a hard 2GB ceiling, and my database had just grown past it. Every time the service booted, it got evicted within 90 seconds, and the cycle repeated. I moved the database off the scratch space onto persistent storage, resized that storage from 2GB to 10GB, and the platform finally stopped fighting me.

The line I keep repeating to myself, and now to clients: the culprit was disk space. The CPU, RAM and health checks I'd been blaming were red herrings.

None of this was about search latency. Sub-second search was already solved at the application layer. These five attempts are the story of keeping that capability alive every time I needed to refresh the data underneath it. Operating a SaaS is mostly the second story. The first one ends the day you ship the feature; the second continues for as long as anyone is using it.

Where do the hardest bugs in a build come from?

In my experience the hardest bugs come from a system you didn't know was touching yours: one of the worst bugs in this project wasn't on the cloud platform at all, but on my own laptop.

The folder I'd put the source code in was being silently synced by a cloud drive product running in the background. Every time I tried to save a change in source control, the sync would write a file in the middle of the lock mechanism, and the save would silently fail. The first hint was that commits were failing on push. The second was that the commits had never actually completed locally. The third was a Stack Overflow thread three pages down that mentioned the same product by name.

I spent more hours on this than I want to put in writing before I noticed.

Moved the folder. Solved.

The harder a bug is to reproduce, the more likely it's a system you didn't know was involved. I now keep a written list of every background product running on every machine I develop on, so I have a place to start when a bug refuses to make sense.

How should a SaaS handle a defect its users already paid for?

When users have paid for a defective result, the business should absorb the cost of the fix, so I gave every affected search a free retroactive watchlist instead of asking users to pay again.

This is the moment I'm proudest of in the whole project. It's also the one that probably tells you most about how I'd handle a client build, so it's worth slowing down for.

The data crisis meant real users had searched for real IDs and got "nothing found" when the gazette had been there the whole time. For collections agencies and lawyers running due diligence, that's a defective product they had paid for and trusted.

The expected SaaS move was obvious. Email everyone. Announce the dataset is now improved. Tell them to re-search. They'd pay for the re-searches. I'd technically be in the clear.

I didn't do that.

Instead, I went through every historical "nothing found" search in the system and quietly created a free retroactive watchlist for each one. 507 of the 728 historically failed searches were identifier-based and matchable against the recovered dataset. When a watchlist entry matches, the user gets an automatic alert at no cost, forever. They never have to know there was a problem. They just get the answer they originally needed, when it became findable.

A bulk announcement would have reopened the trust question. ("Wait, your data was wrong? For how long? What else?") A quiet retroactive alert, framed as a notification the user signed up for, simply delivers the value they were trying to buy in the first place. No apology email. No "please re-search at no charge" prompt that turns a defect into a marketing moment. Just the answer they came for.

The principle: when the product was defective, the right move was to absorb the cost of the fix myself instead of passing it back to the user.

I've quietly run that test on every operational decision since. It would have been cheap to send the bulk announcement and pocket the upsell. It would also have been the kind of decision I'd be embarrassed to write down in a build log like this one. The fact that you can read about it here without me cringing is, in a small way, the proof that it was the right call.

How much does Gazette-Search cost, and why credits instead of subscriptions?

Gazette-Search charges one credit per search that returns a result, sold in packs from R35 for a single search down to R0.55 a credit at volume, plus an Enterprise tier, because subscriptions couldn't serve both a lawyer and a BPO.

The structural tension Gazette-Search has lived with from day one is the pricing gap between two completely different ends of the same market.

A lawyer running a single estate due-diligence search on one ID can surface billable work worth tens of thousands of rand. That one search is worth R35 to them every time, because it replaces a manual gazette check that costs R500-plus and takes months.

An enterprise BPO running hundreds of thousands of searches a month against a recovery book can't pay R35 per search. The unit economics of debt collection don't survive it.

Same query. Two ends of the market. A several-hundred-thousand-fold volume gap. Completely different economic value per search.

My first instinct was wrong. I started where every SaaS founder starts: subscription tiers. Three plans at R1,500, R4,000 and R6,000 a month. It looked sensible on a pricing page and fitted neither persona. The lawyer who runs three searches a year shouldn't pay R1,500 a month. The BPO running hundreds of thousands of searches a month was never going to fit inside a R6,000 ceiling without the spreadsheet starting to argue. The model penalised both ends and only worked for a narrow middle that didn't really exist.

The current model is credits plus Enterprise.

Credit packs. Seven packs on top of a free tier for searching, from R35 a search at the single end down to R0.55 at the 200,000-credit Volume end (gazette-search.com, prices checked 23 October 2026), roughly a 64-fold per-credit drop across the volume curve. Pay for what you use. Credits are valid for 12 months from purchase. The lawyer buys one credit for R35, or a 100-credit Starter pack at R10 a search, and never thinks about a subscription. The BPO buys the 200,000-credit Volume pack at R0.55 a credit, or steps up to Enterprise, and the per-search cost survives their unit economics. Monthly buyers can put any pack on auto-refill and save 10%. Both ends pay a price that matches the value the search delivers to them.

Enterprise. From R250,000 for 500,000-plus credits, on a custom MSA. Banks, bureaus and continuous monthly screening: the segment where contracts and SLAs matter more than per-credit pricing.

I'll be honest about what was still in transition when I wrote this. I moved off the subscription model to credit packs earlier in 2026. The pricing config and every customer-facing page shipped clean. A few payment-processor-dependent pieces (the business-verification gate for the bigger packs, the monthly add-ons and auto-refill recurring billing) were still partially shipped, and some pages advertised things that weren't billable yet. Honesty about what's not yet shipped is part of what this build log is for.

The lesson I keep repeating to clients: subscriptions suit SaaS founders who haven't yet learned what they don't know about their pricing. Credits plus Enterprise is what most B2B products want to become: usage-based pricing for the long tail, contract-based pricing for the head of the curve, and the discipline to stop pretending one model fits both.

If you've ever watched a buyer do the arithmetic on a tier that doesn't fit their actual usage, you know how much commercial damage a bad pricing structure does. The damage is silent, because the buyer doesn't tell you they've rounded you down to "too expensive". They just don't come back.

Who is using Gazette-Search now?

Gazette-Search's anchor customer is a 30-year-old South African credit management firm on a three-month professional contract, with a large BPO in Enterprise discussions and smaller firms on the free demo tier.

I held off writing this section until the rest was solid, because traction without a built product behind it is just a slide deck.

The anchor customer has done due-diligence work the manual way for three decades and decided to test the seconds-not-hours version on a paying contract. They're not named in this article. What matters here is the kind of customer they are.

A large BPO is in commercial discussions with me for an Enterprise contract, the right end of the pricing curve above. Specifics stay confidential while we negotiate.

A handful of other businesses and solo practitioners are running the free demo tier. Some will convert when they take a clean look at what they got from it.

What this means for you as a reader: the five-minute bar from the opening paragraph is operational at customer scale, and the pricing model bills real businesses for real searches at the per-credit prices above.

That's enough. I don't want to oversell what's still a young product.

What does POPIA require after a data breach, and how did I prepare?

South Africa's POPIA requires a company to notify the Information Regulator and affected people as soon as reasonably possible after discovering a breach, so I built a five-phase breach runbook before any incident happened.

Section 22 of POPIA sets that "as soon as reasonably possible" standard (summary of South Africa's breach-reporting rules). It doesn't set a fixed number of hours. I set myself a 72-hour target, the GDPR benchmark, and built the runbook around it. Most SaaS startups don't think about any of this until incident one.

I built the response runbook first. Five phases: Identification, Containment, Assessment, Notification, Post-mortem. Each phase has the actual database queries, command-line steps and decision rules you'd run while the clock is running. These are operational steps, written to be run.

The supporting infrastructure is deployed. A structured audit log of every admin action. A notifications table that proves which user was told what, and when. A "preview" admin endpoint that dry-runs the affected-users list and the exact email body before anything sends, so the incident commander can read every word before any user does. A "notify" endpoint that paces the actual sends to stay inside the email provider's rate limits. The code is in production. The endpoints respond.

Why build all of this cold? A runbook you write under stress is a runbook with mistakes in it. Writing it cold meant I could think through edge cases I'd never think of mid-incident, like what to do if email itself is the compromised channel (fall back to LinkedIn messages and a notice on the public site).

Here's what I haven't done, and what it's quietly taught me about my own operational discipline. I have never run a drill against the runbook. The runbook itself opens with a line that says "Last drill: never." I keep telling myself I'll do one next quarter. Compliance infrastructure is easy to leave alone until you can't anymore: until an incident lands and you find out, in real time, which parts of your runbook work and which parts you wrote for a version of the code that has since changed.

The honest version: built it cold, which was the right call. Haven't kept it warm since. That's the next call.

I think that's a better ending to this section than telling you the runbook is "battle-tested". The truthful version is more useful to me, to anyone else who's let a piece of compliance infrastructure go undrilled too long, and to any prospect who wants to know what kind of person they're hiring to build their infrastructure.

What's next for Gazette-Search?

Gazette-Search's next steps are a managed database, gazettes from other African countries, OCR for scanned PDFs and finishing the pricing migration, in roughly that order and without a launch date on any of them.

The database migration. The infrastructure story above comes from one decision: keeping the database on the same machine as the web service. Moving to a managed database, and running data refresh as a fully isolated scheduled job, is the version where those five failed attempts never repeat. I've costed it at roughly $45–$105 a month all in. It's the next major architectural project.

Other African gazettes. Several Commonwealth-legacy countries, including Zimbabwe and Nigeria, publish government gazettes with a similar purpose, so the core search engine should carry over with modest changes for each country's format. That's commercially significant for collection agencies and BPOs with cross-border recovery work, the segment Gazette-Search was built for. UK gazette scaffolding in the repo was the original proof that the architecture generalises; Africa is what's actually next.

Image-based PDFs. The scanned PDFs that yielded nothing earlier would yield real text under an OCR pass. That's the cleanest path to closing the long tail of historical gaps.

Pricing migration. The move from subscriptions to credit packs is mostly shipped. The remaining payment-processor pieces are listed in the pricing section above.

No "we're disrupting the industry" close. Just honest sequencing.

What did building Gazette-Search teach me about client builds?

Building Gazette-Search taught me three things I now apply to every BrandingLab client build: infrastructure debt hides at the seams between systems, the default option is sometimes wrong, and AI assistants extend judgement without replacing it.

  1. Infrastructure debt compounds quietly, at the seams. Every problem in this build sat where two systems met. The cloud platform's working storage meeting a growing database. A cloud file-sync product meeting source-control internals. A PDF parser meeting scanned pages. The lesson: look for the seams between systems and assume there's a hairline crack you haven't found yet. The most expensive bugs in a B2B product sit at the interface between two components nobody owns.

  2. The default option is sometimes the wrong option. The most popular data source for what I was doing was fine until it wasn't. The official government source was correct but unreachable. A quieter, legally clean archive, the one nobody talks about, was the one that worked. The same holds for client builds. The popular CMS, the standard hosting choice and the obvious stack are right most of the time and quietly wrong in the cases that matter. The work is knowing which case you're in, and telling the client when the obvious answer isn't the right one.

  3. AI assistants don't replace engineering judgement. They remove the cost of moving across unfamiliar territory, and they let one-person shops compete with teams. I made every architectural call myself. Claude made it possible to make them across hundreds of prompts and several months, instead of the years it would have taken me solo before AI. The associate's five-minute bar was one a pre-AI small team had already failed to clear ("it was a mess"). A one-person shop with Claude cleared it. What changed is that a small operator can now ship at a quality bar that used to require a team.

At BrandingLab I design B2B brands that AI recommends, and I build their Webflow websites. Running my own SaaS means I feel every infrastructure call myself before I make one on a client's site. The Tabono naming story is the brand version of the same approach.

If you're a collections agency, a BPO or a financial-services team running gazette searches and you want to see seconds-not-hours inside your own workflow, book a demo at gazette-search.com. The demo runs on real data against the live system.

If you're a B2B team whose brand or website needs the same kind of thinking, book a discovery call with me.

A runbook you write under stress is a runbook with mistakes in it. I've been trying to write everything cold ever since.

Russel

FAQ

Questions, answered.

What is Gazette-Search?

Gazette-Search is a search product for the South African Government Gazette, built by Russel Shalom Davis, founder of BrandingLab. It lets collections, legal and financial-services teams check ID numbers against deceased estates, insolvencies, liquidations, sales in execution and name changes. It indexes 2.3 million gazette notices.

How fast is Gazette-Search?

Single searches return matches in seconds, and bulk screening has checked 50,000 IDs in under 60 seconds. The bar the collections industry set was five minutes per search. Manual gazette checks can take hours, days or months.

How much does Gazette-Search cost?

Gazette-Search uses credit packs instead of subscriptions, from R35 for a single search down to R0.55 a credit on the 200,000-credit Volume pack. An Enterprise tier starts at R250,000 for 500,000-plus credits on a custom contract. Check gazette-search.com for current pricing.

Why did the build move from Lovable to Claude?

Lovable was fast for scaffolding the interface, but the remaining problems were query design and indexing across millions of rows. Claude could reason across the whole codebase, which helped me rebuild the queries and indexes until searches returned in seconds. The lesson was to match the tool to the problem in front of you.

Does POPIA require breach notification within 72 hours?

No. Section 22 of POPIA requires notifying the Information Regulator and affected people as soon as reasonably possible after a breach is discovered. The 72-hour deadline comes from the EU's GDPR. Gazette-Search's runbook uses 72 hours as an internal target.

Who is using Gazette-Search now?

Gazette-Search is in commercial use, with a 30-year-old South African credit management firm on a three-month professional contract as its anchor customer. The main segment is large collection agencies and BPOs, alongside legal and financial-services teams doing the same verification work.

What does this build log show about how BrandingLab works?

It shows Russel Shalom Davis building and running his own product end to end, including infrastructure, data integrity, customer ethics and breach planning. The same judgement goes into BrandingLab's client work on B2B brands, Webflow websites and AEO.

No items found.

Next experiment

Are ChatGPT, Gemini and Claude naming you

?

Run the free AI test and find out in two minutes. No sign-up. If you'd rather talk it through, book a discovery call.