Using a Component Content Management System (CCMS) such as SCHEMA ST4, you can manage your content in the form of modules, blocks or nodes. Among other things, this means that you only need to draft an individual section for a chapter once and can then reuse it in several different places. Changes to the original section are automatically pulled into the repeated sections. This is just one variant of modularisation; there are various others that you can use depending on the situation and framework conditions surrounding your content in ST4.
In this post, we will take a look at what modularisation essentially means and, ultimately, how to work with modules in ST4. (As this is a comprehensive topic, we will show you our Best Practices here.) What do we mean when we “modularise” something?
Let’s start with simple terms: a module is a self-contained content unit with a specific function – for example an ST4 fragment with a warning safety notice: “Caution: wear protective equipment”. A “fragment” is a content unit at section level. This fragment was created as a module, as the safety notice may be used in various chapters and documents. In a CCMS, you can no longer manage content in a linear way, as in a single continuous document; instead, content is created by sections or chapters, i.e. “modularly”, and is compiled at the end to create the final structure.
The size of the module essentially depends on the CMS information model. Here, you could think that the more fragmented you make the content, the more flexible and “ready for use” it becomes. This is, however, not always the case, as we will see.
What’s more, we can say that the content that we manage and map modularly in a CCMS is generally intended for functional texts. These could be operating instructions, error analyses or even marketing texts such as product sheets and catalogues.
Typical modules in texts of these kinds include short product descriptions in the form of flowing text, safety notices, technical data, graphics, product designations, etc.
Our practical example: a maintenance table
Let’s take a look at how to modularise this section.
The strength of a CCMS lies, in particular, in the modular creation of the content. One of its best features is that you need only create content, e.g. a safety notice, once and can then reuse it in the specific areas of the document where it is needed.Â The following questions are useful for first of all identifying, from a metalevel, where a section, a table, a graphic etc. can be reused in multiple texts: How do the variants differ from one another? Where can I reuse content?
You can see here that, when we use the term modularisation, we are automatically talking about reuse as well, i.e. repeatedly referencing a module, e.g. a graphic, a table cell or a section in another context – arranged in such a way that the content is consistent and fitting in all contexts.
If text variants differ in terms of content, you must then consider the position in the text and the size of the module. These may, for example, involve the same product groups, such as household items. Or they may be intended for the end user and therefore be worded differently from texts intended for suppliers, etc.
Specify the module size
In ST4, you can, of course, use modules as described here in various sizes and for various reuse scenarios. Essentially, there are two categories that determine the size and use of a module: Are you modularising at section level (category 1) or at word level (category 2)? These indicators will help you to make your decision:
The major possibilities of modularisation in ST4 at a glance
Technically speaking, there are several possibilities for creating these modules:
In the information pool:
In the project tree:
Back to the example case
Let’s go back to our maintenance table and take a look at the possibilities of modularisation. Today, we are only interested in creating content and in the type of modularisation that is possible in the information pool.
In accordance with the definition of category 1 modules, the entire visible section can be a module. In this case, it also contains the title, the flowing text and the table. Therefore, all three items of information would be included wherever this section is reused:
If, as mentioned, we only need to use the table in other documents, we need to adjust the text node and set the table as its own module. In this case, we put the table into a fragment and can then reuse this in the other node. This gives the following view in the editor:
It is also possible to create the individual cells or lines as structure fragments. We have already discussed this in this blog post.
If we now also want to modularise by category 2 (i.e. word level), this table unfortunately no longer gives us very much, as it does not contain any truly fixed terms, such as product names.
One option for spiking a table with variables is to include a replacement parts list in an instruction. This looks as below in the Word editor – the cell content in the right-hand column refers to the variable:
And the value set for the variable in ST4 looks as follows:
This means that, if the filter is set to “TurboCo Gas” during production, the value “2500″ is entered into the right-hand cell. The variable itself manages all the values together in one place (for two product variants, for example) and the values are assigned in accordance with the chosen product variant during production.
Tip: When working with variables, make sure that you do not use any declining or conjugating designations. Variables are a sensible option, above all for product variants, if the same text is applicable for various versions of a product.
Modularisation of different types of content forms the basis for working efficiently with a CMS, ultimately allowing you to optimise workflows between the parties involved in the editing process. And lastly, this, of course, leads to cost savings because content no longer needs to be recreated time and again and only needs to be translated once thanks to the reuse option. As we have seen, ST4 offers constructive functions that allow you to modularise your content systematically from creation to publication.