Drupal Universe

Progressively Decoupled Drupal Approaches

Acquia Blogs - Mon, 2017-03-27 16:56

Progressive decoupling, a concept outlined last year in Dries Buytaert’s first post about decoupled Drupal, is a compelling approach to building Drupal's front end where content editors, site assemblers, and front-end developers maintain contiguous experiences.

For content editors and site assemblers, progressive decoupling allows for contextualized interfaces, content workflow, site preview, and other features to remain usable and integrated with Drupal as a whole. For front-end developers, dedicating a portion of the page to a JavaScript framework enables them to pursue their own velocity while keeping site assemblers unblocked.

Fully decoupling the front end from the back end severs many of the important ties between the rendered output of a Drupal page and its data model (including the loss of contextualized interfaces like Quick Edit and layout control). As an alternative, progressive decoupling allows you to continue leveraging Drupal’s rendering system while simultaneously using a JavaScript framework to power client-side interactivity and potentially a richer user experience.

This blog post features some compelling approaches which reflect a wide spectrum of possible ways to implement Drupal in a progressively decoupled fashion without abandoning the things that make Drupal great on the front end. These examples run the gamut between providing for site building even as front-end developers push forward (weather.com), enabling front-end flexibility by pairing Angular with Drupal (Warner Music Group), and using data made available on Drupal-rendered pages to power a single-page application (Acquia’s new Cloud UI).

Here is a graph that illustrates where on the progressive decoupling “spectrum” each approach falls:


Together, these approaches signal an exciting range of possibilities for Drupal that maintains its integrity while making rich user interactions and a more modern front-end developer experience possible.

Contents weather.com: Progressively decoupled panels

At weather.com, the requirement for a contiguous Drupal architecture that preserves full administrative control over page appearance is paramount. But weather.com also harbored a strong desire for highly interactive widgets, such as forecast previews, interspersed within the overall content experience. In short, site builders needed the ability to manage the page’s layout and structure without the aid of a developer, but front-end developers needed an intuitive framework to build interactive experiences into a Drupal-rendered page.

The team building weather.com architected the Presentation Framework to fulfill this need, a Drupal 7 module that integrates Panels panes seamlessly with Angular 1 application components so that they can be manipulated by site builders. However, in order to generalize the solution to be used by frameworks besides Angular 1 and to leverage the new block-based version of Panels in Drupal 8, Matt Davis has been leading development on Decoupled Blocks, a framework-agnostic module which allows JavaScript frameworks to render their components into blocks. Acquia and Mediacurrent recently sponsored a successful collaborative sprint on the project with the Lightning team.

The Decoupled Blocks approach is particularly enticing because of its explicit requirement to forge an equilibrium between site builders manipulating layouts and front-end developers manipulating page behavior. While JavaScript frameworks have reinvented user interactions in applications, this is a step in the right direction toward a rich user experience paired with a similarly capable editorial interface.

Warner Music Group: Rich artist websites

While weather.com’s needs focused on the editorial experience and the ability to assemble pages, Warner Music Group’s needs emphasized the twin requirements of bespoke flexibility and application-like interaction speed. Instead of limiting interactive widgets to solely a section of the page, Warner Music Group’s recent work involves JavaScript’s control of everything on the page between the header and footer.

The primary benefit of this vision is client-side routing which enables an application shell-like experience. In short, the header and footer remain static and are rendered through Drupal. Within the content area, however, Angular is responsible for managing the client-side traversal across routes. The use of client-side routing means that the header and footer never disappear in favor of a full page refresh; only the relevant portions of the page are rerendered.

In Warner Music Group’s implementation of progressive decoupling, led by Arun Manoharan and Jeremy Kutner, Drupal routes comprise a superset of Angular routes, meaning that even if an Angular route is not provided, Drupal can take over as a default fallback. This means that Drupal and Angular exchange responsibility when it comes to routing, whereas all templating takes place within Angular.

Warner Music Group’s progressive decoupling framework frees JavaScript developers to build remarkably interactive pages while leaving intact core elements of content management and employing Drupal as a consistent foundation. The result is more unbridled front-end development that still leverages Drupal as the centerpiece of an overarching content experience.

Acquia Cloud: An Angular app as a Drupal page

On the more ambitious extreme of the spectrum is Acquia's new Cloud UI, which leverages Angular 1 on the front end in a similar fashion to Warner Music Group and weather.com. There is, however, one significant exception. Though Drupal is ostensibly responsible for the initial page load, it renders almost nothing visible on the page — it outputs only the HTML head, a body shell, and JavaScript libraries. This Drupal-rendered page shell gives Angular immediate access to data transmitted via the Drupal.settings object.

Like Warner Music Group’s main content area, the only element present within the page body is the Angular application, which utilizes the state information available in Drupal.settings upon bootstrapping. In this example, Drupal 7 serves as an API proxy that accepts requests from the Angular application and forwards those requests to the Acquia Cloud API, which returns infrastructure information based on authenticated user profiles in Drupal.

The use of the Drupal.settings object as a means of providing initial application state is a graceful solution which abbreviates the time to first interaction with Angular, as the data does not need to be requested from the back end first. Not only does Drupal.settings contain all data required during the initial page load; it also contains translatable strings (normally accessible via Drupal.t) which are made available to Angular’s internationalization system (angular-translate).

The Acquia Cloud UI begins to examine how overtures can be made toward a deeper integration with JavaScript frameworks through clean divisions of responsibility and thoughtful handoffs of information. It’s the impressive work of Mike Pezzi and Chris Carignan, among many others on the Acquia Network team.


All in all, these diverse approaches to progressively decoupled Drupal have one thing in common: their close attention to each use case’s specific requirements. weather.com acknowledged the challenge of balancing editorial needs with user experience needs, while the Acquia Cloud UI team understood that editorial considerations were nonessential to their progress. Warner Music Group’s approach, meanwhile, takes a middle-of-the-road route — ensuring their editors’ continued administrative control but freeing the front-end developer to work in an unbridled way.

Though these are some of the most compelling emergent approaches within the rapidly growing progressive decoupling paradigm, there are still many unanswered questions. For instance, the distance is still stark between development practices in JavaScript frameworks and editorial interfaces in Drupal. JavaScript frameworks presume that front-end developers will have full control over issues such as layout and page structure.

This gap is compounded by the current lack of harmony between Drupal’s own systems and APIs and those found in JavaScript frameworks. For instance, how can we best reconcile the editorial assembly experience and the front-end developer experience when Drupal and JavaScript frameworks undertake such divergent approaches to templating, routing, and rendering? Warner Music Group, for instance, concluded that divergent routing was useful in order to preserve a default superset of routes when a client-side route is unavailable.

While progressive decoupling is an eminently effective method of bringing the two closer together, I’m eager to continue exploring new implementations as we forge an exciting path forward for such distinct but codependent characters in the Drupal story.

Special thanks to Jeremy Kutner, Arun Manoharan, Matt Davis, Mike Pezzi, and Chris Carignan for feedback on this blog post.

Categories: Drupal Universe

Response to conversations about me

Response to conversations about me

It's been an eventful couple of days, that's for sure... Eventful enough that I feel it's necessary to clarify a few points.

First off, I want to express my sincere thanks to everyone that has reached out, in public or in private, to express their support in this situation. I genuinely appreciate it, even if I haven't had a chance to respond to everyone directly. Thank you all.

Larry 27 March 2017 - 12:26pm Personal
Categories: Drupal Universe

Waterwheel, the Drupal SDK Ecosystem

Acquia Blogs - Fri, 2017-03-24 20:10

Special thanks to Kyle Browning for contributions to this blog post.

As Drupal is increasingly widely used as a back end for application ecosystems, developers of wildly diverse backgrounds are now retrieving and manipulating data from Drupal in unprecedented ways. With Drupal 8 and core REST support articulating an API-first vision for the decoupled future, Drupal is eminently well-prepared to back a bevy of applications with divergent approaches. There's just one problem: non-Drupal developers don't know Drupal.

That's where Waterwheel comes in. Waterwheel is an emerging ecosystem of software development kits (SDKs) built by the Drupal community which ease and accelerate development of applications in other technologies. If you will momentarily forgive the flawed metaphor, Waterwheel helps non-PHP and non-Drupal developers "speak" Drupal.

This blog post summarizes the motivations behind SDKs for Drupal-backed applications and how the Waterwheel team has worked to map out a trajectory for Drupal to be utilized not only by PHP and Drupal developers but also by developers of diverse backgrounds who might otherwise have never discovered or considered it.

The API-first CMS

API-first architectures have become increasingly commonplace as the concept of a content management system (CMS) continues to evolve. In the Drupal community, the Web Services and Context Core Initiative (WSCCI) confronted this trend early by providing the means for Drupal 8 sites to expose data for the benefit of other sites. Today, one Drupal back end is capable of powering a wide range of applications, whether ancillary single-page or native applications or other back-end applications.

In the last several years, the widening prevalence of application ecosystems has been greeted by the advent of the API-first or headless CMS (also referred to as decoupled CMS or “content as a service”). These are content management systems which lack front ends — as a rule — because their sole purpose is to export content for retrieval and manipulation by other applications. Examples include services such as Built.io, CloudCMS, Contentful, and Prismic, which all offer paid subscriptions to build and consume an API in the cloud.

These platforms all have one thing in common: Like Drupal, they are platforms that back application ecosystems. But this is only one half of the picture.

SDKs for building applications

The concept of a software development kit (SDK) is not new in web development, and neither is the idea of connecting an SDK to web services in order to power and supply a decoupled application. Headless CMS platforms like those mentioned above share another common characteristic: the maintenance and release of SDKs that accelerate application development. These SDKs are predominantly free and open-source, despite their dependency on a paid subscription to a headless CMS platform.

With Waterwheel, Drupal challenges these headless CMS services by not only offering a robust series of SDKs to assist application developers but also serving as the best free and open-source API-first CMS on the market. To make Drupal’s web services first-class out of the box, the API-first initiative has been driving progress on both core and contributed modules to improve the developer experience of reading and writing Drupal data. Though SDKs are not intrinsically tied to Drupal core development itself, they serve as an integral piece of Drupal-backed application ecosystems.

Currently, consuming Drupal data requires at least a basic understanding of Drupal’s REST API. As such, the shared mission of Waterwheel.js (formerly known as Hydrant) and Waterwheel.swift (formerly known as the Drupal iOS SDK) is to help developers building Drupal-backed applications in JavaScript and Swift query and manipulate Drupal data without having to learn about nuances such as the differences between core REST’s authentication mechanisms or its approach to serializing Drupal data, such as how fields of varied cardinality are exposed as JSON.

Waterwheel.js: Drupal for JavaScript developers

Over the last several months, a small team of developers within OCTO and contributors from the Drupal community have been collaborating on the initial minor versions of Waterwheel.js (formerly known as Hydrant), a helper SDK that aids JavaScript developers who need to query and manipulate Drupal data. Development is being led by Matt Grill, Ted Bowman, and Preston So, and the library is available as a project on NPM.

Because Waterwheel.js contains an HTTP client well-suited for Drupal, it can be employed on the server side to make API calls within Node.js during server-side execution of a JavaScript framework. It can also be used on the client side to make asynchronous API calls after the browser loads the bundled library. In this way, Waterwheel.js can be leveraged universally — the code to provision data can be shared across client and server.

You can incorporate Waterwheel.js on your existing Drupal sites to provide AJAX-like interactions, or you can use it in a manner similar to common HTTP clients in the JavaScript community such as superagent or axios. Moreover, Waterwheel.js is well-positioned for progressively and fully decoupled Drupal sites (fully decoupled usage on a separate domain relies on CORS support available in Drupal 8.2 or adding CORS headers in .htaccess), as it is intended to provide a strong foundation which JavaScript frameworks can build on.

The Waterwheel module is required by Waterwheel.js if you wish to implement resource discovery in your application. Resource discovery allows developers desiring client-side validation against server-side entities and their fields to prepopulate an object containing metadata about what entities and fields are available for retrieval and manipulation. Formerly, Waterwheel.js also supported the Entity Query API module and its query operations (e.g. ranges, sorts, and conditions), but this will be superseded in the next minor version by full integration with the emerging JSON API module, where Entity Query API development has migrated.

In sum, Waterwheel.js is uniquely versatile in that it can be used on both server (Node.js) and client (in the browser) and in progressively decoupled or fully decoupled settings. We’re excited to broaden the feature set currently available in Waterwheel.js, especially for a 1.0.0 release in time for DrupalCon Dublin (see our BoF about Waterwheel).

Waterwheel.swift: Drupal for Swift developers

We are also welcoming the Waterwheel.swift SDK, formerly known as the Drupal iOS SDK and the work of Kyle Browning, into the ecosystem as part of a growing suite of SDKs for Drupal-backed applications. Waterwheel.swift provides full support for consuming Drupal 8's core REST API as well as session management and authentication capabilities for the benefit of Swift applications.

Waterwheel.swift supports iOS, macOS, tvOS, and watchOS out of the box with plug-and-play functionality for each of these platforms. Because it leverages Swift, Waterwheel.swift benefits from massive performance gains over the Drupal iOS SDK’s foregoing Objective-C implementation and takes advantage of Swift’s closures, which means anyone who writes Swift will feel very comfortable using it.

For iOS, for instance, it provides a login button which can be placed in any desired location (or subclassed) and will handle showing a custom LoginViewController. To accelerate development even further, Waterwheel.swift also has a waterwheelLoginViewController that provides username and password fields, thus allowing you to incorporate Drupal login and logout functionality into your Swift application with minimal development time.

In an upcoming update, Waterwheel.swift will add full caching of all requests and objects pulled from Drupal. It will be configurable down to the request or globally, but a default for all requests will be included. A demo application of these features is also included in the GitHub repository.

All in all, Waterwheel.swift makes complex communication with Drupal effortless for Apple-driven applications. Because it is built with Swift, you can take advantage of next-generation coding from Apple at your fingertips, and, like Waterwheel.js, you can use it to communicate with Drupal directly without having to understand Drupal’s REST API.


While headless CMS platforms such as Built.io and Contentful benefit from open-source components in the form of application SDKs, Waterwheel spotlights Drupal 8 as a capable and effective API-first CMS that is entirely free and open-source, from data storage to API provisioning to application SDKs and everything in between. With the advent of Waterwheel, paying toward an expensive platform subscription is no longer required — in fact, the sky’s the limit for your unbridled Drupal-backed application ecosystem.

The story of Waterwheel has only just begun. Our ambitious vision is to build upon the successes of Waterwheel.swift’s wide range of application components and Waterwheel.js’ seamless integration with the Drupal core REST API. The end goal is to furnish an ecosystem of SDKs with two significant advantages: For site builders and editors, you will be able to assemble prefabricated Drupal-backed applications without the aid of a developer. For developers, you will have a robust and battle-tested foundation on which to build application components and accelerate Drupal-backed application development.

For instance, after our initial work on Waterwheel.js, our hope is to facilitate the construction of application components in major JavaScript frameworks such as Angular, Ember, or React which can be easily composed to rapidly create a fully decoupled Drupal-backed single-page application. To learn more and to discuss the eventual vision of the Waterwheel ecosystem as a whole, please join us at DrupalCon Dublin!

In upcoming blog posts in this Waterwheel series, we will explore specifics of each of the available SDKs: some of the features available in Waterwheel.swift and how to build a simple Drupal-backed JavaScript application using Waterwheel.js. We’d like to hear from you too, whether you’re a Waterwheel user, an application developer, or a welcome contributor, as we continue paving the way forward for API-first Drupal.


Special thanks to Kyle Browning for contributions to this blog post. Thanks also to Matt Grill and Ted Bowman for feedback during its writing.

Categories: Drupal Universe

Decoupled Drupal with Ember: Introducing Ember and JSON API

Acquia Blogs - Fri, 2017-03-24 19:48

Decoupled Drupal has long been an approach touted by some in the front-end contingent of the Drupal community to achieve goals such as a better user experience, a more modern front-end developer experience, and clearer separation of concerns. Though I’ve written previously on the risks and rewards of fully decoupling Drupal and a steadily proliferating approach known as progressive decoupling, many of us have already ascertained through our own cost-benefit analyses that decoupling Drupal entirely is the appropriate course of action for our needs.

Not solely because of its open-source ethos and welcoming community, Ember is a prime candidate to underpin Drupal-backed JavaScript applications due to its reach, its coverage, and its ease of use. In this two-part series intended to help you attain escape velocity quickly, we’ll explore the inner workings of Ember, foundational concepts of Ember's ecosystem, how to decouple Drupal with an Ember front end, and what the future could bring in terms of more Ember within Drupal. By the end, we’ll have assembled a simple Drupal content browser powered by Ember.

What is Ember?

The Ember community describes its flagship framework as an "SDK for the web." Ember is an opinionated JavaScript framework which values convention over configuration — that is, a common set of practices rather than explicit settings. For this reason, Ember has significant advantages over other common JavaScript frameworks due to its large extent of standardization, including a codified directory structure for all applications (simplifying on-boarding) and a clear and interoperable approach to templating.

Ember is a successor of the SproutCore project, which encompassed both an application framework and widget library. In 2011, the SproutCore 2.0 application framework was rechristened Ember to disambiguate it from the SproutCore widget library.

The Ember community’s stated focus is on “ambitious” web applications which approximate a native application’s user experience as closely as possible. Ember is distinguished from other JavaScript MV* frameworks due to its high level of opinionatedness, which makes it less ideal for smaller view-focused applications or implementations requiring customizability across every layer of the framework. From the cultural standpoint, much like Drupal, Ember is not as shepherded or as spearheaded by large corporate giants as are Angular and React.

What is JSON API?

JSON API, an emerging specification for REST APIs in JSON that dubs itself an “anti-bikeshedding tool,” has recently gained traction because of its adoption by developers in the Ember and Ruby on Rails communities and its robust approaches to resource relationships and common query operations such as pagination and sorting. Thanks to the indefatigable Mateu Aguiló Bosch, the JSON API module is nearing inclusion in Drupal 8 core as an experimental module.

For the purposes of this application, we will be using JSON API, because Ember’s data framework comes with a built-in adapter (see second part in this series for more on adapters) which fits JSON API like a glove. While there are other adapters available for other approaches, our prerogative in this tutorial is to ramp up as quickly as possible. For more insight into the role of JSON API in Drupal core, refer to Dries Buytaert’s recent API-first update.

The Ember ecosystem

While Ember can be employed on its own as a client-side framework without any need for extensibility, there exists a larger surrounding ecosystem of ancillary tools of varying utility. Some of these are maintained by the Ember core team with others and are considered part of the typical starter toolkit for Ember. Others are community-built plugins, analogous to Drupal’s contributed modules, which confer additional or extended functionality.

  • Ember CLI has a stated mission to bring convention and configuration to Ember’s build tools. Not only can you quickly generate a new Ember application having the default stack through Ember CLI’s blueprints, you also have access to other useful tooling such as ES6 transpilation which is frequently more do-it-yourself in other frameworks. Moreover, Ember CLI provides a local development server with built-in live reload, a complete testing framework, asset management, and dependency management.
  • Ember Data is a data persistence library which maps client-side models to server-side data. Though you don’t need Ember Data to use Ember, the majority of Ember applications do utilize it to load and save records and relationships. If your REST API adheres to the JSON API specification, Ember Data is capable of performing data operations without additional configuration.
  • Ember Inspector is a browser extension available for Google Chrome and Mozilla Firefox which provides helpful functionality to debug Ember applications. At any point during the application’s bootstrap, you can identify which templates and components are being rendered. If you’re using Ember Data, Ember Inspector also has access to the records loaded for each Ember model (see part two for more about models).
  • FastBoot is an add-on to Ember CLI which provides server-side prerendering for Ember applications built on a Node.js stack. This enables JavaScript isomorphism — shared code across client and server — which significantly improves performance on initial page load.
  • Liquid Fire is an add-on which provides a declarative approach to building animations and transitions into your Ember application.
Setting up Drupal as a data service

In order to build a Drupal-backed Ember application, which I’m naming “Waterfire” here, we will first want to acquire the most current version of Drupal. The easiest way to accomplish this is to clone the GitHub repository, which grants the added ability to track changes diachronically. The default branch will be 8.3.x; we will need 8.2.x at minimum, as we’ll see shortly.

$ mkdir waterfire-drupal && cd waterfire-drupal
$ git clone git@github.com:drupal/drupal.git
$ cd drupal
$ composer install

After we’ve installed dependencies using Composer, as seen in the final command above, we can now import the local site through a local development tool such as Acquia Dev Desktop and install Drupal normally (or via Drush). Keeping things simple, I’ve named my Acquia Dev Desktop site waterfire-drupal.dd.

To keep the pace up, we’ll be introducing Drupal content entities using the Devel module, whose Devel Generate submodule provides a handy set of commands to perform Drupal actions such as adding dummy nodes (drush genc 20) and users (drush genu 20).

$ drush dl devel
$ drush en -y devel
$ drush en -y devel_generate
$ drush genc 20
$ drush genu 20 Configuring Drupal for JSON API

Next, we will need to enable the JSON API module in order to access its features, as well as to configure those REST resources representing content entities to be exposed through JSON API rather than the default HAL normalization.

$ drush dl jsonapi
$ drush en -y jsonapi

In order to expose content entities as JSON API, we’ll need to configure REST resources using the corresponding configuration entities, which is the new way to access REST configuration as of Drupal 8.2.x. For the purposes of this walkthrough, I’ll be using Atom, an open-source code editor built in Electron. First, we’ll open an example YAML file available within the core REST module as a template for configuration imports.

$ atom core/modules/rest/config/optional/rest.resource.entity.node.yml

Add jsonapi as a dependency under module, and add api_json, used by the JSON API module, to formats. At the end, your configuration import should look like the following. For security purposes, you may not want to allow JSON API consumers to perform requests with all of the HTTP methods.

langcode: en
status: true
    - basic_auth
    - hal
    - jsonapi
    - node
id: entity.node
plugin_id: 'entity:node'
granularity: resource
    - GET
    - POST
    - PATCH
    - DELETE
    - hal_json
    - api_json
    - basic_auth

This has only allowed us to configure node resources. Eventually, our Waterfire application will also include users, which are also content entities. As such, we can provide an additional configuration import which looks as follows:

langcode: en
status: true
    - basic_auth
    - hal
    - jsonapi
    - user
id: entity.user
plugin_id: 'entity:user'
granularity: resource
    - GET
    - POST
    - PATCH
    - DELETE
    - hal_json
    - api_json
    - basic_auth

Now, navigate to /admin/config/development/configuration/single/import in your Drupal site to submit both of these configuration imports. Afterwards, if you navigate to /api/node/article?_format=api_json and /api/node/page?_format=api_json, you’ll see a complete list of articles and pages, respectively. You’ll discern that the URL naming reflects the pattern [entity_type]/[bundle]. Because users lack bundles, the entity type name is repeated, and the resources are available at /api/user/user?_format=api_json.

Finally, another crucial step is to allow applications from other domains to implement HTTP methods against our Drupal site through cross-origin resource sharing (CORS). Opt-in CORS support is available via configuration in Drupal 8.2, but Sally Young’s CORS module is the easiest way to accomplish the same task for the more visually oriented (like yours truly!).

$ drush dl cors
$ drush en -y cors

You can then navigate to the “CORS” page under the “Configuration” section of your Drupal site (/admin/config/services/cors) and add a list of allowed domains. These are pipe-separated rows — the first element being the paths other domains can access, and the second being the domains access is granted to.


Eventually, our Ember local development environment will serve our application at http://localhost:4200[/codefilter_code]. For security purposes, we are restricting the paths that other applications can perform requests against to the namespace /api/*, employed by the JSON API module. Finally, because we have modified configuration extensively, we rebuild our caches.

$ drush cr Setting up Ember

To set up Ember quickly and leverage the broader Ember stack, we’ll need to have Ember CLI available. We can use NPM to install Ember CLI globally before creating a new Ember application. The ember new command will scaffold a directory structure and initialize a new Git repository within a folder having the name you supply as an argument.

$ npm install -g ember-cli
$ ember new waterfire-ember
$ cd waterfire-ember

To check that everything has installed correctly, try booting the Ember server using the command below and navigate to http://localhost:4200[/codefilter_code]. If you see Tomster with a friendly welcome message and a hard hat perched on his head, you’ve successfully created your first Ember application. We’ll need to use this command frequently to interact with our application.

$ ember server

Finally, let’s generate our first template, which is the root template of the application. This means that all other templates will be nested within this all-encompassing application template, which is the entry point to our application and also represents the index or home route. We can then open the application template using Atom to provide some output which replaces Tomster.

$ ember generate template application
$ atom app/templates/application.hbs Ember templates

Ember uses the Handlebars templating language for its templates, which will look somewhat familiar to users of Twig in Drupal, though the two are substantially different. These templates are responsible for displaying properties made available to the template’s context, which can either be a component or a route. The characteristic double curly braces can also include other helpers and components (we will work with the latter in due course).

In our application template, we can insert some initial markup which represents the header of our new Ember application. {{outlet}} represents templates which are nested within the current template. In other words, any templates deeper within our application will “shine through the window” and be visible through the outlet. {{! some text }} represents a Handlebars comment.

{{! app/templates/application.hbs }}
{{outlet}} Ember routes

In Ember, application state is represented by a URL, which is tied to a route object controlling what the user sees. Ember routes encompass templates as well as route handlers, which render templates and load models made available to the template for use.

Our Waterfire content browser will allow us to browse nodes of type article and basic page as well as users, so we will want to create routes for each. Let’s start off with articles. As an aside, many commands in Ember CLI have shorthands; g here is short for generate.

$ ember g route articles
$ atom app/templates/articles.hbs

In the template, insert the following.

{{! app/templates/articles.hbs }}
<h2>List of articles</h2>

When you navigate to http://localhost:4200/articles[/codefilter_code], you will now see the “Waterfire” first-level heading above a “List of articles” second-level heading. Now that the template is functional, we’ll need to provide some data in the route handler.

$ atom app/routes/articles.js

As you’ll see in the code editor, Ember CLI’s generation tool has used available blueprints as a means to generate some initial code for us to proceed quickly. Below, we’re providing some dummy data as an array into the model hook (see second part for more on model hooks).

{{! app/routes/articles.js }}
import Ember from 'ember';
export default Ember.Route.extend({
  model () {
    return ['Article #1', 'Article #2', 'Article #3'];

If you have worked with JavaScript in the past but not the increasingly well-supported ES6, you may be flummoxed by some syntactic features in the foregoing example. First, the example uses ES6 modules, which grants distinct JavaScript files access to methods and functions defined within others. Second, it makes use of concise method names in place of traditional method definitions in JavaScript which would require an anonymous function as the value of an object property (model: function () { } in lieu of model ()).

Now that we have supplied a dummy model consisting of three filler articles within our articles route handler, we can now iterate over this array within our articles route template.

{{! app/templates/articles.hbs }}
<h2>List of articles</h2>
  {{#each model as |article|}}

The resulting HTML at http://localhost:4200/articles[/codefilter_code] will consist of our familiar headings and, beneath, an unordered list of our dummy articles.

A simple Ember component

Ember components are reusable and nestable. They are typically comprised of a Handlebars template, which describes a component’s presentation, and a JavaScript file, which articulates its behavior. In our current state, while we have written a template for articles, it would be quite tedious and less maintainable to use the same template repetitively for pages and users too.

That’s where a component comes in. Let’s generalize our articles template so it can be used to harness all content entities. If you are familiar with the Custom Elements specification proposed by the W3C, some aspects of Ember’s approach to components will seem old-hat.

$ ember g component entity-list

Within our template, copy the contents of the articles template and provide some more generic code, starting with the title, which will need to change based on how the component is used.

{{! app/templates/components/entity-list.hbs }}
  {{#each entities as |entity|}}

Then, within the articles template, replace everything with a reference to our new “entity-list” component. Just like the Custom Elements specification dictates, in Ember, all component names must be hyphenated for the sake of forward compatibility.

{{! app/templates/articles.hbs }}
{{entity-list title="List of articles" entities=model}}

The other routes can then use this component. We can generate new routes and edit the templates and route handlers accordingly. First, generate the “pages” and “users” routes:

$ ember g route pages
$ ember g route users

Insert Handlebars code into both templates which reflects the use of the component:

{{! app/templates/pages.hbs }}
{{entity-list title="List of pages" entities=model}} {{! app/templates/users.hbs }}
{{entity-list title="List of users" entities=model}}

Finally, update the route handlers with dummy data.

// app/routes/pages.js
import Ember from 'ember';

export default Ember.Route.extend({
  model() {
    return ['Page #1', 'Page #2', 'Page #3'];
}); // app/routes/users.js
import Ember from 'ember';

export default Ember.Route.extend({
  model() {
    return ['User #1', 'User #2', 'User #3'];

Now that we have these routes available, we can flesh out our root application template by providing supplemental navigation to improve the usability of our application.

{{! app/templates/application.hbs }}
<h1>{{#link-to 'index'}}Waterfire{{/link-to}}</h1>
  <li>{{#link-to 'articles'}}Articles{{/link-to}}</li>
  <li>{{#link-to 'pages'}}Pages{{/link-to}}</li>
  <li>{{#link-to 'users'}}Users{{/link-to}}</li>
{{outlet}} Conclusion

In the first part of this tutorial series, we’ve delved into Ember, JSON API, and the Ember ecosystem. We’ve also spelunked into the depths of the Ember software stack, erected a Drupal site as a data service, and circumnavigated some of the key elements which constitute a standard Ember application. In setting up Ember and generating routes, we’ve gleaned that Ember routes typically consist of a route template and route handler.

In the second part of this tutorial series, we’ll explore Ember models and the model hook, connect our Ember application to Drupal, fetch data from Drupal’s JSON API implementation, and access the properties available within JSON API resources. Finally, we’ll zoom out to 30,000 feet and examine more critically some questions about Drupal’s front-end outlook and what role Ember could play therein.

This is a two-part series adapted from the DrupalCon Dublin session “Decoupled Drupal and Ember”. The second part is available here.

Categories: Drupal Universe

Acquia and Magento Team Up for the Future of Content and Commerce [VIDEO]

Acquia Blogs - Fri, 2017-03-24 19:17

At Acquia Engage, Acquia and Magento formally announced their commerce partnership, but in reality, the two companies had been working together for a long time.

Magento is one of the most popular commerce platforms available today. Acquia and Magento are part of innovative and passionate open source communities and contribute to the respective movements. Acquia and Magento have strong open source roots and a focus on open APIs. Open APIs are the fundamental architectural decision for tomorrow’s systems. Through this collaboration, both companies have seen that the need for content and commerce is pressing for almost every industry.

This is not your older brother’s eCommerce anymore - Mark Lavelle, CEO of Magento

Commerce is all about customization; this ramped up when multi-channel commerce experiences began gaining in popularity. There is now a complexity that puts pressure on the basics of order management with multiple points for the order (ship to store / in store pickup vs. home delivery for example) and multiple ways to interact with the customer. The experience starts from when they first visit a site and doesn’t end until they have the product in hand.

The partnership between Magento and Acquia is a perfect marriage of what is needed for cutting-edge commerce experience. Acquia, with tools like Acquia Lift that provide content syndication and personalization, helps customers along their journey, but ultimately a transaction needs to be made at the end. That’s where Magento comes in.

In the video below, watch Acquia CEO Tom Erickson and Magento CEO Mark Lavelle talk about the partnership between Acquia and Magento and what’s next for content and commerce.

Categories: Drupal Universe

Mother of All Demos II: Automating Website Changes with 'Pipelines'

Acquia Blogs - Thu, 2017-03-23 19:46

One of the highlights of Acquia Engage is when Chief Product Officer Chris Stone and his team of engineers demo Acquia products and give attendees a preview of what is on the horizon. Dubbed “The Mother of All Demos,” this presentation showcases the best of Acquia’s products and offers insight into the future of the company, not just Acquia’s product offerings.

Part of what makes Acquia product presentation so special every year are the live demos of what Acquia’s engineering team has been working on. At Acquia Engage 2016, one of these new tools -- nicknamed “Acquia Pipelines”-- was demoed by Chief Software Architect Barry Jaspan.

“Pipelines” is a tool for automating functions like building, testing and deploying your websites on Acquia Cloud. When you want to make a change to your website, like add a new feature or fix a bug, the process starts with a developer writing some code. When the code reaches a stable point, they commit that code to a code repository. Previously, when a developer committed the code to the code repository, either nothing would happen to it or it would be immediately deployed on Acquia Cloud. This meant that any process that you wanted to run on that code before it was deployed had to run manually by developers on their individual machines.

With a tool like “Pipelines,” you define a process that you represent in code that specifies what you are going to do to the code before it gets deployed. This includes things like transforming the code and validating it’s correct; making sure it’s the code you want before deploy it. “Pipelines” ensures that as your developers are working and writing new code, they are operating in the a consistent manner, using the same process to test and validate code so any errors that occur get notified back to the developer very quickly.

For more on “Pipelines” and to see it in action, watch Barry’s presentation and demo below:

Categories: Drupal Universe

Decoupled or Headless or API-First Drupal

Acquia Blogs - Thu, 2017-03-23 18:59

Not even three months into 2017, and already two industry articles have appeared that claim that this is "the Year of Decoupled."

If so, this is propitious development for Drupal, and the Acquia Developer Center. Because we've been publishing "decoupled"-related (AKA "headless," AKA "API-First") thinking for a while now.

Wouldn't it make sense to start organizing it into one stream? That's what we thought.

So here's our first installment of a blog series that will point to some of the best thinking on decoupled in general, and decoupled Drupal in particular.

We're starting with a short blog series by Preston So, Development Manager, Acquia Labs: Decoupled Drupal and Ember.

Although Preston mentions at the outset that there are trade-offs that come with decoupling, he addresses these two posts to developers who have determined that decoupling Drupal entirely is the appropriate course of action for their needs.

In this case, Preston recommends Ember as a prime candidate to underpin Drupal-backed JavaScript applications, primarily due to its reach, its coverage, and its ease of use. It also has an open-source ethos and a welcoming community. His two-part series is intended to help readers attain escape velocity quickly, by exploring the inner workings of Ember, foundational concepts of Ember's ecosystem, how to decouple Drupal with an Ember front end, and what the future could bring in terms of more Ember within Drupal. By the end of the series he's assembled a simple Drupal content browser powered by Ember.

You can access both posts here: Decoupled Drupal and Ember.

Or check 'em out one at a time:

Also, on the decoupled tip: Check out the brand new ebook from Acquia: API-First Drupal: On the Road to Publish Once, Access Everywhere. It's a solid intro, with four different case studies illustrating different use cases. A great overview, and a valuable asset to circulate to non-technical colleagues. 


Categories: Drupal Universe

TMI About me

TMI About me

Recently, I've become aware of a whisper campaign going around the Drupal world, discussing details about my personal life. I do not know where it started or who all has been part of it. However, it's become apparent that it's not going to settle down, and has now had a major, direct impact on me and my professional career. Only a few people have bothered to speak to me directly, but there's been enough back-chatter that I feel I have no choice but to clarify some private details about me, in public, and address the actions of some fellow members of the Drupal community.

Larry 22 March 2017 - 4:49pm Personal
Categories: Drupal Universe

Vacation with Drupal: Showcase of Travel and Tourism Websites

Acquia Blogs - Wed, 2017-03-22 15:46

Drupal can help businesses across any industry create rich digital experiences. With benefits like scalability, responsive design out-of-the-box, flexible API-first architecture, and one of the largest open source communities, it’s no surprise that more than one million sites trust Drupal today.

One of our agency partners, Miles, specializes in creating forward-looking websites for destination and hospitality businesses. By creating rich digital experiences for its clients, Miles is inspiring travel and enabling customers’ business success.

Drupal and Acquia Cloud allow us to build and deliver amazing travel destination sites rapidly that can also handle the scale of visitors throughout the busy travel season. - Andrea Wood, Vice President of Marketing at Miles.

If you’re already using Drupal or planning to use Drupal as a CMS to power your travel or tourism site, here are just a few examples of how other businesses in this space are using Drupal, inspired by Miles’ customers. You may even come across a couple of places you’d like to visit as well.

TravelWyoming.com: Module-Based Approach and Industry Extranet

TravelWyoming.com embodies the natural beauty and untamed spirit of the West, pairing grand visuals with thoughtful content that taps into the mindset of those seeking their next great adventure. Easy-to-access planning information pulls site visitors down the travel funnel from high-level inspiration to actual booking, and because the site is responsive, it can move with visitors anywhere, on any device.

Working closely with the Wyoming Office of Tourism, the Drupal developers at Miles focused on allowing content to drive the page layouts for TravelWyoming.com — instead of the template-driven approach taken on by many other sites. The flexibility to create campaign and content pages was key because the site’s focus is to showcase the new “That’s WY” brand while driving partner referrals. Through a module-based approach, the responsive website includes the flexibility to create whatever page layout best tells the story for any given piece of content.

Additionally, Miles developed an Industry Extranet solution that gives Wyoming Office of Tourism’s industry partners a robust, easy-to-use platform for updating listing information on the site, as well as the ability to submit other rich content assets such as photos, videos and article ideas. Partner updates are connected to Drupal through an API for a seamless share of data.

GoToBermuda.com: Taxonomy Powered and Node Referenced Content Delivery

Visit Bermuda
The new, visually rich GoToBermuda.com is a fully responsive website designed to reflect the destination’s new brand, convey Bermuda’s story on any device, connect visitors to on-island tourism partners and enable Bermuda Tourism Authority (BTA) staff to easily administer the site.

Tapping into the allure and intrigue of the new brand, a robust collection of rich, brand-aligned feature content — articles, listicles, itineraries and videos — connects users to local insights and island experiences. The sophisticated, visually stunning site was designed with a mobile-first approach and makes use of eye-catching elements like cinemagraphs.

The developers at Miles leveraged Drupal’s taxonomies and node reference capabilities to make content recommendations that encourage deeper content exploration on the site. Taxonomies are used to make related content recommendations on interest-based landing pages, regional-landing pages and editorial pages. Node references are used on editorial pages to power Google maps showing related tourism businesses, and a reverse lookup of those same node references on tourism business pages show where those businesses have been mentioned on editorial pages around the site. GoToBermuda.com is freely and easily managed by BTA’s tourism staff.

ThePalmBeaches.com: Component-Driven Design with Drupal

Palm Beach County, Florida, is a diverse destination providing visitors with a wealth of experiences, many of them unexpected. ThePalmBeaches.com promotes engaging experiences and trip ideas in bold new ways.

Through close collaboration with Discover The Palm Beaches, Miles took a component-driven approach to developing ThePalmBeaches.com on the Drupal CMS. This allows Discover The Palm Beaches staff the flexibility to easily manage content and seasonal promotions. For example, inspirational landing pages were developed for showcasing the diversity and beauty of the location, while allowing for video assets to be in the forefront. (Palm Beach County is a large region that encompasses a variety of destinations, and this is especially useful for telling each city’s unique story.)

The site’s responsive format is core to capitalizing on organic traffic and focusing media campaign traffic, which is now more often viewed on mobile devices than desktop.

VisitStPeteClearwater.com: 360 Video Portal

Visit St. Pete
On VistiStPeteClearwater.com, you’ll find a Visit St. Pete/Clearwater 360° Video Portal that brings together the destination’s library of virtual reality videos, created to inspire travelers at the “dreaming” stage of vacation planning.

This dedicated section is designed to enable users to move fluidly from video to video, encouraging them to immerse themselves in 360° video content in one seamless experience — ultimately giving them a preview of things to see and do in the area. Like the website, the portal is fully responsive so potential visitors can watch the videos and navigate through the section on any device and any browser — a first for a destination marketing organization (DMO) in the United States.

The videos also connect viewers to planning content — dedicated articles about the experience that answer questions users may be looking to answer after watching the video like the best time to visit to have the experience, and what attractions or things to do that are nearby.

Michigan.org: Roadtrippers Integration

Visit Michigan
When it came to powering business listings on the new Michigan.org, the Michigan Economic Development Corporation (MEDC) had an extensive point-of-interest database for tourism-related locations in the state, but lacked a tactical planning tool that could help users move beyond the inspiration phase of traveling. To that end, the MEDC and Miles partnered with Roadtrippers to leverage their excellent product — more than 12 million points of interest across thousands of categories — which fulfilled that exact need.

The solution was a shopping-cart-type widget that can add locations from Michigan’s POI database and map that to Roadtrippers’ POI database. This allows users to search and find the places they want to visit in Michigan, and then send that information to Roadtrippers, where users can then execute more functional, travel-related features such as calculating total trip distance, manipulating the itinerary, calculating gas cost, etc.

Hopefully these examples will give you some fresh ideas when building your own travel and tourism digital experience on Drupal (or even planning your future vacation destination). For more examples of innovative travel and tourism websites, check out our friends at MilesPartnership.com.

Categories: Drupal Universe

How the YMCA uses Drupal to accelerate its mission

Acquia Blogs - Fri, 2017-03-17 17:00

The YMCA is a leading nonprofit dedicated to strengthening communities through youth development, healthy living and social responsibility. Today, the YMCA serves more than 58 million people in 130 countries around the world. The YMCA is a loose federation, meaning that each association operates independently to best meet the needs of the local community. In the United States alone, there are 874 associations, each with their own CEO and board of directors. As associations vary in both size and scale, each YMCA is responsible for maintaining their own digital systems and tools at their own expense.

In 2016, the YMCA of Greater Twin Cities set out to develop a Drupal distribution, called Open Y. The goal of Open Y was to build a platform to enable all YMCAs to operate as a unified brand through a common technology.

Features of the Open Y platform

Open Y strives to provide the best customer experience for their members. The distribution, developed on top of Drupal 8 in partnership with Acquia and FFW, offers a robust collection of features to deliver a multi channel experience for websites, mobile applications, digital signage, and fitness screens.

On an Open Y website customers can schedule personal training appointments, look up monthly promotions, or donate to their local YMCA online. Open Y also takes advantage of Drupal 8's APIs to integrate all of their systems with Drupal. This includes integration with Open Y's Customer Relationship Management (CRM) and eCommerce partners, but also extends to fitness screens and wearables like Fitbit. This means that Open Y can use Drupal as a data repository to serve content, such as alerts or program campaigns, to digital signage screens, connected fitness consoles and popular fitness tracking applications. Open Y puts Drupal at the core of their digital platform to provide members with seamless and personalized experiences.

Philosophy of collaboration

The founding principle of Open Y is that the platform adopts a philosophy of collaboration that drives innovation and impact. Participants of Open Y have developed a charter that dictates expectations of collaboration and accountability. The tenets of the charter allow for individual associations to manage their own projects and to adopt the platform at their own pace. However, once an association adopts Open Y, they are expected to contribute back any new features to the Open Y distribution.

As a nonprofit, YMCAs cannot afford expensive proprietary licenses. Because participating YMCAs collaborate on the development of Open Y, and because there are no licensing fees associated with Drupal, the total cost of ownership is much lower than proprietary solutions. The time and resources that are saved by adopting Drupal allows YMCAs around the country to better focus on their customers' experience and lean into innovation. The same could not be achieved with proprietary software.

For example, the YMCA of Greater Seattle was the second association to adopt the Open Y platform. When building its website, the YMCA of Greater Seattle was able to repurpose over a dozen modules from the YMCA of the Greater Twin Cities. That helped Seattle save time and money in their development. Seattle then used their savings to build a new data personalization module to contribute back to the Open Y community. The YMCA of the Greater Twin Cities will be able to benefit from Seattle's work and adopt the personalization features into its own website. By contributing back and by working together on the Open Y distribution, these YMCAs are engaging in a virtuous cycle that benefits their own projects.

The momentum of Open Y

In less than one year, 18 YMCA associations have committed to adopting Open Y and over 22 other associations are currently evaluating the platform. Open Y has created a platform that all stakeholders under the YMCA brand can use to collaborate through a common technology and a shared philosophy.

Open Y is yet another example of how organizations can challenge the prevailing model of digital experience delivery. By establishing a community philosophy that encourages contribution, Open Y has realized accelerated growth, feature development, and adoption. Organizations that are sharing contributions and embracing collaboration are evolving their operating models to achieve more than ever before.

Because I am passionate about the Open Y team's mission and impact, I have committed to be an advisor and sponsor to the project. I've been advising them since November 2016. Working with Open Y is a way for me to give back, and it's been very exciting to witness their progress first hand.

If you want to help contribute to the Open Y project, consider attending their DrupalCon Baltimore session on building custom Drupal distributions for federated organizations. You can also connect with the Open Y team directly at OpenYMCA.org.

Categories: Drupal Universe

Phase2 and Acquia Partner to Show Drupal in its Best Light

Acquia Blogs - Thu, 2017-03-16 19:42

Phase2 is a digital agency moving industry-leading organizations forward with powerful ideas and executable digital strategies built on open technology. They are experts at building and designing websites, applications, and digital platforms that position clients to engage with their target audiences in any channel, on any device, wherever they may be. Phase2 has been recognized for effectively integrating Drupal into organizations in order to improve, impact, and even transform them.

Based in Washington D.C. with offices in NYC, Portland and San Francisco, Phase2 works across many different industries, including consumer brands, high tech, healthcare, media and entertainment, sports, non-profit, and government.

Throughout Drupal’s history, Phase2 has played an important role, as a leader in the community, contributing valuable modules and distributions. Specifically, Phase2 was integral to the digital transformation within the Federal government, helping early adopters to begin using Drupal as their platform through the creation of the OpenPublic Drupal distribution. Most recently, contributing significantly to the release of Drupal 8 with patches to the core code, fundraising, and launching Memorial Sloan Kettering Cancer Center’s new platform on Drupal 8 as one of the first enterprise sites to launch on Drupal 8.

Phase2 appreciates the value of a trusted partner. With Phase2’s long view approach to digital experience solutions, combined with Acquia’s robust suite of products, organizations like Al Jazeera Media Network, Weight Watchers, and Johnson & Johnson are empowered by future focused solutions that are designed for flexibility and growth.

We think Acquia provides a sort of leveling up of Drupal against proprietary tools like Adobe, and gives customers more of what they are looking for in a platform - Jeff Walpole, CEO and co-founder of Phase2

In the video below, Jeff and Frank Febbraro, co-founder and CTO of Phase2, discuss how Drupal and their partnership with Acquia helps them aid their clients with digital transformation and changes the way those clients provide digital experiences to their users.

Categories: Drupal Universe

Mother of All Demos II: The Future of Acquia Cloud

Acquia Blogs - Thu, 2017-03-16 19:18

One of the highlights of Acquia Engage is when Chief Product Officer Chris Stone and his team of engineers demo Acquia products and give attendees a preview of what is on the horizon. Dubbed “The Mother of All Demos,” this presentation showcases the best of Acquia’s products and offers insight into the future of the company, not just Acquia’s product offerings.

Cloud is arguably Acquia’s best known product. At Acquia Engage 2016, Senior Director of Product Will Eisner walked attendees through the latest Acquia Cloud features and what’s next on the Cloud roadmap.

New Acquia Cloud UI

The Acquia Cloud presentation kicked off with the debut of the new Cloud UI. This new web experience is more responsive, faster, and API-first. The new Cloud UI was designed with customer feedback in mind. The most important activities are now up front and accessible, such as the environment drill-down screen.

Update: Since this presentation, the new Cloud UI has been made available to all customers.

Acquia Cloud Site Factory Stacks

Acquia Cloud Site Factory offers a simple process for duplicating sites and provides unprecedented control over hundreds or thousands of sites from a single dashboard. It’s a great tool for digital platform owners who want to view, manage and create a set of sites running on a common infrastructure and code base, or “stack.” However, there have been situations where customers have needed the option to have more than one stack. For example, some customers might have sites deploying a Drupal 7 code base, but want to start spinning up sites from a Drupal 8 code base as well. This is where stacks comes in.

Acquia Cloud Site Factory Stacks gives customers the option to deploy multiple stacks -- each consisting of multiple sites, a platform codebase and dedicated cloud resources -- from a single console.

On Demand Environments

One of the benefits of Acquia Cloud is the availability of non-production environments for the purposes of build and test. They are production-like, which is important because when you deploy to production you can deploy with confidence.

What’s next for Acquia Cloud is dynamic on-demand environments. Within the familiar Acquia Cloud experience, you will be able to create additional environments very rapidly -- in a matter of minutes -- which look and work just like Acquia environments you’d expect. The ability to create new environments quickly opens up new use cases for customers, for example, feature branch development or automated testing on production-like environments.

Watch Will’s presentation and demo below:

Registration is open for Acquia Engage 2017. For more info or to register, please visit https://engage.acquia.com/

Categories: Drupal Universe

ACSF + Lift: Managing Multilingual and Global Sites

Acquia Blogs - Wed, 2017-03-15 17:29

This is part four of a four part series on Acquia Cloud Site Factory and Acquia Lift.

We truly live in a global economy and it’s extremely rare to find an enterprise-level organization that doesn’t have a global presence. Managing an omnichannel presence can be challenging in one geography, let alone across the globe. Regional, regulatory, or business subdivision requirements will require different sets of site features and flexibility. Content not only needs to meet the rules and regulations set for your industry by country, but there are also multiple languages to consider. Using a multisite digital experience management platform like Acquia Cloud Site Factory paired with Acquia Lift can help you manage your global presence more efficiently.

Acquia Cloud Site Factory allows you to create templates or “starter sites” that can then be tailored around various regional, regulatory, or business sub-division requirements. For example, if you are a pharmaceutical company looking to deploy a number of global sites, you need to factor in that what you can show on your product’s website will differ from country to country, depending on the country’s regulations. In this case, you can create a template for the U.S. that is a different template for say, Europe. You can then spin out your U.S. sites under one template and all of your European sites from the other, allowing all of the sites under both of those themes to be maintained with the same underlying code base for faster updating.

Then, by using Acquia Lift, you can update common corporate content across your portfolio of sites and share local content with the central repository, which allows you to keep a record of all content across the network. With multilingual entity translation support, after you translate a piece of a content from say, English to French, the French version can be linked to the English version and all other versions of that content. All content from your network of sites can now be available to distribute, update, and reuse globally.

Content is what differentiates your brand from your competitors, and what keeps your customers coming back. But how you manage content differs from how you manage your sites globally. Content needs to stay fresh, it needs to be relevant to your audience, and it needs to be useful, interesting and/or informative. It also needs to follow specific regional regulations depending on where that content will live. The only way to efficiently manage content across a global network of sites is by automating the process. Content pulled into a repository like Acquia Lift’s content hub makes it easier to search for, manage, personalize and syndicate across the appropriate sites and channels, reducing the previously manual tasks of updating or searching for content site by site.

Categories: Drupal Universe

Drupal 8’s Unfair Advantage: 10 Reasons to Standardize on Drupal

Acquia Blogs - Mon, 2017-03-13 17:59

Today, more than 1 million sites are built on Drupal including Princess Cruises, NBC Sports, The Economist and Commonwealth Financial Network. Drupal is one of the largest open source projects and one of the most widely adopted content management systems, powering digital experiences and driving business digitalization for organizations and their brands worldwide.

The latest, most advanced version of Drupal, Drupal 8, offers a powerful tools with more than 200 new features and improvements – it’s the most flexible version of Drupal ever, built for a new generation of content-centric experiences. New “minor” releases (8.x) are issued every six months to roll out new features and functional improvements to help organizations deliver their experiences faster. Drupal is able to respond incredibly fast to market needs because of this.

Standardizing on Drupal certainly doesn't mean every single site needs to be on Drupal. Drupal “plays nice” in heterogeneous environments lowering the impact on IT in terms of integration support, migration strategy and overall support.

But what’s really behind the success of Drupal 8? It’s impossible to pin down just one factor, so let’s take a look at a Dave Letterman list style “Drupal 8’s Unfair Advantage: 10 Reasons to Standardize on Drupal.”

10. Scalability: Drupal scales from simple to complex sites. You can manage a corporate website (like Xerox.com), a commerce site (like Wilson.com), a site that experiences extreme traffic bursts (like Grammys.com), an intranet, or even multiple sites on the same platform (like SABMiller). Drupal 8, the latest version of Drupal, powers huge sites like Nasdaq’s investor relations, in addition to Oregon State University, Hubert Burda Media, and YMCA of Greater Twin Cities, just to name a few. Additionally, Drupal offers out-of-the-box integration with OAuth, Salesforce, Oracle, LDAP and AD for starters.

9. Multilingual: Drupal was built with multilingual use in mind so you can easily create digital experiences for your audiences in their native languages worldwide. And its interface is translatable into nearly any language you want, so almost anyone can use Drupal to create and publish content and manage digital experiences. From a publishing standpoint, Drupal supports an ever-expanding list of languages including right-to-left languages such as Arabic and Hebrew. The Drupal install will auto-detect the language of the browser and offer to set the site to that language.

8. Drupal Community: Drupal is one of the largest open source projects in the world, with a community of more than 1 million members providing organizations with every functionality, module, and distribution needed to deliver any kind of digital experience imaginable. More than 4,500 people, companies, and organizations contributed to the development of Drupal 8. The Drupal community is also truly global, so finding Drupal expertise and help is easy. Plus because Drupal 8 is object-oriented and built on Symfony components using PHP libraries, it further expands the developer base to any PHP developer, which means you no longer need a Drupal specific developer.

7. Get going FAST(er): To quickly assemble experiences, Acquia has built and delivered a free open source Drupal 8 starter kit called Acquia Lightning. While Drupal 8’s installation is relatively straightforward, Drupal Lightning distribution puts you ahead of the game right away by offering the best of Drupal 8 with 20-plus key modules that accelerate most Drupal development by 20 percent or more, and enables developers to build sites and great authoring experiences quickly.

6. Authoring Experience for Non-techies: You shouldn’t need to know HTML codes to create great content. Drupal 8’s built-in CKEditor gives authors an intuitive WYSIWYG editor that includes the expected styling capabilities, and extras like a new widgets feature and image caption editing. All of Drupal 8’s built-in themes are responsive and admin capabilities can be accessed directly from a mobile device for managing sites, content and experiences from anywhere. If you’re using Acquia Lightning, you also have access to drag-and-drop layout and content management.

5. Responsive Out of the Box: Drupal 8 incorporates responsive design into everything, built for internet-enabled devices. It can support content and experience delivery to any channel, device, screen. All core themes are responsive out of the box and automatically reflow elements to fit the size of the mobile device.

4. Security: Website security is paramount to protect your site from attacks. Drupal has many security features built-in and offers guidance for the community to protect sites. For instance Drupal 8 offers security best practices for writing code, generated PHP files and configuration for site builders. Drupal also has a security team in place. If someone discovers vulnerabilities, patches can be quickly released. Stable modules that have a security review also have a shield icon to differentiate them from the rest. Acquia Lightning in particular goes through additional security checks by Acquia's security team.

3. Workflow Management: Drupal has built-in workflow management with different access permissions levels to follow proper review and approvals before content is published. Drupal is constantly improving workflow capabilities for its users and has an established Drupal 8 workflow initiative in place.

2. Flexible Content Architecture: Content architecture in Drupal 8 has changed in a few ways for the better. Drupal provides a superior data modeling experience that supports reusable, structured content that can be displayed in multiple view modes. Content creators can reuse this data and select which view mode to use for any particular display. Developers can make use of this data model by using the tools directly in Drupal, importing data from external sources, or even using an external data store to make that information available. Further, what sets Drupal apart from other CMSes is its flexibility. Drupal allows you to publish content once and access it everywhere. Content can be reused across multiple channels and applications and delivered to any device with minimal effort. Drupal also makes it easy to connect third party content into your environment.

1. API-first: Digital experiences designed today need to be future ready. They need to be designed with omnichannel in mind, and be able to interact with many applications and extend experiences to multiple devices such as mobile applications, wearables and IoT. This requires an API-first architecture. Drupal is built API-first, which means the sky’s the limit for developers who want to build the most flexible, creative digital experiences no matter the technical obstacle.

By standardizing on Drupal, organizations can simplify training, reduce maintenance costs, streamline security and optimize internal resources–all without sacrificing quality or requirements–and still create exceptional digital experiences.

Categories: Drupal Universe

FFW and Acquia Make Drupal a More Trustworthy Option for Brands

Acquia Blogs - Fri, 2017-03-10 18:12

FFW is a digital agency focused on building creative, powerful, and user-friendly digital solutions that deliver results. With more than 400+ people across 11 countries and over 16 years of experience, FFW works with some of the largest globals brands -- including GE, YMCA and Stanford University -- helping them solve their most difficult technical challenges.

What Acquia brings to the table for FFW is strategy, migration and/or hosting services, and a much more secure and mature Drupal platform.

Acquia delivers an absolutely more professionalized platform to start with, they deliver reliable services, and [FFW and Acquia] combined are a more trustworthy proposition for the customer. - Ole Andersen, partner at FFW

In the video below, FFW partner Ole Andersen discuss how Acquia has become a strategic partner for Drupal development, implementing migrations and providing a reliable PaaS to their clients.

Categories: Drupal Universe

Acquia Receives Third FedRAMP ATO from U.S. DOT

Acquia Blogs - Thu, 2017-03-09 20:47


As federal agencies elevate the experience on their .GOV sites, the security and integrity of their digital platforms remains paramount. As a technology provider to the federal sector, Acquia’s greatest priority is meeting the security and compliance demands of our clients. In the United States, the gold standard for government site security is FedRAMPSM, the set of standards and rules required for any vendor who wants to provide products and services to a federal agency.

Acquia has been a FedRAMP Compliant Cloud Service Provider (CSP) for more than a year, receiving our first Authority To Operate (ATO) from the U.S. Department of Treasury in April 2016. Since then we’ve also received an Authority to Operate by the Social Security Administration, and now most recently, as we’re proud to report today, from the U.S. Department of Transportation. For Acquia, FedRAMP has enabled these incredibly supportive customers to move to the cloud, adopt open source technology, and leverage our Drupal tuned platform-as-a-service capabilities with confidence.
The federal government spends hundreds of millions of dollars a year securing the use of IT systems; FedRAMP provides assurance to agencies that the appropriate security and risk management practices are in place for their cloud properties. FedRAMP compliance requires our security team to ensure that we’re meeting the several parameters required.

FedRAMP: What is it?

With a rise in the adoption and proliferation of cloud solutions, finding a way to secure the use of cloud-based IT systems has proven challenging. Historically, the government’s risk management practices were inconsistent, time consuming, and expensive. FedRAMP was created to establish standards and efficiencies for cloud security practices. FedRAMP, the Federal Risk and Authorization Management Program, is a government-wide program that provides a standardized approach to security assessment, authorization, and continuous monitoring for cloud products and services.

FedRAMP was brought to life by close collaboration amongst cloud experts from both private industry and the following government organizations:

  • General Services Administration (GSA)
  • National Institute of Standards and Technology (NIST)
  • Department of Homeland Security (DHS)
  • Department of Defense (DOD)
  • National Security Agency (NSA)
  • Office of Management and Budget (OMB)
  • Federal Chief Information Officer (CIO) Council

It was created to accelerate the adoption of secure cloud solutions, provide a baseline set of standards for cloud product approval, increase confidence in the security of cloud solutions, ensuring consistent application of existing security practices, and increasing the automation of near real-time data for continuous monitoring.

How did we secure an ATO?

To secure an ATO, Acquia had to meet the robust and detailed set of FedRAMP security controls that are outlined within the NIST 800-53 Revision 4 standard. Our team was put through a rigorous independent third party audit and approval process before getting a FedRAMP Authorization. The process included three steps:

  1. Security Assessment
  2. Leveraging and Authorization
  3. Ongoing Assessment and Authorization

These FedRAMP processes are designed to help agencies meet the Federal Information Security Management Act of 2002 (FISMA) requirements for cloud systems, and address the specific challenges that cloud systems face when trying to become FISMA compliant. An agency that begins this process with a FedRAMP compliant platform has already put certain security measures in place that will aide them in securing their own ATO.

If you’re curious to learn more about the process, the FedRAMP website offers a more in-depth look at how the FedRAMP authorization process works.

So what does this mean for you?

FedRAMP offers a number of benefits to federal, state, and local government agencies, as well as other governmental applications. First and foremost, it offers a significant cost and time savings, and provides a uniform approach to risk-based management. It improves real-time security visibility, and enhances transparency between the government and CSPs.

Every government application requires an ATO, but some platforms -- like the Acquia Platform -- can make the process much faster and more affordable. If your organization deploys your application in an on-premise data center, then you’ll require an ATO for the infrastructure, platform, and application. If you’ve deployed your application with AWS, which is also FedRAMP compliant, the controls are only in place through the IaaS level, so your organization is still responsible for platform and application certification. With the Acquia Platform, however, FedRAMP controls are in place up to the PaaS level, so your organization is only responsible for certification at the application level.

Acquia customers are able to leverage a best-in-class platform that is compliant with Federal security standards out-of-the-box. As explained above, your Certification and Accreditation (C&A) efforts will require significantly less time and cost compared with trying to accredit an on-premise solution, or even a system built on a FedRAMP-compliant IaaS. You get a safe and secure cloud platform to power your organization.

Overall, with FedRAMP in place, your organization experiences improved the trustworthiness, reliability, consistency, and quality of the Federal security authorization process.

Looking for more detailed information on the FedRAMP authorization process? Their Guide to Understanding FedRAMP is an exhaustive resource.

Categories: Drupal Universe

Building Ambitious Digital Experiences with NBC Sports Digital

Acquia Blogs - Thu, 2017-03-09 14:59

NBC Sports Digital offers fans 24/7 coverage and unparalleled streaming of NBC Sports Group’s extensive collection of sports and programing. From football to basketball, motorsports and golf, NBCSports.com is the premier digital sports hub.

In partnership with Acquia and digital agency FFW, NBC Sports Digital redesigned NBCSports.com to provide fans with exclusive and unrivaled coverage of NBC Sports Group’s award-winning programming. Built with Drupal on Acquia Cloud, NBCSports.com utilizes custom functionality and a responsive design that is available on any device. NBCSports.com and the NBC Sports Regional Networks’ websites offer fans unlimited access to their favorite athletes and teams.

NBCSports.com has covered some of the most-watched and most-trafficked sporting events of all time. In order to ensure that NBCSports.com can stand up to high traffic, Acquia’s team of Technical Account Managers helps NBC Sports Digital monitor site performance in addition to offering strategic support in the planning and launching of new sites and features. Acquia’s Technical Account Managers also work with NBC Sports Digital to plan for the demands and opportunities that surround highly anticipated events. With Acquia, NBCSports.com offers fans the best digital sports hub in the field.

NBCOlympics.com: The Gold Standard for Digital Experiences

NBC’s exclusive coverage of the Rio Games set records as the most successful media event in history. In order to provide unprecedented multiplatform coverage, NBC Sports Digital needed a platform that guaranteed security, site performance and delivered best-in-class digital experiences during even the heaviest of traffic spikes.

NBCOlympics.com offers fans everything from the video streams of live-events to comprehensive results, and exclusive reporting. Acquia was the strategic partner responsible for insuring that every aspect of the NBCOlympics.com technical system ran smoothly. Acquia assembled an expert team of Technical Account Managers, Operation Engineers, and Performance Engineers to guarantee that NBCOlympics.com set the gold standard. During the Games, Acquia’s TAM team worked onsite to help manage multiple partners, mitigate risk, and to maintain the highest levels of site performance.

NBCOlympics.com sets a new benchmark for how Drupal-based content management systems are built and operated on Acquia Cloud. Over the course of the Rio Games, NBCOlymics.com hosted 3.3 billion total streaming minutes, 2.71 billion live streaming minutes, and was visited by 100 million unique visitors. Acquia is proud to be a partner of NBC Sports Digital - thank you for letting us be a part of your team.

“NBC Sports Digital is pleased to work with Acquia on our coverage of the Olympics and more than 10,000 sports events each year,” said Eric Black, Chief Technology Officer, Digital Media, NBC Sports Group. “Through our relationship with Acquia and our other partners, we are able to provide sports fans a best-in-class viewing experience regardless of the size, scale or demand of the event being streamed.”

Categories: Drupal Universe

The Evolution of Personalized Marketing

Acquia Blogs - Wed, 2017-03-08 22:46

Customer expectations are higher than ever as consumers are empowered to choose where and when they interact with a brand. As a result, marketers are faced with the seemingly impossible task of delivering a contextual experience at every customer touch point. Add in the requirement to deliver these experiences on a global scale across languages, brands and products and the challenge of marketing personalization becomes even more complex.

When considering the number of engagements that happen every second across various channels, it is no surprise that marketers struggle to manage the vast amounts of data. To make matters worse, the same marketers are also under pressure to prove the value of their efforts to the rest of the organization. Metrics around engagement, conversions, and bottom-line are all frequent requests.

The Rise of Personalization

In the early 2000s, marketers launched “personalized” email campaigns to engage their customers. Simply incorporating a customer’s name into the text of an email would surely create that intimate, long-lasting relationship marketers desired with their customers - right? All that while simultaneously collecting customer data in the company’s CRM was a fool proof plan. Until it wasn’t.

Options are limitless for today’s buyers as they have access to more information on brands than ever before. With vast amounts of online content, including product reviews and customer testimonials, consumers are able to research every detail of a brand’s offering (as well as that of their competition) before making a purchase decision. No product review page on a website? No problem for the customer. They can move their research over to one of the many social channels that have become a staple in their everyday life, or simply ask a peer’s opinion based on what they find.

This concept of user-generated content (UGC) changed the world of marketing forever as it officially marked the end of an era. No longer could an organization completely control how its audiences interacted with its brand. With this loss of control came the challenge of trying to understand their online customers’ needs and desires. Where and when a customer prefers to engage and what content that they want to consume are all key components of an impactful interaction. Without the right customer data, the marketer is left guessing. Unfortunately, with the emergence of technology and content at the buyer’s finger tips, there is no room for error. One misguided interaction and audiences can shift their attention toward the competition who are after the same goal–the execution of an impactful, personalized experience that will convert prospects into loyal customers.

Eventually, customers’ behaviors started shifting from email to web and from web to mobile and social. While marketers worked toward perfecting interactions across all these channels, the data they captured lived across disparate technologies. Without a holistic view of customer engagement across various channels, there is no way to provide a cohesive experience. Fortunately for today’s marketers, there are more sophisticated marketing technology solutions to aid in this process.

Important Questions to Ask Before Evaluating Personalization Solutions

The reality is this shift in power is relatively recent and marketers are learning how they can better meet the demands of their customers. Creating a personalization strategy and identifying the technology that will best align with business goals is a requirement for success.

Unfortunately for the marketer, Scott Brinker’s 2016 Marketing Technology Landscape identifies almost 4,000 companies in the marketing tech space. YES, 4000. Of those, there are over 130 personalization solutions. It turns out selecting a technology solution that aligns with overall business objectives might be the most daunting task of all.

When evaluating what personalization solution is right for you, there are some important questions that need to be answered first.

  • What existing Martech and Adtech solutions is your organization already leveraging? It is essential to select a solution that offers open APIs capable of integration. Your organization has most likely already implemented some marketing technology to help drive customer engagement. You don’t want to select a personalization solution that will displace those investments. The once popular marketing “stack” offerings are losing momentum as marketers are realizing the significance of an agile solution.
  • Do you have a central view of your customer data? In order to deliver a contextual experience to your audience, you needs customer data aggregated into a single view. For instance, a personalization solution must be able to integrate with a CRM, marketing automation platform, or email marketing tool for bi-directional data exchange. In addition, a personalization solution should be able to merge anonymous and known data as users are identified across various websites, sessions, and devices. With a unified view of customer profile and behavioral data, you will be able to ensure the right content is delivered at the right time to drive conversions.
  • Do you target your audiences in real-time? Targeting buyers with the right messaging is no longer enough. If you are not adaptively segmenting and targeting your audiences based on the behaviors they exhibit, you are most likely losing opportunities to engage them in the most impactful way. One example of a brand doing personalized content right, is financial services company BAC Credomatic. BAC wanted to provide their customers with a responsive and engaging online experience and implemented a new digital platform to help push tailored content to specific personas in order to provide the most personalized experience for their audiences, regardless of their entry point. Make sure that when you do evaluate a personalization tool, you require the ability to target users in real-time in order to ensure you capitalize on every customer interaction.

Personalized marketing is not going away, but it is getting smarter. I hope these considerations help you in your personalized marketing journey.

Categories: Drupal Universe

Making Drupal upgrades easy forever

Acquia Blogs - Wed, 2017-03-08 12:54
One of the key reasons that Drupal has been successful is because we always made big, forward-looking changes. As a result, Drupal is one of very few CMSes that has stayed relevant for 15+ years. The downside is that with every major release of Drupal, we've gone through a lot of pain adjusting to these changes. The learning curve and difficult upgrade path from one major version of Drupal to the next (e.g. from Drupal 7 to Drupal 8) has also held back Drupal's momentum. In an ideal world, we'd be able to innovate fast yet provide a smooth learning curve and upgrade path from Drupal 8 to Drupal 9. We believe we've found a way to do both!

Upgrading from Drupal 8.2 to Drupal 8.3

Before we can talk about the upgrade path to Drupal 9, it's important to understand how we do releases in Drupal 8. With the release of Drupal 8, we moved Drupal core to use a continuous innovation model. Rather than having to wait for years to get new features, users now get sizeable advances in functionality every six months. Furthermore, we committed to providing a smooth upgrade for modules, themes, and distributions from one six-month release to the next.

This new approach is starting to work really well. With the 8.1 and 8.2 updates behind us and 8.3 close to release, we have added some stable improvements like BigPipe and a new status report page, as well as experimental improvements for outside-in, workflows, layouts, and more. We also plan to add important media improvements in 8.4.

Most importantly, upgrading from 8.2 to 8.3 for these new features is not much more complicated than simply updating for a bugfix or security release.

Upgrading from Drupal 8 to Drupal 9

After a lot of discussion among the Drupal core committers and developers, and studying projects like Symfony, we believe that the advantages of Drupal's minor upgrade model (e.g. from Drupal 8.2 to Drupal 8.3) can be translated to major upgrades (e.g. from Drupal 8 to Drupal 9). We see a way to keep innovating while providing a smooth upgrade path and learning curve from Drupal 8 to Drupal 9.

Here is how we will accomplish this: we will continue to introduce new features and backwards-compatible changes in Drupal 8 releases. In the process, we sometimes have to deprecate the old systems. Instead of removing old systems, we will keep them in place and encourage module maintainers to update to the new systems. This means that modules and custom code will continue to work. The more we innovate, the more deprecated code there will be in Drupal 8. Over time, maintaining backwards compatibility will become increasingly complex. Eventually, we will reach a point where we simply have too much deprecated code in Drupal 8. At that point, we will choose to remove the deprecated systems and release that as Drupal 9.

This means that Drupal 9.0 should be almost identical to the last Drupal 8 release, minus the deprecated code. It means that when modules take advantage of the latest Drupal 8 APIs and avoid using deprecated code, they should work on Drupal 9. Updating from Drupal 8's latest version to Drupal 9.0.0 should be as easy as updating between minor versions of Drupal 8. It also means that Drupal 9 gives us a clean slate to start innovating more rapidly again.

Why would you upgrade to Drupal 9 then? For the great new features in 9.1. No more features will be added to Drupal 8 after Drupal 9.0. Instead, they will go into Drupal 9.1, 9.2, and so on.

To get the most out of this new approach, we need to make two more improvements. We need to change core so that the exact same module can work with Drupal 8 and 9 if the module developer uses the latest APIs. We also need to provide full data migration from Drupal 6, 7 and 8 to any future release. So long as we make these changes before Drupal 9 and contributed or custom modules take advantage of the latest Drupal 8 APIs, up-to-date sites and modules may just begin using 9.0.0 the day it is is released.

What does this mean for Drupal 7 users?

If you are one of the more than a million sites successfully running on Drupal 7, you might only have one more big upgrade ahead of you.

If you are planning to migrate directly from Drupal 7 to Drupal 9, you should reconsider that approach. In this new model, it might be more beneficial to upgrade to Drupal 8. Once you’ve migrated your site to Drupal 8, subsequent upgrades will be much simpler.

We have more work to do to complete the Drupal 7 to Drupal 8 data migration, but the first Drupal 8 minor release that fully supports it could be 8.4.0, scheduled to be released in October 2017.

What does this mean for Drupal developers?

If you are a module or theme developer, you can continually update to the latest APIs each minor release. Avoid using deprecated code and your module will be compatible with Drupal 9 the day Drupal 9 is released. We have plans to make it easy for developers to identify and update deprecated code.

What does this mean for Drupal core contributors?

If you are a Drupal core contributor and want to introduce new improvements in Drupal core, Drupal 8 is the place to do it! With backwards compatibility layers, even pretty big changes are possible in Drupal 8.

When will Drupal 9 will be released?

We don't know yet, but it shouldn't matter as much either. Innovative Drupal 8 releases will go out on schedule every six months and upgrading to Drupal 9 should become easy. I don't believe we will release Drupal 9 any time soon; we have plenty of features in the works for Drupal 8. Once we know more, we'll follow up with more details.

Thank you

Special thanks to Alex Bronstein, Alex Pott, Gábor Hojtsy, Nathaniel Catchpole and Jess (xjm) for their contributions to this post.

Categories: Drupal Universe

ACSF + Lift: Maintaining Brand Consistency and Allowing Individual Identity

Acquia Blogs - Tue, 2017-03-07 15:15

This is part three of a four part series on Acquia Cloud Site Factory and Acquia Lift.

Many global enterprises have multiple brands with different levels of recognition, within their organization. For example in the consumer packaged goods industry (CPG), SABMiller is a good example of a global organization that’s been able to deliver cost-effective, cohesive and controlled digital experiences across its entire portfolio of websites by using a single content management system and multisite digital experience management platform.

Before implementing a multisite delivery and management solution, SABMiller let its brand teams locally manage all aspects of website creation, including production, curation and delivery. This sounds organized, until you consider that SABMiller is one of the world’s largest brewers with more than 200 brands across 80 countries. Many of its brands were obtained by mergers and acquisitions, leading to varying technologies and processes in place across the organization.

SABMiller identified a cost savings opportunity to reduce its dependencies on expensive legacy technologies, consolidate its existing systems and improve processes overall. SABMiller needed a single, cost-effective and secure digital platform that could manage all of its digital experiences with a standardized level of control while still allowing their brand teams creative freedom locally.

By using a standard multisite digital management platform like Acquia Cloud Site Factory, companies can create templates that can be as flexible or as locked down as needed. With a single management console to manage all websites on the platform, permissions become easier to control, ensuring that only the proper stakeholders have access to templates and sites, preventing any accidental or unwanted changes.

Similar to companies in the CPG industry, financial services companies also have reasons to maintain brand consistency, while at the same time allowing for individual identity. For example, a financial institution might specialize in 401K plans for its different business customers. Each 401K customer portal will want the same functionality, but might also want to be individually branded for each customer’s organization. Content might vary depending on the customer’s plans and needs, but the structure of the portal might remain the same.

In practice, once you’ve established your site architecture, as well as the look and feel of your site templates, it’s time to build an engaging customer experience. While each brand site might have it’s own messaging and unique content, Acquia Lift serves as the master hub to manage all content within your network. Here, common corporate content can be updated and distributed out to all sites, and unique, relevant content can be repurposed from spoke sites across the network. Then with Acquia Lift, you can easily deliver personalized content in context throughout the buyer’s journey.

Pairing Acquia Lift with a multisite digital experience management platform like Acquia Cloud Site Factory gives you the freedom to create sites beautiful, personalized sites that your customers or prospects will love while maintaining governance and control on the backend.

Categories: Drupal Universe


Subscribe to My Drupal aggregator - Drupal Universe