Builder Book logo

Book: SaaS Boilerplate

  1. Introduction. Project structure.
  2. Setup. GitHub and Git. Visual Studio code editor. Node, Yarn. package.json. TypeScript. ESLint, Prettier. Next.js. Server-side rendering. Project structure. Document HOC. App HOC. Index page. Testing. Environmental variables.
  3. Material-UI. Client-side and server-side rendered pages. Dark theme, CssBaseline. Shared layout. Adding styles. Shared components. MenuWithLinks. Notifier. Confirmer. Nprogress. Mobile browser.
  4. HTTP, request, response. APP project. Fetch method. API method at Index page. Next-Express server. Express route. Asynchronous function, Promise, async/await. API server. New project API. Updating APP.
  5. Infrastructure for User. MongoDB database. MongoDB index. Jest testing for TypeScript. Your Settings page. API infrastructure for uploading file.
  6. Login page. Session and cookie. Google OAuth API. Authentication HOC withAuth. firstGridItem logic in App HOC.
  7. AWS SES API. Passwordless OAuth API. Mailchimp API.
  8. Application state, App HOC, store and MobX. Toggle theme API. Team API. Invitation API.
  9. Discussion API. Post API. Websockets for Discussion and Post.
  10. Stripe API - API project. Stripe API - APP project. Setup at Stripe dashboard and environmental variables. Email notification for new post API - API project. Amazon API Gateway and AWS Lambda.
  11. Environmental variables, production/development. Logger. APP server. API server. SEO - robots.txt, sitemap.xml. Server-side caching. Heroku. Testing application in production. AWS Elastic Beanstalk.

Chapter 1: Setup. GitHub and Git. Visual Studio code editor. Node, Yarn. package.json. TypeScript. ESLint, Prettier. Next.js. Server-side rendering. Project structure. Document HOC. App HOC. Index page. Testing. Environmental variables.

We regularly update the codebase with stable syntax and stable versions for packages. The price becomes $249 on June 1st, 2021.

The section below is a preview of SaaS Boilerplate Book. To read the full text, you will need to purchase the book.

In Chapter 1, you will start with the codebase in the 1-begin folder of our saas repo and end up with the codebase in the 1-end folder.

We will cover the following topics in this chapter:

  • Setup
    - GitHub and Git
    - Visual Studio code editor
    - Node, Yarn
    - package.json
    - TypeScript
    - ESLint, Prettier

  • Next.js
    - Server-side rendering
    - Project structure
    - Extension for Document HOC
    - Extension for App HOC
    - Index page

  • Testing

  • Environmental variables

As you learned from the Introduction chapter, this book assumes a basic understanding of JavaScript, React, Next.js, and Express. Although we will have occasional detours to discuss important concepts, we will make fewer detours compared to our first book. If you are new to concepts such as HTTP, Promise, syntactic sugar async/await, server-side rendering, MongoDB index - you should read our first book, Builder Book.

In the Introduction chapter, we discussed our motivation to write this book and showed you a final structure of the project you will build in this book. You may have noticed from the project's structure that the final project is made of two projects: app and api.

The app project has code that can run on both browser and server (code inside pages) and code that runs only on the server (code inside server), which is made of a Next-Express server whose main purpose is to either (1) send JSON data to the browser for a client-side rendered page or (2) send a server-side rendered page. The server from app sends most of its requests for data to the api server.

api has server-only code and is made of an Express server that contains all internal and external APIs - for example, an API to display a list of Posts or an API for Google OAuth. The app server sends requests for data to the api server, and the api server sends data to a MongoDB server to CRUD that data in a MongoDB database.

In this setup, page requests that come to the app server or browser do not block requests to the api server (user authentication, processing payments, sending transactional emails, CRUDing data in database). And vice versa - requests that come to api don't block page requests to app. We will discuss this architecture in more detail in Chapter 3, where we introduce the api project. We will also discuss a lambda project in more detail in Chapter 9.

In Chapter 1, our sole focus is to set up the app project. We will not write much code, but we will discuss and create many configurations and configuration files. Please see the table of contents for this chapter. You can always find the table of contents on the left sticky panel or at the top of each chapter.

link Setup

Similar to our first book, we work on Ubuntu 18.04.3 LTS. All installation instructions in this book should work on Ubuntu 18.04.3 LTS, Ubuntu 20.04.1 LTS, and most Linux-based operating systems (Debian). Most instructions will work on MacOS as well. You have to do your own research if you work on Windows. We make no promise to have instructions for Windows-based operating systems.

You can download Ubuntu 18.04.3 LTS from:

Instructions on installing it to your machine:

link GitHub and Git

If you bought our first book, you know that we make the entire codebase for our book public on GitHub. For this book, the codebase is hosted in our public repo saas:

As you can see, every chapter has two folders: one with the suffix -begin, one with the suffix -end.

Every chapter in the book guides you from the N-begin codebase to N-end codebase. For example, in this chapter we will start with 1-begin and end up with 1-end. The 1-end codebase is identical to the 2-begin codebase, and the 2-end codebase is identical to the 3-begin codebase, etc.

After you succesfully install Ubuntu, press Ctrl+Alt+T to start a new terminal window.

Inside your terminal, navigate to the folder on your computer where you want to save all chapters' folders. Navigate between directories using cd folderName or cd ...

To copy the entire saas repo from GitHub, you have to run a Git command inside your terminal:
git clone

Navigate to the cloned folder. In your terminal, you can type cd book/1-begin. As you can see, since this is the very beginning of our journey, this folder is nearly empty. It contains only one file, .gitignore.

link Visual Studio code editor

At this point, you have installed Ubuntu, used the terminal, and used GitHub and Git to copy the book's codebase to your local machine.

The next step is to install a code editor on your local machine. Over years of writing software, we found Visual Studio code editor ( to be a good choice, for now.

Follow these instructions to install VS code editor on your operating system:

We use version 1.52.1 as of writing of this book.

Once installed, open the code editor:
Builder Book

VS code editor has User and Workspace settings:
- You can modify any of the settings for all projects opened with the code editor using the User settings. These settings are specific to your machine.
- You can modify project settings using the Workspace settings. Workspace settings overwrite User settings for a particular project (narrower settings overwrite global settings). These settings are specific to a project.

Read more about settings here:

Let's edit some of our Workspace settings. Open the saas folder with your code editor. Then go to File (or Code) > Preferences > Settings:
Builder Book

Select the tab that says Workspace. Scroll through the list of different settings and you can, for example, set up the following configs:

"window.zoomLevel": 0,
"files.autoSave": "afterDelay",
"git.enableSmartCommit": true,
"editor.formatOnSave": true,

The first setting controls the zoom level of your window. You can also adjust it on-the-go by pressing Ctrl+ or Ctrl-.

The second setting allows you to automatically save files after you modify them, without manually clicking Ctrl + S.

The third setting commits changes automatically if there are no staged changes.

The last setting allows the editor to automaticallty format code on every save event. Later on, when you press Ctrl+S, the code editor will apply TSLint formatting to the code.

After you modify these settings, your Workspace settings will be saved to the root of the saas folder inside .vscode/settings.json. You can open the .vscode/settings.json file to see all Workspaces we provided you.

You can find explanations for all settings inside this .vscode/settings.json file:

We will discuss the dbaeumer.vscode-eslint extension for VS code editor later in this chapter.

link Node, Yarn

Both app and api are Node.js projects. All third-party packages (also called libraries) are built for Node projects.

We recommend using nvm ( (Node Version Manager) for installing Node and managing its version.

On Ubuntu, press Ctrl+Alt+T to open your terminal (alternatively, use the search bar to search for terminal).

  • Run the command below to install nvm:
    curl -o- | bash
  • Check the nvm version to confirm successful installation:
    nvm --version
  • Trigger nvm:
    . ~/.nvm/
  • Install Node 12.16.1:
    nvm install 12.16.1
  • Make it default:
    nvm alias default 12.16.1
  • Check Node version to confirm successful installation:
    node -v

Node version, as of writing this book, is 12.16.1.

Once Node is installed, we can install Yarn, a manager for third-party packages (also called dependencies or libraries). Whenever we need to use code developed by other developers, we add the package name and version to a package.json file (or you can run yarn add packageName@packageVersion) and run yarn in the project's directory. More on package.json in the next section.

Throughout this book, we are using yarn instead of npm package manager.

Install Yarn on Ubuntu as follows:

  • Configure the Debian package repository for Yarn ( by running the following two commands in your terminal:
    curl -sS | sudo apt-key add -
    echo "deb stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
  • Then install Yarn with:
    sudo apt-get update && sudo apt-get install yarn
  • Check Yarn version to confirm successful installation:
    yarn -v

If you're using another operating system, find specific instructions here on Yarn's official website. Select your operating system from the "Operating system" dropdown menu.

In this book, the Yarn version is 1.22.5.

At this point, you have Node and Yarn installed on your local machine. Now we can create a Node project by defining a package.json file and installing third-party dependencies defined inside the package.json file using Yarn.

In this book, the Node version is 12.16.1 and Yarn version is 1.22.5.

link package.json

As mentioned earlier in this chapter, the final app will consist of app, api, and lambda projects. We discuss app project setup in this chapter, api project in Chapter 3, and lambda project in Chapter 9.

All three projects are Node projects. Every Node project requires a configuration file: package.json. Learn about this file's metadata from the official docs:

On your VS code editor, open the cloned saas repo, navigate to the book/1-begin folder, create an app folder and inside it, create a package.json file.

package.json should contain the project's metadata such as:
- name,
- version,
- scripts
- dependenices (described by name and version), among many other required and optional properties.

Some metadata is required and some are optional. The parameters keywords and license are optional, while parameters name and version are required.

Open your newly created package.json file and add the following content to it:

"name": "1-end-app",
"version": "1",
"license": "MIT",
"scripts": {
    "dev": "next",
    "build": "next build"
"dependencies": {
    "dotenv": "^8.2.0",
    "next": "^9.1.2",
    "react": "^16.13.1",
    "react-dom": "^16.13.1",
    "typescript": "^3.4.3"
"devDependencies": {
    "@types/node": "12.12.2",
    "@types/react": "^16.8.24",
    "@types/react-dom": "^16.0.5",
    "@typescript-eslint/eslint-plugin": "^4.2.0",
    "@typescript-eslint/parser": "^4.2.0",
    "eslint": "^6.7.2",
    "eslint-config-prettier": "^7.1.0",
    "eslint-plugin-prettier": "^3.3.1",
    "eslint-plugin-react": "^7.21.5",
    "prettier": "^2.2.1"

You can see required metadata like name and version (version has a format of major.minor.patch).

The dependencies section contains a list of third-party packages that we need in production and development environments. To install all packages from package.json, simply run yarn in your terminal while inside the app directory.

The devDependencies section contains dependencies that our app uses in development but not in production. Typically, developers use packages in devDependencies to run tests, compile code, or lint code locally. Useful locally but not required in production.

If you see no ^ (caret) and no ~ (tilde) in front of the major.minor.patch version number, then when you run Yarn or Npm, you will install an exact version of the package.

However, if you use ^1.0.0 instead of 1.0.0, then if a version with a higher minor number is available, you may install 1.1.0 instead of 1.0.0.

If you use ~1.0.0 instead of 1.0.0, then if a version with a higher patch number is available, you may install 1.0.1 instead of 1.0.0.

To check if Yarn successfully installed the packages, check the autogenerated node_modules folder or yarn.lock lockfile at the project's root directory. The former folder contains the code of third-party packages, and the latter file contains the exact versions of packages (direct) and packages they depend on (indirect).

The section of package.json called scripts contains shortcuts for commands. At the end of this book, in Chapter 10, the scripts section will contain the following command:

"build": "next build && tsc --project tsconfig.server.json"

You can see that it's much easier to type yarn build in your terminal window than yarn next build && tsc --project tsconfig.server.json. Thus, scripts are essentially shortcuts for commands.

In this chapter, the commands are still short enough that shortcuts are not as useful, but they will become more useful as you make progress in this book.

We will discuss the dev and build scripts later in this chapter.

We can also prepend any command with a so-called environmental variable, for example:

"build": " NODE_ENV=production next build && tsc --project tsconfig.server.json"

But it is better not to store environmental variables (which are typically secret) in package.json. More about environmental variables later in this chapter.

Run the yarn command inside the 1-begin/app folder, and you will see a newly generated node_modules folder and yarn.lock file. You successfully installed all packages we need for Chapter 1. We will discuss each installed package as we go.
Builder Book

You've reached the end of the Chapter 1 preview. To continue reading, you will need to purchase the book.

We regularly update the codebase with stable syntax and stable versions for packages. The price becomes $249 on June 1st, 2021.