A reporter in a Knight Ridder newsroom finishes a story in the print editorial system. The desk edits it. A designer places it on a broadsheet. Overnight, someone in the online group rekeys the headline, rewrites the deck (the short text beneath the headline), picks a different photo, and posts a truncated version to the web by around 6 a.m. Both versions tell the same story, more or less, but they live in different databases and carry different metadata. If the print story gets a correction on page A2 the next day, the web version stays wrong until somebody notices.
This was familiar newspaper work in 2001. I spent a lot of that year and the ones after it trying to change it. XMUltra was one of the projects through which we connected those systems.
Systems with their own histories
Every newspaper I worked with already had capable systems for producing journalism. The editorial system ran the newsroom, pagination handled page production, and advertising and classifieds had their own software. The web content management system, usually younger than the others, ran the site. Getting a story through this collection still involved people copying information between systems.
The purchases had accumulated over years: a newsroom system from 1988, pagination from 1994, classifieds from 1997, a web CMS from 1999. Each vendor had built around its own part of the business. Connecting those products was work the newspaper still had to arrange.
The separation was also organizational. Print and web reported to different executives, had different union rules, and sometimes worked on different floors. A conversation about getting the data to move soon became a conversation about who was responsible for it.
The reporter's wish was straightforward: file once, then have the story, photo, caption, headline and corrections reach every destination that needed them. The company wanted to stop paying twice for the same work. Eliminating rekeying and repeated maintenance gave us a useful purpose for the integration.
Shared processing
XMUltra was a Java framework developed by my earlier newspaper engineering team. Wayne Weber led its architecture. Tom Austin extended it to process classified ads and helped prepare the public source package; his account of the project describes that work. The framework put reusable scheduling, file transfer and other services around processors that understood particular kinds of content.
For news, the common representation was NITF, the News Industry Text Format, an industry XML format. Source-specific adapters and mapping rules translated incoming documents into that form. Downstream systems could work from the normalized story instead of having to understand every editorial system's dialect. The input system did not need a separate relationship with each destination.
That division paid off as we added newspapers. We could write the adapters for a paper's editorial system and CMS without rebuilding the middleware. By the time we had five or six papers in, adding the seventh involved little enough new work that we stopped treating every addition as a separate project.
Centralization also changed the maintenance problem. Our 2003 project description set out a single installation capable of processing content for Knight Ridder's 30-plus newspapers. Previously, document-processing software at separate locations meant maintaining and updating hardware and software across those locations. Sharing the processing installation reduced that repeated work. XML configuration let many changes be made without changing code, and a configuration update could restart only the affected processing channels. A channel was the configured unit doing a particular processing job; changing one need not require stopping the whole framework.
Shared processing gives an engineering team more time to improve the shared machinery and less work repeating the same maintenance at every newspaper. It also makes the shared machinery something that deserves sustained care.
Agreeing on what a story means
An FTP transfer can finish successfully with the headline buried in the story text, the byline unidentified and print-formatting instructions still mixed into the words. Those files need interpretation before a common format helps. One newspaper's “deck” was another's “subhead.” A byline might be a string, a structured author record with credits and contact information, or a code pointing to another table. Copying the characters would preserve the text while losing its meaning to the next system.
News stories also have slugs, budgets, tracking codes, editorial hierarchy, embargoes and correction chains. Several thousand content objects could pass through a major metro's sections on a weekday. At that volume, an unnoticed mapping mistake could be repeated across a great deal of journalism. Late was bad; wrong was worse.
We wanted a story to travel through the systems without losing information. Agreeing on what each field meant took more meetings than writing its conversion rule. The meetings were part of the engineering. If the source and destination teams meant different things by the same field name, a syntactically correct conversion would preserve their disagreement.
XMUltra's news processor made these decisions configurable. It could identify the headline, byline, deck and structures in the body, distinguish staff from wire-service material, and normalize categories. Its implementation used a configurable pre-parser, followed by parsers for the document's head and body and an NITF validation step.
One mapping in the documentation is especially revealing: headline point size to NITF's urgency attribute. The source carried a signal in typography; the destination expected a value it could process. A large headline might reflect the importance of a story, or it might reflect the space available on a page. I'd want the people who understood that publication to agree on the mapping. Once they did, the converter could apply it consistently.
Correctly identifying a byline once let downstream systems use it as a byline. Adding that knowledge should not require writing another scheduler or FTP client.
Different clocks and publication rules
Print and web had different clocks. A print system might lock a story at 8 p.m. for a 10 p.m. press run. The website wanted it as soon as the desk cleared it. Classifieds had a 3 p.m. deadline for the next day's print edition and a continuing flow online. Synchronizing blindly could leave the website waiting for print, or put a story online before the copy desk had seen it.
We worked out explicit synchronization windows and a “web-ready” signal from the desk for material going online. That was an editorial policy the connected systems had to carry through.
The processor's status names alone were not enough to implement that policy. In the public news processor, NOT_READY_TO_PUBLISH could be logged, but the output branch checked whether the document was marked for disposal and whether it had invalid XML. Material not marked for disposal went to normal destinations or the bad-output directory according to its XML status. A receiving publication needed an explicit eligibility rule; logging “not ready” did not itself stop the output.
Structural validity also could not establish that the byline named the right person. Conversion, validation and publication had different jobs, and the design had to connect them deliberately.
An agreed class of feed material could be published automatically, with exceptions sent for review. That fits my preference for quick, web-native editorial workflows. Requiring a website to inherit every step of producing a printed edition would waste the advantage of publishing online. The processor should spare editors repeated format interpretation and give them the controls their web publication actually needs.
Operating the connection
When the editorial system was unavailable, work accumulated in the queue. When the web CMS was unavailable, it accumulated on the other side. A mapping bug could leave a story in a dead-letter state, set aside after processing failed, for hours before someone noticed. We came to care about monitoring as much as throughput: how much was waiting, how old the oldest item was, which adapter was reporting errors, and who would respond.
The framework's operating services addressed several parts of that problem. The 2003 description specified a separate monitor for each processing channel, a time budget for its task and an automatic restart when that budget was exceeded. Failed FTP or HTTP connections were retried after a configurable interval. After a configured number of connection failures, an operator received an email while retries continued. Serious processing errors could also trigger email. These services made a stalled channel or a broken connection actionable; someone still needed responsibility for the response.
The supplied directory examples show another way to connect processing steps: one component's output directory becomes the next component's input. Receiving a file and interpreting its contents can have separate schedules. The same operating questions apply to the waiting work.
One example waits until a newly encountered file's modification time is more than 30 seconds old before handling it. That is a practical attempt to avoid reading a file still being written. A sender can, however, pause for longer than 30 seconds and resume. Where both ends are under our control, I'd prefer an explicit agreement about how a completed file becomes available. Where timestamps are all we have, a longer interval trades a lower chance of mistaking a pause for completion against a longer wait to process recently modified input.
Another example routes XML filenames to one directory and recognized image filenames to another. Extension matching chooses a destination; it does not validate the XML or establish that the file contains a usable story. This example deletes unmatched files. Before adapting it, I would inspect the incoming material and decide what should happen to each kind.
I would keep the original input long enough to investigate a bad conversion. If a byline is wrong, comparing source and result tells us whether the source supplied it incorrectly or our mapping changed it. Keeping only the result loses that possibility. Retention should follow the questions we need to answer.
The remote-backup example separates retrieval, compression into an archive, and cleanup by age and size. Its FTP retrieval is disabled until configured. Those separate steps let us discuss the transfer schedule and archive policy independently, and decide what evidence will remain when an editor reports a problem.
The agreement behind the software
Moving the bits automatically did not settle who owned a headline, a correction or a photo choice. XMUltra made those disagreements visible faster. In a few cases that made things worse before the editors sat down together and agreed on a policy.
When reviewing an integration, I'd follow one representative story from its original document to the version the website receives. I'd inspect its headline and byline, follow a correction through the same path, and ask what made it eligible for publication. I'd also ask who could see a stalled item and who would deal with it. An agreed automatic-publication policy is a valid answer. An intact file transfer answers only the delivery question.
The adapters were often the easiest part. The work that demanded continuing attention was the meaning of the fields, the timing rules, and the operating discipline around failures. Those responsibilities remained after the first successful transfer.
A later reflection, September 2026
I underestimated how long the neighboring systems would live. I expected several to be retired within a couple of years of XMUltra going in. Some were still running in 2010, about a decade after I had first connected them. That experience changed how I thought about maintaining an integration layer: its neighbors may outlive the replacement plans, and it has to keep working alongside them.
The particular product belonged to its moment, but the problem keeps returning wherever several systems share the same content. Reusable processing and a common representation can save a great deal of repeated work. They deserve an operating model that lasts as long as the systems they connect.
The deeper lesson I took from the XMUltra years was that the hardest integration problem is almost never between two computers. It is between two groups of people who have each solved the same problem in different ways and now have to agree on one answer. The software forces the conversation to happen.