I built a system that turns n8n workflows into portfolio pages and keeps those pages in step as the workflows change. It gathers the project details, checks them for sensitive information, writes the page and publishes it to WordPress.
The whole machine, all at once
4 workflows · 56 nodes
Finding the whole party
The main Sync workflow starts every six hours, although I can also run it manually. It looks for workflows tagged as portfolio projects. At the same time, it gets the workflows tagged as parts of those projects. It also reads the table where published projects are tracked. So before making any changes, it has both the live workflows and the existing records on the table.
A project can be made from more than one workflow. Sync combines the two workflow lists and looks for the relationships between them. It groups a portfolio workflow with the tagged sub-workflows it calls. That group becomes the project’s workflow family. Think of it as collecting the whole party before heading into the dungeon.
The table takes a slightly different route. Sync filters it down to tracked rows and prepares them for comparison. The live families are prepared on the other side. Both streams then meet at the comparison node. This keeps the discovery work separate from the decision about what to do with it.
New, changed, gone or just chilling
Once both lists are ready, Sync compares the live projects with the tracked rows. It sorts them into new, unchanged, updated and removed projects. Each category has its own route through the workflow. Unchanged projects can stay where they are. There is no need to rebuild the level when nothing has moved.
New and updated projects are handed to the Process Project workflow. It does the work of gathering information, writing and publishing the page. When it returns, Sync saves a row for a new project or updates the existing row. Removed projects take a different route through the Unpublish workflow. Sync then marks their rows as unpublished.
The run does not need a human to approve each project. If a project fails, it is skipped and tried again on the next run. An error workflow sends an email as well. That means one troublesome project does not have to stop the rest of the queue. The table keeps the results of these separate routes together.
Turning a workflow family into source material
When Sync sends a new or changed project to Process Project, the first job is to gather its family. The sub-workflow lists the family members and gets their workflow definitions. It extracts a fact sheet from each one. Those fact sheets are then combined into material for a single project. This way, the page can describe the main workflow and the parts it calls together.
A workflow definition contains the pieces and connections that make the automation work. Extracting them gives the later writing stage something concrete to work from. The project can have several workflows, but it still needs to read as one system. Combining their fact sheets happens before the writing starts. It is a bit like gathering all the scene files before trying to explain the shot.
Process Project does not send that material straight to the writer. It first calls the separate Utility – Safety Check workflow. The result comes back to a decision node in Process Project. Safe material can continue towards the writing stage. If the check blocks it, Process Project builds a blocked result instead.
A safety check with two pairs of eyes
The Utility – Safety Check workflow is the gate before project material reaches the writer or the website. First, it scans the incoming data for fixed patterns such as credentials and email addresses. Matches are replaced with a redaction marker. It then scans the cleaned copy again. If it still finds a match, the material is not considered safe.
Fixed patterns are useful, but they cannot read a sentence. So the next layer sends the cleaned text to a reviewing model with no tools. The reviewer looks for sensitive information expressed in plain language and points out the text to remove. It does not edit the project material itself. A separate code node removes the flagged text and checks that it is gone.
I made this check fail closed. If the reviewer fails, gives no answer, or flags something that cannot be found, the result is unsafe and the cleaned output is empty. The project is then not published. Findings describe the type and location of a problem rather than repeating the sensitive text. A safety gate that quotes the thing it is protecting would be a slightly awkward gate.
Giving the writer something to work with
After the safety check, Process Project gets my writing samples from a table. It prepares those samples alongside the cleaned project material. The samples give the writing model a reference for my voice. The workflow information supplies the project-specific material. Keeping those jobs separate helps the page sound like me without treating an unrelated sample as a project fact.
The writer produces a structured project page rather than just a loose wall of text. It has a model attached to do the writing and a parser to handle the expected output. The page is organised into a title, summary and blocks. Blocks can also identify the workflow nodes they are about. That gives the next stage a way to connect the story to diagrams.
The generated page then goes through validation. If it passes, Process Project continues towards building the page. If it does not, the workflow builds a blocked result instead. The writer gets to be creative with the explanation, but it does not get to skip the checks. Even an enthusiastic procedural generator needs a gate at the end.
From blocks to a WordPress page
Once a page passes validation, Process Project builds diagrams for its blocks. It then turns the page into HTML for the website. The diagrams follow the node references in the generated blocks. The text and its illustrations can therefore travel together into the page-building stage. It is a little less mysterious than handing WordPress a pile of disconnected nodes.
Before publishing, Process Project looks for a saved page. It uses that result to choose between creating a new WordPress page and updating an existing one. Both routes meet again after the WordPress action. The workflow then sets the page excerpt. Finally, it builds a published result to return to Sync.
This is the same Process Project workflow whether Sync found something new or something changed. The saved-page lookup determines the WordPress action inside it. Sync then records the returned result in its table. That separates making the page from keeping track of the project. Each part has its own job instead of one enormous node trying to do everything.
When a project leaves the party
A removed project does not go through the writing pipeline. Sync sends it to the Unpublish workflow instead. That workflow first checks whether there is a saved page. If there is, it updates the WordPress page to hide it. The project can leave the visible portfolio without needing a new page to be written.
If there is no saved page, Unpublish takes the other branch. Both branches end by building an unpublished result. That result goes back to Sync. Sync then marks the tracked row as unpublished. The check keeps the hide action tied to a page that actually exists in the saved record.
I like that removal has its own small workflow. It makes the difference between publishing and hiding explicit. Process Project handles the longer trip from project information to a page. Unpublish handles the shorter trip in the other direction. Not every project needs the full boss fight on its way out.