Custom WordPress plugin case study
Turning recurring campaign layouts into reusable editorial tooling
A custom WordPress plugin built for editorial teams that needed to publish transformation stories repeatedly without rebuilding layouts or handing every content update back to development.
Context
Campaign and editorial pages repeatedly needed to communicate some form of transformation: where something started, what changed and what the resulting state looked like.
Approach
The implementation separates the content model from the final page where it appears.
Outcome
What previously required another bespoke implementation became something editorial teams could create and reuse independently.
Technical model
How the system carries the work from one boundary to the next
- 01
Content
Structured journey data
- Titles
- Supporting copy
- Bullets
- 02
Authoring
CMS-managed presentation choices
- Before
- After
- Neutral
- 03
Rendering
Reusable delivery
- Shortcode placement
- Controlled markup
- Conditional assets
- 04
Experience
Consistent storytelling
- Desktop layout
- Mobile behavior
- Visual hierarchy
The problem
The context and technical tension behind the work
Context
The same storytelling pattern kept returning
Campaign and editorial pages repeatedly needed to communicate some form of transformation: where something started, what changed and what the resulting state looked like. Building each version as custom page markup worked initially, but every repetition introduced another opportunity for layout drift, duplicated styling and developer dependency.
Challenge
Give editors flexibility without giving every page its own implementation
The content could not be reduced to a rigid fixed template. Different stories required different numbers of cards, different relationships between before and after states and enough layout control to preserve the intended narrative.
The approach
Technical decisions that kept the work coherent
Decision 01
A dedicated structured content type captures the journey itself, while ACF-backed controls define the fields and bounded presentation options available to editors.
Decision 02
The frontend renderer then translates that model into the established storytelling component.
Decision 03
This turns decisions such as before, after or neutral positioning into meaningful content attributes rather than arbitrary markup choices.
The solution
Implementation evidence and technical capability
Solution
A reusable editorial system packaged as a WordPress plugin
The finished plugin packages the content model, ACF authoring controls, rendering logic and frontend behavior into one reusable editorial system. Editors can create journey content through the CMS, control the relevant narrative fields and place the resulting component wherever it is needed.
Technical summary
- Structured journey dataTitles · Supporting copy
- CMS-managed presentation choicesBefore · After
- Reusable deliveryShortcode placement · Controlled markup
- Consistent storytellingDesktop layout · Mobile behavior
Core capabilities
- Structured journey content type
- ACF-powered authoring
- Before / after / neutral states
- Layout controls
- Responsive behavior controls
- Shortcode rendering
- Conditional asset loading
- ACF local JSON configuration
Outcome
A technical system with a clearer path forward
Repeated storytelling became a publishing capability
What previously required another bespoke implementation became something editorial teams could create and reuse independently. The component still preserves the visual and responsive rules established by development, but content production no longer depends on reproducing those rules manually for each campaign.
Built to fit into agency delivery
The agency retains control of the client relationship, commercial scope and presentation while technical implementation, testing, documentation and handoff remain behind the scenes unless direct communication is explicitly requested.
Start with a bounded scope
Need senior technical support that fits behind your agency?
The engagement can start with a bounded technical task, a complete implementation or an existing codebase that needs stronger ownership.