Node.js Modular Content Management System

A reusable, modular Content Management System built with Node.js, MongoDB, Handlebars and PJAX, designed to power multiple websites from a single application architecture.

Instead of rebuilding the same functionality for every new website, the system centralizes reusable modules, content, APIs and rendering logic into one platform.

Overview

I built this CMS to solve a recurring problem in web development: rebuilding the same functionality every time a new website or project is started.

The platform treats website content as structured data and reusable modules. Features such as email delivery, blogs, page rendering and other functionality can be developed once and reused across multiple websites.

The architecture allows new websites to be launched by configuring and composing existing modules rather than repeatedly copying and modifying application code.

The system has evolved through hundreds of commits and is designed around a modular request/response architecture.

Key Features

• Modular Content Management System
• MongoDB-backed content and data storage
• Server-side rendering with Handlebars
• Reusable application modules
• Dynamic routing and request handling
• HTML page rendering
• JSON data APIs
• PJAX partial-page responses
• Authentication and authorization levels
• Brand-specific routing
• Reusable email and newsletter functionality
• Dynamic blog/content modules
• Shared functionality across multiple websites
• Nginx-based domain routing
• Lightweight architecture designed for cost-efficient deployment

Modular Architecture

The platform uses a structured request pattern:

/:brand/:permit/:requiredType/:module/:input

This allows the same application to serve different websites and modules while keeping the request architecture consistent.

Brand

Identifies the website or application being served.

Permit

Controls the access level:

• gen — General/public requests
• auth — Authenticated website-owner requests
• admin — Administrative requests

Request Type

The system supports three response types:

• page — Render a complete HTML page
• data — Return JSON data
• pjax — Return only the portion of the page that needs updating

Module

Identifies the functionality being requested, such as blog, email or other reusable application modules.

Input

Provides the data required by the module, such as a blog slug or other identifier.

This architecture allows the same underlying system to expose different capabilities depending on the website, user permissions and requested response type.

Example

A normal website request can be transformed through the CMS into a rendered page.

For example:

/:brand/gen/page/:module/:input

A data request can instead return JSON:

/:brand/gen/data/:module/:input

And a PJAX request can return only the relevant portion of the page rather than reloading the entire website.

This made it possible to build responsive, content-driven websites while keeping the backend architecture centralized.

My Contribution

• Designed and developed the CMS architecture
• Built the Node.js backend
• Designed the MongoDB data layer
• Implemented dynamic routing
• Developed reusable application modules
• Implemented authentication and authorization levels
• Built server-side rendering with Handlebars
• Designed JSON data endpoints
• Implemented PJAX-based partial page updates
• Developed reusable email functionality
• Created a structure for supporting multiple websites from one codebase
• Configured production routing through Nginx
• Maintained and continuously evolved the platform

Technologies

Node.js · Express.js · MongoDB · Mongoose · Handlebars · JavaScript · PJAX · jQuery · Nginx · Linux

Why I Built It

The goal was to stop rebuilding the same functionality for every new website.

Instead of copying code between projects, reusable modules could be maintained in one place and made available to different websites.

This approach reduced duplicated development work and created a foundation from which new projects could be developed faster.

Engineering Focus

The project demonstrates my experience with:

• Backend architecture
• REST-style API design
• Server-side rendering
• Database-driven applications
• Modular software architecture
• Authentication and authorization
• Reusable software components
• Multi-site application design
• Dynamic routing
• Performance-conscious web development
• Linux server deployment

Deployment

The CMS was designed to run on lightweight infrastructure and was deployed behind Nginx.

One of the original design goals was to keep infrastructure costs low while still supporting multiple websites from the same application architecture.

Project Status

The CMS is an evolving personal platform and experimentation project that has grown over time as new requirements and projects were added.

The repository currently contains more than 500 commits, reflecting its continued development and use as a foundation for web projects.

Live / Source

GitHub:
https://github.com/qasim2020/playground