How to Set Up a Node.js Project with TypeScript & Docker

If you’re planning to build a web app and want a smooth, efficient process, you should consider using Node.js with TypeScript and Docker. These tools make development faster, cleaner, and easier to manage. Many companies now look to hire Node.js developers in the USA because this setup helps build modern, scalable apps. 

Whether you’re launching a startup MVP, a SaaS product, or an enterprise application, this tech stack provides the flexibility and performance developers need. It also makes collaboration simpler when working with teams, especially in remote environments. In this article, we’ll guide you step-by-step on how to set up a Node.js project using TypeScript and Docker, even if you’re just getting started.

Why Use TypeScript and Docker with Node.js?

Using Node.js is already a great choice for backend development. Adding TypeScript and Docker makes it even better.

Benefits of TypeScript:

• Adds types to JavaScript, which helps avoid bugs
• Offers better code suggestions and auto-complete
• Makes the code easier to understand and maintain
• Provides early error detection during development

Benefits of Docker:

• Makes your app run the same way on every computer
• Helps package everything your app needs in one place
• Useful for deploying your app anywhere easily
• Simplifies testing across multiple environments

Combining all three tools lets you work smarter, write better code, and avoid problems when moving your app to other computers or servers.

Step 1: Set Up Your Project Folder

1. Create a new folder for your project.

mkdir my-node-app
cd my-node-app

2. Start a new Node.js project:

npm init -y

This creates a package.json file to manage your app’s settings and dependencies.It’s good to also create a .gitignore file to ignore folders like node_modules and dist:

echo "node_modules/\ndist/" > .gitignore

Step 2: Install TypeScript and Other Packages

Install TypeScript and other helpful tools:

npm install typescript ts-node @types/node --save-dev

• typescript: lets you write TypeScript
• ts-node: runs TypeScript files without compiling first
• @types/node: adds type information for Node.js

Create a TypeScript config file:

npx tsc --init

Change your tsconfig.json to match this basic setup:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "outDir": "dist",
    "rootDir": "src",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}

Step 3: Add Your Code

Create a folder named src and add an entry file:

mkdir src

Inside src/index.ts, write this simple code:

const message: string = "Hello from Node.js with TypeScript!";
console.log(message);

To run it:

npx ts-node src/index.ts

You can also add a script in your package.json to make it easier:

"scripts": {
  "dev": "ts-node src/index.ts"
}

Now you can just run:

npm run dev

Step 4: Dockerize Your App

Docker helps you create an environment that runs the same anywhere.

Create a file named Dockerfile in the root folder:

# Stage 1: Build
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Run
FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/dist ./
CMD ["node", "index.js"]

Then, add this to your package.json scripts:

"scripts": {
  "start": "node dist/index.js",
  "build": "tsc"
}

Build and run your Docker container:

docker build -t my-node-app .
docker run my-node-app

You can also use docker-compose.yml for multi-container setups (like Node.js + database):

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    command: npm run dev

Step 5: Best Practices for Node.js Projects

To make your app easier to manage, follow these tips:

1. Project Structure Example:

my-node-app/
├── src/
│   └── index.ts
├── dist/
├── package.json
├── tsconfig.json
├── .gitignore
└── Dockerfile

2. Use ESLint and Prettier Install tools that help you write clean code:

npm install eslint prettier --save-dev

Set up configurations for code style and formatting. You can run them with scripts:

"scripts": {
  "lint": "eslint src/**/*.ts",
  "format": "prettier --write src/**/*.ts"
}

3. Use environment files Avoid hardcoding settings like passwords. Use .env files and libraries like dotenv:

npm install dotenv

Example usage in your code:

import dotenv from 'dotenv';
dotenv.config();
console.log(process.env.MY_SECRET);

4. Test your code Add unit tests using Jest:

npm install --save-dev jest ts-jest @types/jest

Set up jest.config.js and run tests with:

npx jest

5. Keep dependencies updated Regularly update packages with:

npm outdated
npm update

Conclusion

Now you know how to set up a basic Node.js project with TypeScript and Docker! This setup gives you a strong foundation for building apps that are easy to test, deploy, and scale. Whether you’re building microservices, APIs, or full-stack applications, this stack is widely adopted for its flexibility and efficiency.

If you’re looking for help building fast, modern applications, Orbitwebtech is the best web development company in the USA. We offer expert solutions for startups and enterprises using the latest tech stacks like Node.js, Docker, and TypeScript. Let us help you bring your web ideas to life!

Frequently Asked Questions