The Google Plus logo

Making the complicated simple: integration of mobile systems within LINEstream

This post first appeared on the LINE blog on 12th September 2012.

LINE’s Senior Technical Architect, Paul Nebel, highlights how effective integration of mobile systems has been key to the development of simple one-click publishing with our new LINEstream product.

When we tap a button on a screen to order a new sofa, or to get information about a flight time, we seldom think about the technologically marvelous thing that is happening in the background. And so it should be. The job of technologists is to make complicated things simple for the user.

Web technology often is very complicated, involving the interaction of many systems and data sources. We live in a world of networks and linked data, where machines talk to each other across undersea cables so that we can check tomorrow’s weather on our iPads before we go to sleep.

In this world, software engineering is less and less about creating the perfect, hermetically sealed program to perform a given task, as perhaps it once was, and more and more about integrating different systems, which may be widely dispersed across a network. This is even more true of mobile than it was in the era of desktop dominance – and in our own industry, the opportunities offered by just-in-time learning on mobile devices are driving a call for more and more instant delivery of content from diverse sources.

This change is seen also in the process of creating and publishing content for learning and communications. We might be used to thinking of an authoring tool as a fairly self-contained thing, but authoring and publishing content for mobile delivery involves a complicated feat of integration. Answering the requirement of clients for usable tools that make this process simple is therefore a considerable challenge – but one that we have risen to with LINEstream.

In search of simple

When we first began to look around at the tools available to do this job, we found nothing that delivered the kind of seamless workflow we knew clients wanted. Though designing and sequencing a set of templated screens might be easy enough to manage, no-one that we could find had succeeded in taking the clunkiness out of the package/build/publish part of the authoring process. You would have to get your vendor involved at various stages, leading to delays (up to five weeks in one example!).

What we set out to do – and achieved – with our LINEstream platform, was to automate the build process in its entirety. No phone calls, no emails to any provider: once you have had your day’s training you can create your package and, with one click, publish it to all your target devices. That was what we knew clients wanted, and that is what LINEstream delivers.

Machine shall talk unto machine …

So what is going on behind this apparent simplicity? I could draw you a diagram, but we would quite soon be into an alphabet city of acronyms, and I would lose the non-technically-minded part of my audience very swiftly. Suffice it to say that there are a number of different entities in this integration map, and they all have to talk understandably to each other. Say it’s a learning program you’re creating: the following notional steps will have to happen within the system:

  • Course designed by learning designer
  • Course previewed by learning designer/stakeholders
  • Content assets (text, images, video) stored and accessed when needed
  • Course built and packaged for different platforms/devices
  • Course published to different mobile platforms as an app
  • Usage statistics and management information collected and sent to a LMS

Each of these steps will involve one or more of these different entities, and they all have to communicate with each other as you move through the process of getting your course out to the user.

In LINEstream, we make this happen through use of something you might well have heard of, called an application programming interface (API). Each of the entities in the system has an API that enables it to talk to the other boxes. It’s my job to write these.

Why am I telling you this, you might well ask? Well the slightly tricky thing about creating a mobile platform at enterprise scale is that not all of the entities will necessarily be part of the authoring platform itself. You might want to use your own content management system (CMS), for instance, or your own Mobile Application Management (MAM) system.

Most people know what a CMS is. Organisations that produce a lot of e-learning often have a great deal of knowledge and development time – as well as content – invested in their CMS. Many have LCMS system that they use to author desktop-delivered e-learning and would like to use those same content assets in their mobile learning. LINEstream has its own CMS if needed, but can operate completely comfortably with a client CMS or LCMS if required, due to its API-driven architecture. This allows clients to leverage the value of their existing investments in learning technology, and avoids costly duplication of systems.

Less people, perhaps, will be quite so familiar with the other acronym I dropped there, MAM. Think of this as the organisation’s own internal App Store: the platform for mobile apps within that company. Again, LINEstream has its own MAM, but it can also use yours.

Hold the front page

I’ve talked about the ability to publish quickly and easily to multiple devices, but what if the thing you’ve published contains mistakes, or needs updating?

Here again, our initial research picked up problems with existing systems. You might have to republish the app afresh, necessitating a new download for users, with a requirement that they delete the previous version – which as we know can lead to problems. With LINEstream, you don’t have to go through this step. Changes are easy to make, and updates will automatically take effect next time the user accesses the app, with no need for a further download. This applies not only to text and images, but also to branding, look-and-feel, the sequence of pages and on-screen functionality.

The benefits of this are obvious. Say you have authored a health and safety app, but a mistake in one piece of text has caused someone to have an accident. The text and images can be changed and republished and the erroneous messages will no longer be pushed out to the workforce.

So fast and easy is this process that it allows iterative development of apps: put the beta out there and see how users react – perhaps in a controlled pilot group – then modify the programme according to user feedback and roll out to a wider group … All without the need for further republishing, and all managed internally: you won’t have to get a LINE employee out of bed in the middle of the night to make the changes.


The forward-looking architecture we have chosen for LINEstream gives us many opportunities for future development. We already have plans to integrate and expose our APIs to enable new forms of integration with existing and emerging systems.

I hope this article has showed how the seemingly dry subject of systems integration becomes considerably less dry when you see the benefits in action. Mine is a great job, where I get to see people’s working lives made easier as a result of what this product team does, and the practice of learning and communications moved decisively forward with the help of technology.