Next Generation Headless CMS

Blaze Overview

The ‘headless’ nature of the Blaze application, facilitated by messaging between application services, enables performant, secure management of content, media, user data and transactions within the application, between services within Blaze and between Blaze and other applications.  Blaze is a micro-service orientated, ‘headless’ CMS application.  It is built for efficient management of data, scaling, performance and optimal management of the application, independent from any discrete system front-end or Application (App), hence ‘headless.

Blaze is divided into a micro-service orientated, backend CMS application which primarily supports a front-end web client, delivered as a discrete Isomorphic React application.   The headless nature of the Blaze application facilitates many content delivery and publishing use cases, like the delivery of content and user data to an associated App, or to other platforms like an Email Management System (EMS) such as Mailchimp, to Social media Platforms like Facebook or LinkedIn or to CRM systems like SalesForce.   The use-cases for easy, secure transfer of data between systems are myriad with Blaze.

The core Blaze application is architected based on the CRUD (Create, Read, Update, Delete) methodology using APIs created in GraphQL. When compared to RESTful APIs, GraphQL facilitates very efficient data interaction between services within the application and with the front-end website application, or indeed any other system integrations and dependencies.

Blaze’s secure & performant GraphQL based ‘API first’ approach, coupled with a NoSQL database, MongoDB, supports elegant web application development for digital teams and offers new depth in what is achievable in content and data processing and scaling both within and between web applications.

The benefits manifest themselves with increasing scale of data stores, like within a publishing company’s content archive, retailers EPOS data, or ecommerce transactions, where large amounts of data can be analysed, processed and returned to a web page in fractions of the time that what was previously achievable with Relational Database Management System (RDBMS) data processing models.

Using Blaze, use cases like content relationship management, structured or unstructured search, data reporting or personalisation of content at scale, based on user analytics become easily achievable.

The decoupled architecture also facilitates the distributed management and delivery of media and display presentation assets, making use of global Content Delivery Networks (CDNs) like AWS CloudFront or CloudFlare and their distributed media delivery capacity.   This again supports performant delivery of content, at scale, but also in a geographically dispersed way.

Support for serverless deployment means that the Blaze application can be deployed to an operational environment that can also be easily scaled.  Serverless Application Models (SAM) allow Blaze users to easily deploy the application and dependent resources directly from GitHub.  Serverless architecture allows you to pay only for usage on demand and to deploy specific functions independently, so that they can be scaled independently to meet demand only when it arises, not all of the time.    This approach provides on-demand scaling, improving operational availability and significantly reducing ongoing operational costs.

Byte9 follow an agile software development methodology and Blaze is delivered using continuous integration (CI)  and immutable architecture and continuous delivery, using test driven methodology, to reduce development and support risk and to reduce ongoing operational cost.

The primary benefit is that Blaze Framework users can release changes regularly and securely, reacting to demands on discrete parts of the system instantly, independently and without downtime or interruption.

Common Language, better team efficiency with less resources

Blaze is authored using a full JavaScript technology stack, serverless architecture with  supporting micro services to de-couple the application and supporting services as far as we can,  giving scalability and lower operational overhead.

Being written predominantly in a single programming language JavaScript allows for better understanding of the source code for teams working on the project, front-end and back-end teams.   Moreover, the open source, supported deployment environment facilitates interaction between in-house, third party and Blaze partner development teams.

Full stack JavaScript development is prevalent amongst leading technology companies focussed on fast paced development of performant scaled applications. Facebook is a main ambassador for the technology stack and tooling that the Blaze application utilises (see below).  Performance success stories like PayPal’s migration from Java to full stack JavaScript bear out the benefits that can be attained in engineering efficiency and application performance across the technology stack.

Extensive Code Re-use

With full stack JavaScript development time is saved in code reuse and sharing.  Following the “don’t repeat yourself” (DRY) principle we have minimised duplication within the Blaze codebase (or sharing libraries, templates, and models) on both back and front-end, that are very close in terms of logic and implementation.  In other words, you don’t need to think about the JavaScript utility equivalents in Python or PHP, you just use the same utility in the back-end and front-end.

High Performance, Speed and Efficiency

Blaze’s Node.js, run-time environment, uses an event-driven, non-blocking IO model that makes it lightweight and very fast indeed.   This is important when considering application or website ‘concurrency’ (number of concurrent users or requests for data) and the ability to scale the application across one or many environments.  For servicing increasing or spiking website usage (e.g., page-loads), or concurrent transactions (e.g., orders or transactions) and the impact that has on e.g., SEO or conversion rate and the cost of serving that the benefits are significant.  Combined with the ‘on-demand’ serverless load-balanced server environment this means both the application and the environment manage scale both efficiently and cost-effectively.

Blaze’s ‘plug-in’ architecture allows for the discrete management and scaling of services between layers of the Blaze application and between de-coupled micro-services and third-party systems.   Image processing is, for example, is managed and scaled within its own AWS Lambda micro-service.  A modularised, micro-service orientated architecture allows the Blaze application and services to scale easily, horizontally and independently or in parallel.

Serverless, cloud provisioning of computing power also enables almost instantaneous capacity scaling to meet demand.  This means that server computing power is no longer limited to physical infrastructure, or one ‘hosting’ company.

De-coupled, GraphQL API first approach

APIs allows an external system to interact easily and securely with any given system, using a standards-based methodology.

APIs support modularity within the system architecture, which allows the ‘separation of concerns’ and hiding internal application complexity – exposing the client application to only the data required.  If different components interact with each other via APIs, then as long as the API doesn't change, components can be swapped in and out of the system, reducing dependencies within and between applications and facilitating ongoing development. Moreover, the use of GraphQL means that the transfer of data between systems accounts for precisely the data required, defined by the client.  This has distinct advantages for performance as a system scales, especially over alternatives like REST APIs.   In a micro-service environment there are additional advantages, such as data owner separation, granular data control, parallel execution, service caching etc.

Additionally, the backend being separate from the front-end client, utilising the APIs, gives multiple benefits, like the ability to scale either part of the system in isolation from the other, or being able to update either part of the system independently.  De-coupled system architecture supports easier ongoing system development, application management and scaling.

Blaze uses GraphQL API messaging for everything, which will give flexibility to easily evolve the system without breaking changes, as the de-coupled parts of the system can be updated, or replaced independently.

This modular approach will also help with evolving CMS requirements and also facilitate interactions between internal and third-party systems by creating a ‘de-coupled’, secure and standards-based approach for data exchange between systems.

‘Headless’ CMS Application

Traditionally CMS applications have been ‘monolithic’ in nature, treating the website or application, front-end, or content presentation layer, as part of the system using themes, or templates (see WordPress or Drupal themes and templates for reference).

Treating the CMS application as ‘headless’ creates a number of benefits to users.   In the case of Blaze, the website presentation is provided via a separate in-browser ReactJS JavaScript application, which accesses the CMS application via the GraphQL APIs.    The APIs provide access to content, user account data, subscription data, transaction data etc in a secure, authenticated way and data is passed securely between the applications, for presentation in the separate front-end application within the web browser.

On a simple level this allows for design changes to be undertaken completely independently of the CMS, even supporting the introduction of different technologies, even as yet unknown.  Front end developers are also consequently liberated to create much richer, interactive and performant user experiences within the front-end application and the web browser.

Another simple advantage gained in this approach is a performance and stability one, we can isolate the in-browser performance and optimise it independently of the Blaze administrative back-end.   The ability to remove the assembly of any completely formatted response, based on complex presentation rules and focus on just content delivery, allows for significantly improved performance and simplified management.

The de-coupling of the front-end and other dependant and supporting applications from the CMS also allows for the CMS to be updated easily incrementally, simplifying significantly the application upgrade path.

The ‘de-coupling’ of the website front end using the GraphQL API framework also then supports other use cases for the passing of data to and from Blaze.

• App development and integration
• Progressive Web App development
• Ecommerce system integration
• Fulfilment system integration
• Subscription system integration
• Customer Relationship Management (CRM) system integration
• Email & marketing system integration
• Marketing automation system integration
• Payment gateway integration
• Accounting system integration
• Social Media integration
• Advertising and Pay-per-Click (PPC) platform integration

The Blaze application can then itself be optimised for the support of administrative, content and media management, reporting, and dashboarding tools (etc), allowing independent development, but with a web standards-based interface between the other supporting applications.

Plugin framework & Development Partners

A framework for plugins provides additional functionality that can be added to any Blaze installation.   For example, an approved ESP, CRM or Payment Gateway plugin might be added, via the API framework within the Blaze plugin administration.

Byte9 will provide an increasing set of approved plug-ins and managed approved partners’ plug-ins in order to maintain the quality and quantity of plug-ins and to extend the core Blaze functionality and integrations ongoing.

Open-source development partners will also support Blaze implementation and core application development.    A directory of implementation and development partners will help end users to select appropriate partners with which to work on Blaze implementation and support in future.

Decoupled architecture, for easy development

Blaze manages a series of dependencies where different versions of different parts of the application may be required.

Plugin selection dynamically introduces routes when a plugin is enabled. For example, by activating an ecommerce plugin the application understands routes like /cart /checkout and /success, these are managed independently per plugin allowing for their update or replacement.

Events and messaging allow for secure commands and data to be transferred between independent parts of the system.    A plug-in orientated architecture allows for easy updates and changes to existing parts of the system without the risk of breaking dependencies within the application. This de-coupled architecture allows for easy update and development by any contributing developer or in-house team.

Plugins developed within the Blaze Plugin Framework can be quality controlled and visual consistency and user experience maintained by use of the Blaze Design System (see below)

Cloud serverless hosting

Blaze is deployed on AWS cloud infrastructure.  This gives Blaze users cost effective, scalable, ‘on-demand’ computing and web infrastructure.  Fast deployment to AWS cloud infrastructure is achieved on Amazon Web Services (AWS) templates.   This gives Blaze users a low cost, high performance, scalable hosting infrastructure – paying only for what they use, with computing that scales instantly to meet traffic demand.   Redundant hosting capacity and cost is therefore no longer a consideration for Blaze users.

Continuous delivery and Immutable deployment infrastructure

Blaze deployment infrastructure utilises continuous and Immutable deployment from GitHub.  This is managed using Github Actions, AWS Code Pipeline and quality controlled using Jest, Cypress and Sonar Cloud.   With this continuous deployment infrastructure in place functional changes, security updates and performance tweaks can be released, quality controlled and tested in a semi-automated way, with no downtime.

Protection, Monitoring and Support

Blaze is protected by AWS Web Application firewall, utilising Machine Learning to manage firewall rule, code quality in dependencies are managed used SNYK, and within the Blaze application itself using Sentry.  The AWS serverless environment is monitored using AWS CloudWatch and all application, performance and computing data is managed and reported within Datadog.

Gold, silver and Platinum support packages are available with the Byte9 team to manage ongoing application development and deployment to suit Blaze user requirements.