A vignette on thirty years of the same good idea
There's a moment in software that every builder lives for.
The user stares at a blank page. They click a button. And then — without touching a single layout control, without dragging one text box, without doing anything at all — the content appears. Perfectly formatted. Everything in its place. The columns flow in. The ads land where they're supposed to. The headers and footers are already right.
To the user it looks like magic.
To the developer, it looks like Tuesday.
Yellow Pages and the Bin-Packing Problem Nobody Called That
It's 1994. FoxPro 2.6. Cross-platform Windows and Mac — DDE on the Windows side, Apple Events hacks on the Mac side, LAN-networked across both. The product was called GalleyMaster, and it was built for a very specific, very lucrative, and now largely forgotten industry: independent Yellow Pages directory publishers.
In the mid-90s, the Baby Bells — the regional phone company monopolies spun out of the old AT&T — were printing Yellow Pages directories and collecting enormous amounts of money to do it. Businesses had to be in the book. There was no alternative. And the phone companies knew it.
But there were independents. Scrappy regional directory publishers who competed head-to-head with the phone companies in specific markets. They were nimble. They were hungry. And if they had the right tools, they could undercut the Bells on price and still make a healthy margin.
GalleyMaster was built to give them those tools.
The core problem — the one that made directory publishing genuinely hard — was pagination. A Yellow Pages page isn't a blank canvas. It's a constraint satisfaction puzzle:
- Display ads come in as placed graphics with text flow boundaries, pushing body copy out of the way
- Nothing goes in the gutter
- Bigger ads float to the top
- An ad must appear on the same page as its category heading — unless it's a full page
- The text has to flow around everything, reflow when anything moves, and the directory still has to close — you can't just add pages
Every page, every category, every ad placement was a decision with downstream consequences.
GalleyMaster had a placement function that tested every possible location on the page, checked whether another graphic was already occupying that space, and chose the next available slot if it was. It knew the rules. It applied them automatically. And when it was done, the page looked like a professional layout artist had spent an hour on it.
The user had started with a blank page.
More Than a Layout Tool
But GalleyMaster wasn't just about the pages. The real architecture was the business system underneath.
A Yellow Pages ad is simultaneously four different things:
- A layout object — it has dimensions, position constraints, a category, a page
- A sales contract — somebody sold it, at a rate, with a close date
- A production job — artwork had to come in, get placed, get proofed
- An accounts receivable item — somebody owed money for it
Most shops in that era ran separate systems for each of those functions — a layout tool here, a billing package there, a spreadsheet for AR somewhere else — and reconciled them manually, painfully, monthly.
GalleyMaster unified them. The directory was the central object. Every other function — sales leads, contracts, ad specifications, proof tracking, signed approvals, invoicing, AR aging, collections, past-due reports — orbited around it.
The signed proof sheet is worth a moment. When the ad was ready, GalleyMaster printed the proof. The customer signed it. It went in a physical file. When a customer called six months later and said "that's not what I approved," you pulled the file. There was their signature. Collections needed that paper trail. Accounting needed it. It was the legal backstop for the entire production relationship.
Paper and pixels, working together. That's still how a lot of real business gets done.
PageMaker, Then InDesign, Then the Internet
The communication layer evolved. GalleyMaster started talking to PageMaker via DDE on Windows — DDEInitiate(), DDEExecute(), DDETerminate(), all the finicky timing-sensitive ceremony that DDE required. On the Mac side it was Apple Events, which was its own kind of exotic. The FoxPro Mac documentation on this was thin. You figured it out.
When Adobe shipped InDesign 1.0 in 1999, the migration followed. New scripting model, new communication layer, same core idea: structured data flows in, perfectly formatted pages flow out.
For a window of maybe fifteen years, the independent directory business was genuinely good. The technology worked. The margins were real. And the Bells, for all their size, couldn't move as fast as a small publisher with the right software.
Then the internet arrived and made the entire category obsolete inside of a decade. A business that had been multi-billion dollars and deeply profitable became a historical footnote. The scrappy independents and the phone company giants went down together.
That's how it goes. Markets end. Technologies change. The work was still worth doing.
The Same Good Idea, Thirty Years Later
DataPublisher for Word is not a Yellow Pages tool. It generates personalized documents — letters, contracts, reports, certificates, proposals — from structured data sources, distributed at scale through Microsoft Graph.
But look at the shape of it.
Structured data + business rules + automated document generation + distribution.
That's GalleyMaster. That's the same insight that made the columns flow in perfectly on a blank page in 1994. The domain is different. The delivery mechanism is different. Word task panes instead of PageMaker artboards. Microsoft Graph instead of a LAN share. AI-assisted template design instead of hand-coded placement algorithms.
But the thing the user experiences is the same: they start with something empty, they run a process, and something complete appears. It still looks like magic. It's still Tuesday to the developer.
The automatic pagination dream isn't dead either. InDesign has a full scripting API now. There's a headless server-side path. AI can reason about layout constraints the way a placement algorithm once did with explicit rules. The thread that started in FoxPro 2.6 is still running.
Creation Is Fun
If you were a FoxPro developer in the 90s, you know what it felt like to make something work that probably shouldn't have worked — DDE handshakes across a LAN, Apple Events on a platform where the documentation was aspirational, Rushmore queries flying through .DBF files on hardware that would embarrass a modern wristwatch.
If you were in the Yellow Pages business, you know what that industry felt like at its peak: specific, profitable, and completely certain of its own permanence right up until it wasn't.
Both of those things are gone now. The tools are different. The markets are different.
But the act of making something that feels like magic to the person using it — that part doesn't change.
That's the thread worth following.
Richard Roberts is the founder of DataPublisher LLC, building document automation tools for the Microsoft 365 ecosystem. He has been making data flow into documents automatically since 1994.