Cloud Connected

"I have been searching for a product like Cloud CMS for over 10 years.

After false starts with some typical content management solutions, we were finally able to design the content repository that our business required."
James Baddiley
James Baddiley, CEO

Content Previews and Thumbnails with Cloud CMS

Cloud CMS lets you generate preview images (often called thumbnails) for any content item stored in your repository. This generation can be performed ahead of time via content modeling or it can be done in real-time using a simple URL call.

Content Nodes

In Cloud CMS, everyone content item you create is referred to as a node. A node is a JSON document that can have any structure you’d like.

That is to say, you can drop any valid JSON document you’d like into Cloud CMS and the product will automatically capture it, version it, index it and so forth. It’ll also give your node a unique ID (provided by the _doc field).

Every node lives on a repository branch. You might be working on repository repo1 and branch master. You might use the Cloud CMS Console to create a simple JSON node:


When we create this node, Cloud CMS automatically gives us a Node ID.  


In this case, it gives us d9cfc0491de1a63b6e8e. It is available in our JSON document and we can use this ID to reference our node anytime we want to. 

Note: Fans of the 80’s will no doubt identify the absurdity of a document promoting a movie that should not be made.  Still, we’re here to have some fun, so let’s go with it!


The Cloud CMS REST API lets us work with Cloud CMS content via HTTP commands. If we’re authenticated against our Cloud CMS platform or if our platform offers guest-mode access, we can reference our node like this:

This will give us back our JSON document. It’ll also give us a few additional and interesting properties.

         "filename":"Back to the Future part IV"
   "description":"Yes, they're back.  In Time.",
   "title":"Back to the Future part IV",

We won’t delve into this too deeply. But it suffices to say that our new node has automatically been given a dictionary type n:node and a definition qname o:d9cfc0491de1a63b6e8e. This allows us to use Cloud CMS’ content modeling facilities (if we choose to) to provide validation logic and behaviors on top of our content.

We also see that it has been outfitted with a number of features such as f:audit, f:geolocation and f:indexable. These features inform the behavior of our content and tell Cloud CMS that:

  • access to this content object should be recorded in the audit logs for our platform
  • a geolocation index should be maintained for this content so we can look it up by latitude and longitude (if desired)
  • this content should be indexed for search

Each feature can be configured. By default, no configuration is provided which allows Cloud CMS to fall back to its default way of handling each feature.


Now on to preview images.

Every node in Cloud CMS supports zero or more attachments. An attachment is a binary object that is associated with the node.

You can think of attachments kind of like you think of attachments for an email. Every email can have many attachments. And the same is true for nodes. A node might have zero attachments. If so, we think of this as “content-less” content. Nothing wrong with that. However, other nodes might have a single attachment.

For example, a Word document would be stored in a node (with some JSON) and have a single default attachment which contains the Word document itself.

Suppose we upload a Word document as an attachment for our node. The word document might provide a movie description along with some images.


We can then reference this Word document via HTTP:

This will stream the Word document back to us.  Very useful!


Now let’s suppose that we have a web site. And on our web site, we’d like to provide a link to this Word document along with a thumbnail for purposes of preview. It’s easy. We just let Cloud CMS do the thumbnail generation for us.

This will generate a thumbnail image of the default attachment with a max width of 320 in image/jpeg format. Cloud CMS will produce a preview image of the first page of the Word document.

The preview image will be saved as a new attachment on the node. The new attachment will be called thumb320. The thumbnail will only be generated on the first call. Subsequent calls will re-use the previously generated attachment.


The URL-based preview generator provides all kinds of neat options. Using request parameters, you can adjust how your preview attachments are generated and maintained. Here are some of the options:

  • mimetype - specifies the preview mimetype to be generated. If not specified, assumed to be image/jpeg. However, you could specify other image formats or even other document formats such as application/pdf.
  • size - specifies the maximum width of the resulting image (when mimetype is an image format).
  • attachment - specifies the attachment on the node to be previewed. If not specified, assumed to be default.
  • force - specifies whether the preview attachment should be re-generated in the event it already exists. If not specified, assumed to be false.
  • save - specifies whether the generated preview attachment should be saved as a new attachment on the node. If not specified, assumed to be true. If you set this to false, each request will generate the preview anew.
  • fallback - specifies a fallback URL that should be 301 redirected to in case the preview does not exist or cannot be generated.


Cloud CMS uses preview generation in many places. Fundamentally, we use this quite extensively in all of our HTML5 front-end applications as a means for generating intuitive user interfaces. Here are a couple of really neat places where it shows up: 

Real-time Document Transformations

Suppose we wanted to offer the default attachment (Word document) as a PDF. After all, PDF is a much preferred format for consumption. Businesses tend to prefer Word for the back-office and PDF for the consumer. We can do this by using a link like this:

Multi-Device / Multiple Form Factors

Suppose we want to support lots of form factors. We might want to have a hi-res preview for large form factors (like a kiosk) and much smaller images for devices like an iPhone. We may even want different mimetypes based on bandwidth. We can adjust our URLs accordingly.

Here are a few examples:



Sometimes we may not know whether a preview can/could be generated for content. Suppose, for example, that we want to produce a list of nodes. For content-less nodes, we might provide a stock image that use as a placeholder. The preview generation code lets you fallback to a URL of your choosing. You can do it like this:


As Cloud CMS grows and evolves, we’re pushing further into services and capabilities that support live applications.  The platform’s document management and transformation services are powerful capabilities that stand ready to service your web and mobile apps!

Are you new to Cloud CMS?  If so, consider giving us a try by signing up for a free trial today.

Easy Forms with Cloud CMS

One of the many uses of Cloud CMS is as a storage and reporting mechanism for forms. If you’re looking to put a form up onto your web or mobile site, Cloud CMS serves as an excellent option for capturing and storing this information.

Fundamentally, Cloud CMS provides the Alpaca forms engine. Alpaca is an open-source JavaScript library for jQuery. It makes it easy to design and insert forms into your sites.

Cloud CMS built Alpaca and been working with the broader community to improve it and make it more feature complete. Alpaca provides a large library of pre-built controls.

You can easily do things like render a simple form:


Or a more complex form with multiple fields:

Alpaca provides a library of lots of field types - ranging from basic input things (text, checkbox, select, etc) all the way to full-screen text editors and Google Maps interactive fields.

You can also fully customize the layout of your forms as well as take advantage of automatic features like validation:

Once you’ve built your form, you can connect it to Cloud CMS. This lets you load and save data to/from the Cloud CMS servers. When your users submit their forms, the form data is stored in a data list.

A data list lets you see all of the records including all of the properties of the form, when it was submitted, who submitted it and more.

Data list items are regular nodes in the Cloud CMS world and so you can work with them just like any other content. For example, you might set up rules that trigger notifications, send response emails or transform content for repurposing within your business.

CodeMash 2013 was Excellent!

Last week, Cloud CMS had the pleasure of sponsoring CodeMash 2013 which was held at the Kalahari Resort in Sandusky, Ohio. This was our first year at CodeMash and the first opportunity that we had to hang out at one of the premier developer conferences in the country.

Over two days, we had the opportunity to meet with developers, digital agencies and folks from many other walks of life who were interested in the cloud, content management and mobile applications. The feedback was awesome! Being at an event like this affords the opportunity to hear perspectives from a wide range of people spanning technology from .NET to native iOS and covering industries from construction to healthcare and consumer retail.

It was also very energizing. It’s wonderful all the ways that Cloud CMS could be utilized to assist the “real world” with their everyday problems. Meeting with so many people also helped to reaffirm our company strategy which is heavily oriented around the pending “big data” problem that is quickly eclipsing all industries.

From home cookware devices to medical machinery, the flow of incoming data from outside the firewall is something that businesses struggle with. And tools like Cloud CMS stand ready to help them capture, understand and make sense of that data.

Here are a few thoughts from the event:

Create Once, Publish Everywhere

Everyone is struggling with mobile. The industry hasn’t figured out how to cost-effectively build and publish mobile applications. Cloud CMS offers the ability to create content and publish it to multiple devices without having to rebuild your apps, involve IT, pay lots of developer costs or go back through the App Store. This is a huge win.

The cost of building native applications, time and time again, simply doesn’t scale. This has been pointed out before (but never so eloquently as Karen McGrane in her thought-provoking video “Adapting Ourselves to Adaptive Content”.

JavaScript Rocks

JS/HTML5 continues to grow as the dominant means for expression of cross-platform, multi-surface applications. We were treated some pretty impressive demos of Telerik’s KendoUI and ComponentOne’s Wijmo. These couple together nicely with Backbone, Underscore and other JS frameworks and provide a powerful means for building apps.

Ahead to an Applications Marketplace

We had a very positive response to our strategy going forward both in terms of open-sourcing our Cloud CMS server as well as hosting HTML5 applications. Both are coming very soon. The latter will utilize our NodeJS application tier and dynamic hosting (on * subdomains) to allow anyone to pick an app from our marketplace and deploy it within a few seconds.

Looking forward to CodeMash 2014

Finally, while not surprising, it was very interesting to see such a vast collection of Microsoft .NET enthusiasts all under the same roof. There were plenty of sessions and breakout meetings around .NET topics as well as many others.

We really have to give a lot of credit to the organizers of CodeMash 2013 for putting together such a fantastic event. In addition to having a great amount of technical depth, the event was also a lot of fun. With the water park right there, many of the 2000+ attendees brought their families, kids and significant others. The food was great and the services were top notch.

Above all, the event featured a lot of spontaneity and fun - from improv musical jam sessions in the hallway to magicians, live Star Trek simulators and a bacon bar (where you could load up on fried bacon with chocolate syrup and much more). Yes, that was a first for many of us. But it was awesome!

There were lightning talks, pecha kucha presentations, keynotes and open sessions where folks could spontaneously talk about anything they wanted. All of this amidst hallways filled with people (many barefoot and at least one in a kilt) and RC cars (zooming around underfoot). There was so much going on. It was a blast!

We’re definitely looking forward to being there next year at CodeMash 2014!