The Problem
At Everfox, I inherited a bare-bones CI/CD publishing deployment that worked only partially and produced PDF. I made the initial deployment reliable, then expanded its outputs beyond PDF to include online help (OLH), HTML, text, spreadsheets, man pages, eBooks, and ISO release media for long-lived enterprise cybersecurity products. The platform had to support several active release lines as well as secure and restricted environments.
I served as the product manager and primary hands-on builder for the system. I managed its roadmap, requirements and specifications, design and implementation, testing, user acceptance, releases, and writer training as new features and publishing needs were added.
Why It Was Hard
Most of the capabilities I needed were not available as settings I could simply turn on. I had to make DocBook XML, XSLT and XSL-FO, Python, Jenkins, ANT, oXygen, shell scripts, regular expressions, and Subversion work together as one publishing system. A new feature could require changes across the source model, transforms, configuration files, validation scripts, local builds, Jenkins jobs, and generated output.
I also managed and built most of the platform myself. I handled the roadmap, requirements and specifications, design, coding and implementation, release planning, testing, user acceptance, troubleshooting, documentation, and writer training and support. I had to trace failures across the system while continuing to support active product releases and add new capabilities.
What I Figured Out
The publishing system needed the same deliberate product management as the software it supported.
I managed it accordingly. The platform needed requirements, release awareness, useful diagnostics, tests, acceptance criteria, regression coverage, UAT, release notes, and maintainable workflows. Quality gates had to enforce standards without making the publishing specialist the only person capable of diagnosing a failure.
What I Changed
Keep Releases Isolated
I rebuilt the inherited workflow so writers could publish locally through oXygen or use centralized Jenkins builds. Both paths used the same structured XML source and transformations. Subversion branches and release-aware build logic selected the right content for each active release, while automated checks caught problems before the output was published.
Catch Problems Before Publication
The QA system checked links, images, metadata, spelling and duplicate words, readability, TODO markers, prohibited terms, and compliance requirements.
Help Writers Recover
A failed validation could stop publication, but the diagnostic output also identified what failed and where. Templates, alt-text prompts, image inventories, QA reports, and compliance controls showed writers what each deliverable required before the final build. Writers could correct missing or noncompliant content while they still had the source open and the context fresh.
Writers did not have to reconstruct every publishing choice at release time. As they worked, they recorded publishing-system options, proprietary notices, ITAR information, and other settings in an XML build file. Inline tags identified content for features available in one product version but not another. The publishing process used the saved configuration and tags to generate the appropriate output, so those decisions were already in place during the final release rush.
I created formal training materials and led live Zoom sessions that demonstrated the publishing workflow, explained new features and process changes, and helped writers diagnose and correct problems themselves.
Keep Platform Changes From Breaking Another Release
Before releasing a publishing-system change, I tested it against the versions and outputs it could affect. I wrote formal test plans, defined acceptance criteria, and used regression matrices to confirm that a change for one release did not break another.
Writers and other contributors performed UAT in their own workflows. Their feedback showed whether controls appeared at the right time and whether diagnostics gave them enough information to correct a problem. I documented the changes in release notes and user documentation before they became part of the regular publishing process.
Trace Certification Requirements
During a year-long government laboratory certification effort, documentation, Engineering, and package staff needed to show where requirements were addressed and what had been corrected or retested. I built a local traceability tool that transformed the government requirements matrix from XML into Excel using Python and XSLT. The resulting workbook connected requirements to documentation and specifications and gave the teams a shared record for certification work.
Raising the Bar requirements and ITAR-related controls also remained part of the publishing and review process. The traceability tool did not replace that work. It made the evidence easier to follow across the people responsible for documentation, engineering, and the release package.
What Changed as a Result
An unreliable PDF-only workflow became a publishing system that produced the required formats, supported multiple release lines, and gave writers both local and centralized build paths. Writers could save publishing decisions before the final release rush and use specific diagnostics to correct problems themselves.
The completed platform connected authoring, quality, compliance, testing, and release work. Writers could run routine builds and diagnose failures without depending on a publishing specialist every time.
Evidence and Technical Detail
The implementation used XML schemas, metadata, variables, conditional content, reusable source, XSLT, XSL-FO, centralized Jenkins builds, local oXygen builds, ANT, scheduled builds, shell scripts, Python, regular expressions, and Subversion branching. Test plans, acceptance criteria, regression matrices, UAT, release notes, formal training materials, live demonstrations, and compliance traceability turned that machinery into a release process people could evaluate and operate. The technologies mattered because they kept releases isolated, moved checks earlier, made failures actionable, and supported dependable delivery.
