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
Have questions about the stack or the deployment process? Drop a comment below.