The problem
Publishing an article should not require a product engineer to make a code change. In practice, that was the workflow: routine editorial requests competed with feature work, publication depended on engineering availability, and content behavior risked being reimplemented differently across sites.
Docs Hub already had an early application shell when I joined the work. I became its primary engineer and evolved it into a reusable browser-based publishing platform used by seven colleagues in marketing and content.
The outcome was organizational as much as technical: fewer article-related requests reached engineering, and blog-only changes required fewer application deployments.
A publishing path, not just an editor
The visible center of Docs Hub is a Lexical editor, but the useful system extends well beyond a toolbar. A complete article moves through several responsibilities:
Authoring → structured editor state → media storage → conversion → publication → public renderingI worked across that path: editor behavior, file and folder management, authentication, uploads, content APIs, storage, migration tools, publication, and integration with the sites consuming the result.
That end-to-end responsibility is what turned a rich-text field into a platform.
An extensible content model
Technical and editorial content needed more than paragraphs and headings. I extended Lexical with custom nodes and supporting plugins for:
- tables and table management;
- inline and block formulas;
- code blocks and language selection;
- images and image sliders;
- charts and structured visual data;
- iframes and information cards;
- multi-column layouts;
- custom links and richer text behavior.
The difficult part was not rendering each block once. The same content model had to remain coherent while editing, saving, restoring, importing, converting, publishing, and rendering in another application.
Selection-sensitive features were another practical concern. Link insertion and image upload, for example, had to preserve the user's place in the document while asynchronous work happened around the editor.
Content operations
I developed the management and publication capabilities needed for daily use:
- hierarchical files and folders;
- create, rename, update, and delete workflows;
- duplicate prevention;
- frontmatter and article metadata;
- image upload;
- Markdown import and Markdown-to-Lexical conversion;
- legacy content import;
- batch and direct publishing;
- server-side Lexical-to-HTML conversion;
- administrative find-and-replace tools.
These features made adoption possible. A content platform is only useful if teams can bring existing material with them, recover from naming mistakes, manage assets, and publish more than one idealized document.
Authentication and publication
Docs Hub supported authenticated administrative use, including embedded or parent-application flows. Publication moved through object storage, eventually using a shared AWS-backed path that could be consumed by multiple public applications.
The architecture reduced coupling between editorial work and application source code. A routine article update could move through the content workflow instead of waiting for a developer to edit a repository and redeploy a website.
Reuse across applications
The platform work was paired with reusable rendering packages and presentation components. Other public products could consume the same structured content model while retaining their own product experience.
That reuse mattered for more than code reduction. It established a shared contract between authoring and rendering, making rich content behavior easier to evolve across several applications.
Outcome
Docs Hub enabled seven marketing/content colleagues to manage routine article work through a web interface. After adoption, I observed:
- fewer engineering requests for article-related changes;
- fewer application deployments required solely for blog updates;
- a clearer and more repeatable path from authoring to production;
- shared content capabilities across public sites.
Exact before-and-after request counts were not retained, so I keep the operational result directional rather than inventing precision.
Why this matters to my platform direction
Docs Hub is the clearest bridge between my full-stack background and platform engineering. It gave internal users a self-service path, standardized a repeated workflow, centralized complex implementation details, and helped several applications consume the result.
It taught me to evaluate a system by more than whether I could ship the feature. The better questions were: Can another team use it safely? Can existing content move into it? Can applications integrate without copying the implementation? Can the publication path evolve without making every user relearn the workflow?