A Developer’s Case for Futureproofing Content Management Systems

A Developer’s Case for Futureproofing Content Management Systems

Mike Reynolds

Implementing a new content management system (CMS) can be expensive and time-consuming, so it’s not something you want to uproot year after year. Alternatively, the overhead of maintenance and upgrades can compound over time if a system isn’t configured with the future in mind—exhausting resources and far eclipsing any original savings from cutting corners.

The best practice, of course, is to get it right the first time—implementing the system you need from the beginning and reaping the long-term rewards of efficiency, adaptability, and a lower total cost of ownership. It’s the same rule with carpentry: measure twice, cut once. Unlike wood, CMSs take a few different approaches to be measured for the correct cut.

Why Your Future Self Will Thank You

In a world of planned obsolescence, the idea of long-term planning can seem paradoxical, as the only certainty in the tech world is uncertainty. But that’s exactly the point. Because change is inevitable (operationally, technically, strategically, etc.), it’s essential we manage code and content accordingly by structuring them to flex and adapt to a varying horizon.

The benefits are two-fold: we save on cost (the money and hours spent displacing or upgrading systems), and we gain the flexibility to continually respond to emerging insights and best practices.

Say, for example, our current content model calls for quoter forms with five specific elements. It’s cheaper in the moment to hardcode these elements without investing in additional features; however, if we acknowledge the certainty of change, it’s far more economical to build an environment that content creators can use to generate custom forms moving forward—without opening IT tickets and initiating a new build process all over again.

Alternatively, if we cut corners early with stock factory configurations, we risk bleeding resources later by improvising unplanned and unstable fixes that call for frequent triage and roundabout workflows. We also paint ourselves into a corner by restricting our content options for the life of our system. Both are very real dangers.

Strategies for Futureproofing CMS

While we can’t prevent change, we can minimize risk by adhering to best practices:

Loose Coupling: A CMS should function a lot like a home theater system—wherein each component (television, cable box, media player, gaming console, sound system, etc.) can be upgraded individually without affecting the entire system. A proper CMS should be configured for the same independence, allowing you to modify standalone components of an ecosystem (CRM, campaign management, ecommerce, digital asset management, etc.) without revamping the entire layout.

Independent Code and Content: Similarly, code and content should be configured independently to allow the same flexibility (i.e., an ability to update text without having to update code and vice versa). This will enable content creators to work independently without opening IT tickets for every edit, as illustrated in our quoter form example above.

Content Strategy: Planning for change doesn’t mean planning for chaos. We can’t predict the future, but we can identify patterns that will help us give our content a common root structure moving forward. Again, the goal here is to make it easier to implement changes down the road, and a cohesive family of templates is far easier to manage than assorted one-offs, with each following different rules.

The Importance of Documentation and Training

Of course, all of this is for nothing if contributors and developers can’t utilize a CMS fluidly post implementation—both for maintenance and updates.

It’s ultimately the contributors who will determine a system’s success and ROI, so proper training and documentation is paramount, as is working with them from the beginning to understand workflows and ensure they’re comfortable with processes moving forward. 

Need help futureproofing your CMS? Let’s work together.