How to Manage Content Inside Transactional Applications

Featured article by Robert Minton, Vice President and General Manager at Movable Type

Web applications come in all shapes and sizes. From online banking interfaces to video players like Hulu to social apps like HootSuite or TweetDeck.

What all of these applications have in common, though, is that they exist to manage user-specific data that was generated from some other transaction. The user of the app manipulates data created through some other process intended specifically for them, like their financial records or their list of Twitter followers. These transactional applications primarily handle data that is not often subject to any editorial process. There is usually no human creation, no editing and no approval.

But a closer inspection reveals that applications consist of much more than just the data they manipulate. Inside an application, you’ll also find items such as:

• * Help Topics
• * Marketing Content
• * Label and Instructional Content

These and similar elements are not transactional data. Rather, they are content.

It may seem simple, but this content needs to be created, revised, discussed, collaborated on, versioned, approved and published.

This is a recognizable editorial process, but not like the one you’re used to following when publishing blog posts and static pages. In his whitepaper entitled “Managing Content in the Transactional Application”, Deane Barker writes that such content comes with a unique and complex set of challenges.

The Problem

Some applications build in rudimentary content management capabilities, but these generally function poorly and are often missing higher-level content management functionality, such as granular permissions, workflow, versioning and localization.

This begs the question: Why not use a traditional CMS to manage content inside an application?

This can work, but it comes with its own difficulties.

Most Content Management Systems today utilize what’s known as a “coupled” environment, which means that one CMS environment serves both editors and consumers. In other words, the same server on which the content is delivered is the server on which the content is edited.

Though coupled Content Management Systems are prevalent and include many of the world’s most powerful platforms, they are often problematic for managing content inside transactional applications. The coupled CMS is complex and computationally heavy, which presents multiple problems.

– Performance – A coupled CMS introduces considerable processing overhead, which is often incurred on every request.

– Stability – A processing failure of the CMS can bring the entire application down.

– Security – A security exploit in the CMS can provide a foothold from which an attacker can gain access to the larger application.

– Licensing – If the application runs across multiple servers, this often requires licensing (and paying for) the CMS multiple times.

– Resource Conflicts – It’s not uncommon for applications to “compete” for the management of inbound requests, database namespaces, file system resources, etc.

– Complexity – The introduction of another system to the runtime environment increases the time required for debugging and trouble-shooting issues.

Most transactional applications are complicated works of software engineering, requiring complete control over their processing domain, including the file system, the database server and the web server itself. The same can be said for the modern, coupled CMS.

But there is another type of CMS – one that is far more effective at managing content inside transactional applications.

The Solution

A proven method of removing the complication and instability is to manage content in a separate environment, then “inject” that content into the production environment. The goal is to inject it in such an innocuous method that conflicts are avoided.

This is known as “decoupling.” Inside a decoupled environment, the CMS exists apart from the production server and allows full editorial control while maintaining the stability of the transactional application. Other benefits include being able to utilize different architectures for your repository and publishing systems as well as easy scalability.

Decoupled Content Management Systems are becoming increasingly less common, but legacy platforms like Movable Type are undoubtedly the best solution for managing content properly inside transactional applications.

Further Considerations

Managing application content is still a challenge, even inside a proper decoupled environment.

– Consider in what data format you will publish content. Flat HTML is easy and safe, but offers very little presentational agility. Content should be published in a presentation-neutral format, which allows for easy parsing and manipulation with supported tools.

– Choose your content delivery method carefully. Movable Type and other decoupled Content Management Systems often support multiple direct methods, including FTP, SFTP and rsync. You can also use common tools such as Microsoft’s Distributed File System or Unison to synchronize file system assets. Choose the method that best fits your application’s content needs.

– Developers and content creators should also plan for how to process inbound requests as requests for content rather than application functionality, how to avoid path conflicts and how to create consistent and manageable content handling at the template layer.

Installing a decoupled Content Management System is only a starting point toward properly managing content inside transactional applications. As outlined above, there are many other concerns that need to be addressed in order to avoid conflicts between your CMS and application. Keep this information in mind as you choose a content platform or develop your app. Look for a Content Management System that has the power and flexibility to suit your needs and one that can make using your application a seamless experience for the user.