Molecular Content and the Separation of Concerns

Our current ways of writing and producing web content seem ill-prepared for the needs of the future.  Content producers focus on planning articles or web pages, but existing approaches aren’t sufficiently scalable or flexible.  Web publishers need to produce growing quantities of increasingly specific content.  High volume content still requires too much human effort: the tedious crafting of generic text, and/or complicated planning that often provides inadequate flexibility.    Content producers, using tools designed for creating articles, lack a viable strategy for creating content that machines can use in new contexts, such as voice interfaces.  Before audiences see the content, machines need to act on it.  It’s time to consider the machine as a key audience segment, instead of as a incidental party.

Within the content strategy community, a discussion is starting about making content “molecular”.  Content molecules are  fundamental building blocks that can be combined and transformed in various ways.  The concept still lacks a precise definition.  But it seems  a compelling metaphor for thinking about content, given the diverse directions content is being pulled.   Molecules connect together, like Tinkertoys™.  Forces (business, technical, and consumer preferences) are pulling content in different directions.  How to connect molecules of content together is a pressing issue.  The metaphor of molecular content offers a chance to reimagine how content is created, and how it can serve future needs.

“A molecule of content is the smallest stable autonomous part of content, with a unique purpose. Molecules, of varying purpose, can be built into stable compounds of content in order to form meaning and provide a purpose.” — Andy McDonald and Toni Byrd-Ressaire

Content needs to serve many functions.  It must provide coherent narratives as it always has done.  But it is also needed in short bursts as well.  Content will need be interactive: responding to user requests, anticipating needs, updating in real time as circumstances change.  Molecular content is fundamentally different from previous ideas of “modular” content.  Modular content are static standalone chunks of words.  Molecular content is data-aware: responsive, interactive and updatable.  Molecular content is connected to logic, and gets involved in the context it is used.

In the future we can expect content will need to be:

  • Able to be speak and listen
  • Capable of animation to show a change in state
  • Able to communicate with machine sensors
  • Capable of changing its tone of voice according to the user’s state of attention.

The notion of shape shifting words seems fantastic — especially to authors accustomed to controlling each word as it appears in a text.  But words are really just a special form of data — meaningful data.  Computers can manipulate data in all manner of ways.

Content for human communication can be more complex than common computer data.  Existing data practices will contribute to the foundations of molecular content.  But they will need to be extended and enhanced to support the unique needs of words and writing.

Writers don’t like considering words as data.  They raise two objections.  First, they consider words as more nuanced  than data.  Second, they worry that the process of writing will resemble programming.  Their concerns are valid.  No progress will happen if solutions are too rigid, or too complex.  At the same time, writers need to prepare for the possibility that the process of web writing will fundamentally change.

Four Hidden Activities in Writing

Writing is a tacit process, rarely subject to analytic scrutiny.    We’re aware we form sentences involving subject, verbs and objects.  These get joined together into paragraphs, and into articles.  But the process can be so iterative that we don’t notice separate steps. When writers talk about process, they generally refer to rituals rather than workflows.

If we break down the writing process, we see different activities:

  1. Making statements (typically sentences)
  2. Choosing the subjects to write about in statements.
  3. Organizing these statements into a flow.
  4. Making judgments through implicit references.

Implicit references are the stealthiest.  In our speech and writing, humans summarize thoughts.  We may make implicit statements, or render an explicit judgment that saves us from having to list everything (for example, saying “the best…”, or “good…” ).  People who work with data talk about enumeration — basically, creating a definitive list of every value (e.g, the seven days of the week.)  When we talk, we assume shared knowledge rather than repeat it.  We assume others don’t want a complete list of every city in a country, they just want to know the largest cities.

If anything, technology has made the writing practice blur together these activities even more.  When we can rewrite on the screen, we can cut and replace with abandon.  The stringing together of words becomes unconscious.  Any attempt to make the process more explicit, and managed, can feel limiting, and is often met with resistance.

One of the big unanswered questions about molecular content is how to write it.  Molecular content will likely require a new way of creating content. First, we need to examine the process of web writing.

The Three Writing Workflows

Any web writing process needs to address several questions:

  • What things (proper nouns or entities) do you want to discuss?
  • What statements do you want to make about these things?
  • How to structure these statements (what template to use)?

These questions can be addressed in three different sequences or workflows:

  1. Author-driven
  2. Template-driven
  3. Domain-driven.

The author-driven approach treats writing as a craft, rather than as a process. The sequence starts with a blank page. The author writes a series of statements.  He structures these statements.  Finally, he may later tag things mentioned in the text to identify entities.

The author-driven sequence is:

  1. Write statements
  2. Structure text
  3. Tag text

The template-driven sequence starts with a template.  This approach is gaining popularity, with products like GatherContent providing templated forms that authors can fill-in.  The structure is pre-determined.  It is not unlike filling in an online job application.  The author needs to add text inside boxes on a form.  Later, the text can be tagged to identify entities mentioned.

The template-driven sequence is:

  1. Choose template or structure
  2. Write statements
  3. Tag Text.

The template-driven approach can sometimes allow the reuse of some blocks of text.  But often, the goal of templates is to organize content and facilitate the inputting of text.  A common organization can provide consistency for  audiences viewing different content.  But such structure doesn’t itself reduce the amount of writing required if the content has a single-use.

The domain-driven sequence starts by choosing what entities (people, places or things) the author plans to discuss.  Entities are the key variables in content.  They are what people searching for content are most likely to be seeking. Shouldn’t we know what entities we will be talking about before we start writing about them?  Once the entities are chosen, authors write statements about them.  They consider what can be said about them.  Writers can organize these statements by associating them with containers that provide structure.  Unlike the other approaches, authors don’t need to worry about tagging, because the entities are already tagged.

The domain-driven sequence is:

  1. Choose entities (pre-tagged)
  2. Write statements
  3. Choose containers for structure.

Domain-driven content writes content around entities. In other approaches, identifying what entity is mentioned is an afterthought, during tagging.  Because it is entity focused, domain-driven content is well matched to the needs molecular content.

Molecular Content through Domain-driven Writing

Domain-driven content is not new, but it is still not widely known.  I wrote about content and domains as they relate to Italian wine several years ago when I was living in Italy.  Happily, a new book has just come out by Carrie Hane and Mike  Atherton called Designing Connected Content talks about domain-driven content in detail.   It’s an excellent place to start to learn how to think about planning content from a domain perspective.  For writers wanting to understand how domains can influence writing, I recommend the blog by Teodora Petkova, who has been writing about this topic extensively.

Domain-driven writing may seem hard to envision.  How will one choose entities to write about before writing?  Perhaps writers could tap to select available entities, much like they tap to select available airline seats.  The tool could be connected to an open source knowledge graph that describes entities; a growing number of knowledge graphs are available.

The entities selected could be at the top of a screen, reminding the writer about what they should be writing about.  It could help writers remember to include details, or explore connections between topics they might not think to explore.  A tool could even helpfully offer a list of synonyms for entities, so that writers know what vocabulary they can draw on to discuss a subject.  Maybe it could even recommend some existing generic text about related entities, and the author could decide if that text is appropriate for discussing the entities they have chosen.

Domain-driven writing is a good fit for factually rich content.  It’s not an approach to use to write the next great novel.  Novelists will stick with the author-driven, blank page approach.

Much web writing is repetitive.  The details change, but the body of the text is the same. Domain-driven content puts the focus on those details.  It isolates the variables that change, from those that are constant.  In bring attention to the context that variables appear.

Even when the text of statements changes, domain-driven content allows factual data to be reused in different content.  If a product is mentioned in various content, the price can always appear beside the product name, no matter where the product name appears.

Two approaches to domain-driven writing are available, which can be used in combination.  The first approach creates reusable statements that are applicable to many different entities. The second approach allows custom statements for specific entities.

The first approach aims to standardize recurring patterns of writing by:

  1. Decomposing existing writing into common segments or chunks
  2. Normalizing or standardizing the text of these segments
  3. Reusing text of segments.

Instead of writing to make the text original-sounding, writers focus on how to make the text simpler by reducing the variation of expression.  The emphasis is on comprehension.  It is not about boosting attention by aiming for originality or the unexpected.

Let’s imagine you have a website about caring for your dog.  You have content about different topics, such as grooming your dog, or training your dog.  Dogs come in different breeds.  Does the breed of dog change anything you say about training advice?  Do you need to customize a paragraph about training requirements for specific breeds?  The website might have a mix of generic content that applies to all breeds, with some custom content relating to a specific breed.  The delta in the content helps to flush out when a specific breed is a special case in some way.

The second approach is start with entities — the key details your content addresses.  Instead of thinking about grand themes and then the details, you can reverse the sequence.  In our dog website example, we start with an collection of entities related to dogs.  This is the dog domain.  What might you want to say about the dog domain?  A tool could help you explore different angles.  You might choose a breed of dog to start with, perhaps a poodle.  The tool could show you all kinds of concepts connected to a poodle.  These concepts might be start of statements you’d want to make.  The tool would resemble a super-helpful thesaurus.  It would highlight different connections.  You could see other breeds of dog that are either similar or dissimilar.  Seeing those entities might prompt you to write some statements comparing different breeds of dog.  You might see concepts connected with dogs, such as traveling with dogs.  You could even drill down into sub-concepts, such as air travel or car travel.  The experience of traveling with a dog by air is different according to breed: for example, a Dachshund versus a Saint Bernard.  If you need to write statements to support specific tasks, the domain can help you identify related people, organizations, things, events, and locations — all the entities that are involved in the domain.

Domain-driven content is scalable.  You can start with statements about specific things, and then consider how you can generalize these statements.

Slide from a presentation by Rob Gillespie

Molecular Content: How Content Gets Liberated

Molecular content needs to be highly flexible.  To deliver such flexibility, different components need to play well with the rest of the world. One can’t overstate the diversity that exists currently in the web world.  Millions of individuals and organizations are trying to do various things, developing new solutions.   Diversity is increasing.  New platforms, new syntaxes, new channels, new programming languages, new architectures must all be accommodated.

We need to let go of the hope that one tool can do everything.  Tightly-coupled systems are seductive because they seem to offer everything you need in one place. Tightly-coupled systems give rise to authoring-development hybrid tools such as Dreamweaver or FontoXML.  Content, structure and logic all live together in a single source, which seems convenient.  But your flexibility will be limited by what those tools allow you to do.

The ideal of single sourcing of content is becoming less and less viable.  Requirements are becoming too elaborate and varied to expect a monolithic collection of files following a unified architecture to address all needs.  A single model for publishing web content can’t cope with everything being thrown at it.  Models are brittle.  We need systems where different functions are handled in different ways, depending on shifting circumstances and diverse preferences.   When you use a single model, others will reject what’s good about an approach because they hate what’s limiting about it.

Web publishing is becoming more decoupled.  Headless CMSs separate the authoring environment from content management and delivery.  Content management systems offer APIs that allow unbundled delivery of content.  Even the authoring process is getting unbundled, with new tools that specialize in distributed input, collaborative editing and offline workflows.

While the trend toward decoupling is gaining momentum, most attempts are limited in scope.  The don’t fundamentally change how content is created, or how it can be available.  They rely on the current writing paradigm, which is still document focused.  No one yet has developed solutions that make content truly molecular.

Molecular content will require a radical decoupling of systems that process content.  The only way to create content that is genuinely future-ready is to remove dependencies that require others to adopt legacy approaches and conventions.  Systems need to be adaptable, where parties involved in producing web content can swap out different sub-processes as new needs and better approaches emerge.

The Backend of Molecular Content: Separation of Concerns

It is challenging to talk about a concept as novel as molecular content without addressing how it would work.  I want to introduce a concept followed by developers called “the separation of concerns” and discuss how it is relevant to content.

Suppose a developer wanted to code a heading that said “Everyone is talking about John.”  In old-school HTML, developers would hard-code content, structure, and in-line logic together in a single HTML file.  Here’s what single source content might look like:



<h1>Everyone is talking about<div id="person"></div>.</h1>


document.getElementById("person").innerHTML = "John";




The file is hard to read, because everything is smushed together.  In a single file, we have content, structure, a variable, and a script.  It may sound efficient to have all that description in one place, until you realize you can’t reuse any of these elements.  It is brittle.

In modern practice, webpages are built from different elements: content files, templates, and separate scripts providing common logic.  Even metadata can be injected into a webpage from an outside file.  This decoupling allows many-to-many relationships.  One webpage may call many scripts, and one script may serve many webpages.  This is an example of the separation of concerns.

To separate concerns means that code is organized according to its purpose.  It is easier to maintain and reuse code when common things with similar roles are grouped together.

Let’s consider the different concerns or dimensions of how content is assembled.  The dimensions that computer systems consider to assemble content is in many respects similar to how authors assemble content.  They are:

  • Content variables
  • Narrative statements
  • Containers for content
  • Logic relating to content

These different concerns can be managed separately.


Variables are the energy in the content.  Because they vary, they are interesting.  Humans are hardwired to notice stuff that changes.

Variables live within statements.  Suppose wish aloud to our companion, Google, on our smartphone.  We say: “Ok, Google.  Get me a flight between Paris and Hong Kong for less than $500 in the first week of March.”  We have numerous variables in that one statement.  We have destinations (Paris and Hong Kong), price ($500) and time (first week of March).  Which of those is negotiable?  When we think about variables as being subject to negotiation, we can see how statements might change.

Variables animate statements the way atoms animate molecules, to use a metaphor.

Variables are frequently proper nouns or entities, which are visible in the content.   Such variables are descriptive metadata about the content.  A price mentioned in a statement is an example.

Some variables are not visible.  They are background information that won’t show up in a statement, but will be used to choose statements.  Such variables are often administrative metadata about content.  For example, to know if a statement is new or old, we could access a “published on” date variable.

What makes variables powerful is that they can be associated with each other.  These are not random words like the ones  used by a random phrase generator.  Variables follow patterns, and form associations.

For example, if we wanted to describe a person, we start by thinking about the variables associated with a person.

Person :

  Name: John,

  Gender: Male,

  Profession: Painter

A different person will have same variables, but with different variable values.  We can keep adding variables that might be useful.  This is the factual raw material that can be used in our content.

An important point about variables is that they can be represented different ways.  Because we want to separate concerns as much as possible, the variable lives separately from statements, instead of being embedded in them.  Because variables are separate, they can be transformed to serve different needs.  We don’t worry about what syntax is used.  It could be JSON, or YAML or Turtle.  When variables exist separately, their syntax can be easily converted.  We also don’t worry about what schema is used.  We can use different schemas, and note the equivalences between how different schemas refer to a variable.  We can reassign the name of a variable if required.  Maybe we want to refer to a person’s job instead of a person’s profession.  Not a problem.


Statements are generally text, though they could be an audio or video clip, or even an SVG graphic.  I’ll stick to text, since it is most familiar and easiest to discuss.

Statements will often be complete sentences, perhaps several related sentences.  But they could be shorter phrases such as a slogan or the line of a song.  Statements can be added to other statements.  Each line of a song can be joined together to produce a statement conveying the song’s full lyrics.

Statements become powerful when used in multiple places. Statements can accommodate visible variables to produce statement variations.  Some statements won’t use variables, and will be the same wherever they appear.

Statements are the basic molecules of content.  Some statements will be short, and some will be long.    The length depends on how consistent the information is.  We can use variables to produce statement variations, but the statements themselves stay consistent.  When we need need to talk about certain variables only in some situations, then new statements are needed.

Let’s look at how statements can incorporate variables.  We will use the person variables from our previous example.

Statement_1 : “Everyone is talking about {Person.Name}, the popular {Person.Profession}.”

Statement_2: “{Person.Name}’s Big Moment”

These are two alternatively worded statements that could be made about the same person.  Maybe we want to use them in different contexts.  Or we want to test which is more popular.  Or maybe they will be both used in the same article.  Because these statements are independent, they can be used in many ways.

I’ve used “pseudocode” to show how variables work within statements.  If we have many persons, we can be selective about which ones get mentioned.

But the syntax used to represent the text can follow any convention.  It could be plain text, or a subset of Markdown.  We are only interested in representing the information, not how it is structured or presented.  The information is independent of structure.  There’s no in-line markup.


Structure is how statements are arranged and represented.  Structure is one of the two ways that content molecules get “bonded” to other molecules (the other way is logic, to be discussed next).

Statements and structures have a many-to-many relationship.  That means the same statement can be used in many different structures, and a single structure can accommodate more than one statement.

A simple example (again using pseudocode) will show how statements get bonded into structures.  It is as simple as dropping the statement into a structural element.

/// Structure_1

<h1> {Statement_1}</h1>

/// But it could be instead

/// Structure_2

<h2> {Statement_1} </h2>

A single statement could be applied to many structures, including image captions or email headers.

As we consider a wider range of content, we can see how statements need to be used in different templates.  For example, the same transcript may need to appear as text of interview, and as subtitles of a video.

Structure should not be hard-coded into statements the way XML markup and CSS-selectors tend to do.  That limits the reuse of statements.

Molecular content should be independent of any specific structure, and able to adapt to various structures. We need structure flexibility.  Statements need to change structural roles.  We are accustomed to thinking about a statement having a fixed structural role.


Logic provides instructions about what content to get.  It may be a script (a few steps to do), a query (a command to find values of a certain kind), or a function (a reusable set of instructions).

Logic processes content to characterize it.  For example, if the content is about the “top” movies this week, the logic does a query to determine and display what the top-grossing films are.  Logic allows computers to make implicit statements, just like writers do, which makes the text sound more natural.

“With content molecules, content is separated not only from the presentation, but from the business logic, that is from the way the content is processed and manipulated.”  Alex Mayscheff

Logic is another way content molecules can bond together.  When logic is applied to statements, logic plays a matchmaking role.

Logic can also be applied to variables.  It can help to decide the right values to include in a statement.

A common example is when a query of a database generates a list.  The query asks the top 10 best selling literary fiction titles, and a statement is returned with 10 titles in a list.

Logic can provide more than simply reporting data.  As software gets smarter, it will be able to make more natural sounding statements.

Consider a simple example.  If we know the gender of a person, we can create new variables indicating the appropriate person pronoun and possessive pronoun to use.  Expressed in pseudocode, it might work like this:


If Person.Gender == Male


    PersonalPronoun -> He

    PossessivePronoun -> His



    PersonalPronoun -> She

    PossessivePronoun -> Her


Logic can summarize variables so they are easier for humans to comprehend.  If we only rely on variables, we have to see the values exactly has they are recorded.   In earlier examples, the variable was directly injected into a statement.  The variable says: When you get here, put a certain value here.

Using logic, a variable can call a function.  The function instructs: When you get here, figure out the appropriate value to put here.  This gives much more flexibility for the scope of values that can be used in statements.

Because the logic is separated from the variables and the statements, we don’t care what form of logic is used.  It might be PHP, Python or Javascript.  Or a query language such as SQL or Sparql.  Or some new AI algorithm.  Developers might combine different programming languages, so that different ones can perform specialized roles.  It is a very different situation than exists when content is encoded in XML, forcing developers to rely on XSLT or some other XML-focused language.

Systematizing What’s Routine

My excursion into the coding of molecular content may give a false impression that writers will need to code in the future.  I hope that is not the case.  Nearly everyone I know agrees that code is distracting when appearing in writing.  Ideally, the separation of concerns means that code won’t appear in statements.

What’s been missing are systems that make it easy for writers to reuse facts (variables), statements (content chunks), and templates (structures).  Systems should let writers add some logic to their writing without worrying about the programming behind it, perhaps by choosing some pre-made “recipes” that can be dragged into text and inserted.  I’ve seen enough different efforts to simplify systems (from Jekyll to IFTTT to automated suggestions) to believe writer-friendly tools to support molecular content are possible.  But new systems emerge only when a large community believes there is a better way.  No one person, or company, can build and sell a new system, much less force its adoption.

When I started out working in the web world, all user interface screens were individually designed.  Each one needed to be crafted and tested individually.  Each screen was a precious creation.  Eventually, the UX community realized that approach was madness.  UX folks weren’t able to keep up with the volume of screens that users needed to see.  And UX staff were recreating the same kinds of screens again and again.  Eventually, the UX community adopted components, patterns and templates.  They created systems that could scale.  Original, new designs are needed only in highly novel situations, such as new device platforms or enabling interaction technology.  The rest can be reused and repeated.

Atomic Design methodology by Brad Frost

UX designers now talk about a concept called atomic design.  Atomic design sounds related to molecular content.

The transformation of UX design is still ongoing, but it’s impressive in what has been achieved already.  One might expect designers would be resistant to technology.  Many studied graphic design in art schools, using colored markers.  When applying their graphics knowledge to web design, they saw the benefits of reusable CSS, adopted plug-and-play Javascript frameworks, and started building component libraries. Much of the progress was the work of various individuals trying to solve common problems.  Only recently have companies started marketing complete solutions for UI component management.  Designers still like to sketch, but they don’t expect screen design to be a manual craft.

I’ve long been puzzled why so many art school grads can happily embrace technology, while so many writers have an anti-technology attitude.  Designers have found how technology can extend their productivity immensely. I hope writers will discover the same.  A craft approach to writing is wonderful for novels, but insane for producing corporate web content.

Most of the original structured writing approaches built in XML are tightly-coupled, resulting in systems that are both inflexible and overly complex.  A more loosely-coupled system, based on a separation of concerns, promises to be more flexible, and can be less complex, since adopters can choose the capabilities they need and are willing to learn.  Designers have benefitted from open systems, such as CSS patterns, Javascript frameworks, and other publicly available, reusable components. Designers can choose what technology they want to use, often having more than one option. Writers need open systems to support their work as well.

—  Michael Andrews