Building TheEpicBook: A Deep Dive into a Node.js Monolithic Web Application

By a Full-Stack Developer | May 2026

Introduction

In an era where microservices and serverless architectures dominate tech conversations, there is still a strong case to be made for the classic monolithic application. TheEpicBook is a full-stack bookstore web application built as a monolith — a single, unified codebase that handles everything from serving HTML pages to managing a relational database. This post walks through the architecture, the tech stack, the challenges faced during deployment, and the lessons learned along the way.

What Is TheEpicBook?

TheEpicBook is an online bookstore application that allows users to browse a curated collection of books, view book details, add items to a shopping cart, and proceed through a checkout flow. The app greets visitors with the tagline "Discover Your Next Great Read" and delivers a clean, responsive UI backed by a real relational database.

At its core, TheEpicBook is a traditional server-rendered web application — no separate frontend framework calling a REST API, no independent microservices. Everything lives in one place, and the server does it all.

The Tech Stack

TheEpicBook is built on a straightforward but powerful stack:

Node.js + Express — the backbone of the application, handling routing, middleware, and HTTP request/response logic
Express-Handlebars — a server-side templating engine that renders dynamic HTML views on the server before sending them to the browser
Sequelize ORM — an abstraction layer over the MySQL database that lets the app interact with data using JavaScript models rather than raw SQL
MySQL — the relational database storing Authors, Books, Carts, Checkouts, and their relationships
Nginx — a reverse proxy sitting in front of the Node.js server, handling incoming traffic on port 80 and forwarding it to the app on port 8080
AWS EC2 — the cloud infrastructure running the entire application on an Ubuntu server

Application Architecture

The monolithic architecture means every concern — routing, templating, business logic, and database access — lives within a single deployable unit. Here is how the key layers fit together:

Models

Sequelize models define the database schema and relationships in JavaScript. TheEpicBook has five core models:

Author — stores author first and last names
Book — stores title, genre, publication year, price, inventory count, and description, with a foreign key linking to Author
Cart — tracks quantity and price for a shopping session
Checkout — stores shipping address and subtotal, linked to a Cart
Cartbook — a junction table managing the many-to-many relationship between Books and Carts

On startup, Sequelize syncs these models with the database, automatically creating tables if they do not exist.

Routes

Express routes define the URL structure of the application. Each route handler fetches data from the database via Sequelize and passes it to a Handlebars template for rendering.

Views

Handlebars templates receive data from route handlers and produce the final HTML sent to the browser. This server-side rendering approach means the browser receives fully-formed pages — no client-side data fetching required.

Static Assets

CSS, images, and client-side JavaScript are served as static files from the public directory via Express's built-in static middleware.

Deployment on AWS EC2

Deploying TheEpicBook to a live Ubuntu server on AWS involved several real-world challenges worth documenting.

Permissions Issues

After removing node_modules to resolve an npm rename conflict, the directory ended up owned by root due to a prior sudo npm install. Running sudo chown -R ubuntu:ubuntu /home/ubuntu/theepicbook restored correct ownership and allowed npm to install cleanly. The lesson: never run npm install with sudo inside a project directory.

Nginx as a Reverse Proxy

The server ships with Nginx pre-installed, which intercepts traffic on port 80. Rather than expose the Node.js process directly to the internet, Nginx is configured as a reverse proxy — forwarding requests from port 80 to the app running on port 8080. This is best practice for production Node.js apps, providing a clean entry point and making it easy to add SSL termination later.

Security Groups

On AWS, inbound traffic is controlled by Security Groups at the network level. Port 8080 must be explicitly opened in the EC2 inbound rules for direct access, and port 80 for Nginx proxied access. Missing this step is a common gotcha — the app runs fine on the server, but the browser simply times out.

Database Seeding

Sequelize creates the schema automatically on app startup, but an empty database shows no books. TheEpicBook ships with SQL seed files — author_seed.sql and books_seed.sql — that populate the database with initial data using a simple mysql import command.

The Case for Monoliths

TheEpicBook is a great example of why monolithic applications remain relevant and valuable, especially for smaller projects and early-stage products:

Simplicity — one codebase, one deployment, one process to manage
Easier debugging — the entire request lifecycle is traceable within a single application
Faster development — no API contracts to maintain between services, no network calls between components
Lower operational overhead — no service mesh, no inter-service authentication, no distributed tracing needed

The trade-offs come at scale — a monolith becomes harder to scale independently, and a bug in one module can affect the whole app. But for a bookstore with a well-defined domain and a small team, the monolith is the right tool for the job.

What's Next for TheEpicBook

There are several natural next steps to evolve the application:

Process management with PM2 — keep the Node.js process alive across server restarts and crashes
SSL with Let's Encrypt — add HTTPS via Certbot and Nginx for secure connections
User authentication — session-based login so users can track their own carts and order history
Admin dashboard — a protected route for adding, editing, and removing books without touching the database directly
Extracting an API layer — a first step toward a more modular architecture, serving JSON alongside the server-rendered views

Conclusion

TheEpicBook demonstrates that a well-structured monolithic application can be a robust, maintainable, and deployable product. Built with Node.js, Express, Sequelize, and MySQL, and deployed on AWS EC2 behind Nginx, it covers the full stack from database to browser in a single cohesive codebase. The deployment journey — from permissions errors to Security Group configurations — reflects the real-world experience of shipping a web application to a live server.

Sometimes the right architecture is the simple one. TheEpicBook is proof of that.

---You want to follow and implement the this project:https://github.com/ntonous/theepicbook.git