As I sat down with my colleagues on Tuesday for a little hack day on our favourite open-source content management system, we had a familiar conversation — one that is probably familiar to all people who hack on CMSs — which is, What is the future of content management?
It’s a conversation that has been unfolding and evolving for many, many years, but seems to be a gaining a lot of steam again in 2011.
The essence of some of the more recent conversation is nicely summarized over on Stijn’s blog.
One of the questions presented is: will tomorrow’s CMS be a monolithic app, or a ‘confederation’ of purpose-built micro-applications — like the app that Talking Points Memo demonstrates for managing their front page, for example.
In the blog post on the TPM media lab about the ‘Twilight of the CMS,’ they describe their solution to the problem of the monolithic CMS — “a simple and flexible API that digests manifold requests from the different applications.”
As I ponder these ideas in the context of my work for online-only publishers like TheTyee.ca, I struggle with a few competing notions…
Read-only API, or Read/Write API
In the case of TheTyee.ca, the monolithic CMS writes data to a data store (Elastic Search) that directly provides the (soon to actually be public) public API. From there, various applications can request the data from the API and receive a structured JSON representation of that data back as a response. Basically, once these clients have the data, they can do what they want.
This is great. It’s a read-only scenario. The CMS is still the ‘authority’ on the state and structure of the data (along with a lot of other information), but there is an identical copy of that data in the store that provides the API.
Now, let’s think about that TPM front page management app: it clearly needs read/write access to their API, because it can change not just layout, but editorial content like the story title, deck, teaser, and so on.
So, if the API is read/write, the questions I have are:
The schema for the documents (the stories, etc.) must be validated somewhere, right? So… does that logic live in each purpose-built app, or as a layer on top of the data store? And does that then violate a bit of the ‘Don’t Repeat Yourself’ design pattern?
Do these content-centric writes to the API make their way back to the CMS or editorial workflow system? And, if they don’t, does that not introduce some confusion about mis-matched titles, decks, teasers, and so on? For example, say I change title of a story on the front page, but now I see a typo in the body of story and want to fix that, so I go into the other CMS and search for … whoops! … what was the title of that story again?
How does this new ‘front page app,’ or the read/write API, handle typically CMS-y things like competing or conflicting write requests? Or version control? Or audit trails of who made which edits? If one, or the other, or both, actually handle these concerns, is this not a duplication of logic that’s already in the CMS?
Perhaps I’m not thinking about this right, but my gut is saying that the idea of a read/write API — a scenario where you have both a CMS (Movable Type in TPM’s case) and a ‘front page management’ app — starts to get a bit tricky when you think about all the roles that the CMS plays in the day-to-day of a site like TPM.
It gets even more tricky when you think about all the delivery mediums that have their own ‘front page’ — tablet experiences, scaled down mobile experiences, feeds, e-newsletters, and so on.
Presentation management or editorial management
The other thing that is immediately striking about the TPM demo is the bizarrely print-centric feel to the experience — I’m immediately transported back to my (very brief) days working at The Varsity where the editors and designers would literally paste up the newspaper’s pages on big boards.
For a publication like the TPM — an entirely online ‘paper’ — it seems like an odd, slightly ‘retro,’ approach in an age that is defined by content that defies containers. One must ask: where does it end? Should there be a purpose-built app for each section’s front page, e.g., Sports, Arts, Life, etc.? For each regional section? For each-and-every article?
Isn’t this just vanity at some level? Endless bit-twiddling to make things look ‘just right’? Kinda’ like those mornings when I just can’t decide whether to wear a black shirt or a white shirt and stand in front of the mirror trying them on for what seems like eternity.
So, coming back to my point: in a time when many believe (like a religion!) that content and presentation should be separated — not as an exercise, but because that content is delivered to literally hundreds of different end-user experiences (phones, tablets, readers, etc.) — do we really want to be building tools that focus on the presentation for just one of those experiences? If so, where does it end?
For the most part, the modern-day CMS has been designed to alleviate these myriad challenges by providing a way for non-technical people to input structured data, and the tools for developers to output that structured data in a variety of ways, formats, and mediums.
Watching the TPM video gives me some ideas about how to improve the experience for an editor to quickly edit headlines, decks, teasers, photos of the morning’s stories — and even to indicate their relative priority in terms of newsworthiness — but I would want to stop there, at the editorial, and let the presentation layer be handled according to the medium, device, or experience the content is being delivered to.
Loosely coupled monoliths & read-only APIs
Many moons ago, I proposed that Wienberger’s Small Pieces Loosely Joined idea held true for content management also. The proposal was simple: instead of investing in one monolithic CMS — a CMS that did everything from manage content to advertising delivery to comments to search to who-knows-what (a trend in CMS projects at the time) — an organization could choose the current ‘best in class’ solution for each need and connect them together through loose coupling. Then, if a better solution came out for, say, comments, the old system could be replaced with the newer system without having to re-build the whole enchilada.
(Of course, the flip side often is that louse coupling can feel like bubble gum and string when you have to work with it every day.)
So, while my own experience is that loose coupling is great, and that purpose-specific applications are usually better than apps that try to do everything, I would personally want to draw the line somewhere. For me, that line is between distinct ‘areas of responsibility,’ like editorial, advertising, design, community, search, and so on.
In this scenario, each area would have the authority over its own data, and the logic for how that data is structured and validated, and so on. If that data was written to a central data store that provided an API — something simple, flexible, and RESTful — the other apps in a ‘confederation’ could read from it, choose what to do with it, how to present it, and so on, but the final ‘say’ on that data would be from the app that is responsible for creating it.
For me, this is a sensible way to allow these apps to work in concert without having the logic about the data living in multiple places, i.e., the API, and the clients that can write to it (which makes sense if you’re Twitter with hundreds of external clients, but not if you’re one organization building exclusively internal client apps).
Would love to hear otherwise, or experiences of how others are handling this or thinking about the challenge.


Comments
5 Comments
For my own Bricolage-inspired structured content unit (aka BISCUIT) management system in development, I'm thinking a git-like distributed model.
With publishing speed in mind, the front page app makes changes and pushes out that changed version. Behind the scenes, it makes something like a git branch. Further edits continue to use that branch.
Back in the "real" CMS, editors can merge and resolve merge conflicts. Front page app users will then receive a notification to sync up.
Or not: you could always have multiple "branches" – slightly different versions of the same base story but tailored for different output streams, devices, etc.
Hi Phillip,
Really like what I'm reading, but you bring up a couple of rhetorical questions that actually have perfectly valid answers.
You say that the Talking Points Memo front page management app needs read/write access to the content API, but that's actually not true: the titles and teasers that come from the CMS are meant to be placeholders or defaults, and tweaking the copy on the front page should _never_ affect the original content that comes from the CMS. Any changes that happen at this level are purely aimed at perfecting the *presentation* of the story on the front page of one specific platform (the desktop browser), not the content itself.
Also, it would be perfectly feasible to create a read/write API that has support for versioning, content locking and validation. I've actually done this before. The idea should indeed be to push as much of the logic as possible to the API, so the front-end applications can be stupid simple.
If, like TPM, you're hijacking an existing CMS, then, as you say, it becomes an incredible mess with duplicated logic everywhere. However, that's why we should ask the question of what a post-CMS CMS should look like.
If you'd build a API-driven CMS from scratch you'd probably build it as a front-end that can interact with any RESTful data store that follows certain conventions, and would leverage all the features of that API instead of doing validation, locking, versioning etc. itself. Still quite the mission, mind you, but a different one.
You also raise the question of how much bit-twiddling we should do to make the presentation just right for each page on every platform. Well, I'd say that we should do as much twiddling as makes sense economically. It is actually perfectly possible to automate a magazine-style publication, and let a computer layout stories and pictures by just inputting the page you want each story to be on. I'm not kidding, I've done this. It's just that, well, the experience is so much better with human designers behind the wheel, so that's what we collectively stick to.
If it'd pay off and if it'd make sense usability-wise to customize every individual page for every platform, then yes, I think we should do exactly that. You ask: where does it end? I answer: it ends at the point when we say, "okay, I can do more fruitful things with my time than this silliness". For some publications that happens fairly soon (just the facts! content over embellishments!), for others, like the beautifully designed WIRED, that happens rather late. And for TPM, the front page is where it stops. It's the one thing they want absolute control over, and that makes total sense to me.
Lastly, the information professional in me does cry a little bit when you say that CMSes are made for non-technical people to input structured data. They're not, they're made for people to input big blobs of text :-)
Hi Phillip,
Interesting article. I think one of the key things to remember is what your primary asset is, and that's the actual data, or content of the articles and associated assets. Obviously at the end of the day you need a way to present that data, but the important thing is to provide a self contained representation of the different data sources. Self contained is the key idea here, and what I mean by that is you need real functional data APIs. Everyone is obsessed with rest*FUL* APIs right now, but really, they're not enough. The reason that the 'FUL' is included in restful, is that the actual rest spec requires an API to define its own actions for any given resource. If you're creating a mashup of a variety of data sources, it is imperative that you know as little as possible about any particular API, and instead you generically build its operations on top of data it provides. Then having a variety of APIs sources that will most likely be in relative flux over time is not a burden, its an asset.
This not only translates into an easier way for you to work with a variety of data, but also means that people come to you for your real asset, data! You become a provider of data sources, rather than a provider of structural presentation of data (aka non parseable web pages). I think Web 3.0, or whatever new buzzword will describe it, will be represented by a move away from provider controlled presentation of content, and instead be an era of data consumption (you could argue that current technology provides a lot of this, however I think the current APIs are entirely too dependent on the client side being knowledgeable about the API itself. I should be able to discover and traverse your API in a meaningful without ever having to read documentation on it). I think its ridiculous to expect every website or service to not only provide an interface to all of my devices and various forms of data consumption, but to also provide an interface I like! Everyone is different and everyone has different views on how they want to see data. I've really started to notice this as I've been experimenting with different data consumption apps on an android tablet. I would love to see an explosion of data presentation applications in the same vein as RSS readers, but the RSS standard itself is not up to par as its focused on direct consumption of data streams, not on the consumption and interaction of that data.
Well there's my long winded comment about data APIs, and where I think they should go. Not all of this is feasible today, but you can go a long ways with self contained APIs and a minimal common data schema.
-Russell
You're sick, Greg, sick. :-P
Hey there Stijn,
I guess I'm a bit confused by this. In my experience, there are several 'truisms' that hold across most of the publishers that I work with. One is that more than half of their Web traffic bypasses the front page completely.
If that holds true for TPM, then the front page is being bit-twiddled for an ever-increasingly smaller audience as traffic moves to new devices that don't see those same changes (if what you're saying is true -- that these changes don't get pushed back to their CMS -- then I shouldn't be getting these headlines on my phone, tablet, and so on).
Obviously, if you're a print publication, changing the titles, decks, and teasers for mediums that are not space-restricted makes total sense. But if you're an online only publication, changing them for the front page alone -- and nowhere else -- makes little sense to me.
Moving on... :)
I accept that if we were to throw out the old CMS and re-invent something new, it would be *amazing* and would answer all of the questions that I've asked above. But how many organizations have you come across who could do that? Either logistically, or financially? A start-up publisher, maybe.
In my experience, it's most often incremental improvements that publishers can count on, and it sounds like it's that way for the TPM too. They're going to stick with their CMS but try to abstract away as much of it as possible from the delivery of content, which makes total sense.
As for building a new API-based CMS that can handle all of the needs of a large publication with many contributors, editors, designers, and developers -- sure, it can be done -- but when will it be ready for prime time? I suspect any ideas we have today of a 'post-CMS CMS' will be outdated by the time it's built.
That's why I ask if TPM is moving in the wrong direction here (not for its own needs, obviously). I don't see how publishers can -- or why they should -- replace the years of consideration and development that have already gone into (sometimes unnecessarily monolithic) CMSs.
I often looked at newer CMSs and am amazed at how sparse they are: revision history with diffs? Nope. Audit log for any / all objects in the system (stories, sure, but also media, templates, changes to state, etc.)? Nope. Live template editing / change previewing without running a separate instance of the software? Nope. Rich permissions system -- e.g., limit what kind of objects a user can create, where they can put them, and what state they can leave them in? Nope.
Starting from scratch seems like a long journey to me.
Not sure which CMSs you're working with, then. ;) That may be true for Wordpress and Movable Type, but it's not always true -- some CMSs focus on document modelling and structured data almost exclusively.
Of course, having the text in the right field is one thing, and having it embodied with meaning is another challenge entirely. Entities and relationships in data are a problem much bigger than any one CMS and probably need to be grappled with by each organization that sets out to use them -- like bit-twiddling the front page, I supsect it's going to be a question of 'How much time can I justify spending on this.'
Regardless, I think what I'm asking is: do we really need to throw out everything that is good about the modern-day CMS just to get to the post-CMS CMS?