Continuous Deployment Made Easy: Automate Node.js Deployments on Seenode Using GitHub Actions

Deploying a Node.js application manually can quickly become stressful—pushing changes, tweaking environment variables, restarting the app, and hoping everything works. But what if deployment could be automatic, reliable, and hands-free?

In this guide, using a Node.js app, you’ll learn how to automate deployments to Seenode with GitHub Actions, following clear, step-by-step instructions you can apply immediately. I’ll be using the Slangify App.

Table of Contents

• Table of Contents

• Features of our App

  • Architectural Overview of Slangify

• Why Deploy to Seenode?

  • Production Readiness Checklist for Seenode Deployment

  • Push Your Project to GitHub

  • Deploy Your Project to Seenode

  • Configuring Seenode Build & Start Commands

  • Choosing a Deployment Plan

  • Setting Up GitHub Actions for Your CI/CD Pipeline

  • Add the GitHub Actions Workflow in your Project Folder

  • Push to Main and Watch Deployment Happen Automatically

  • Add a Health Check (Optional but Recommended)

• How the Deployment Actually Works Internally

• Final Thoughts — CI/CD Should Not Be Complicated

Features of our App

Slangify is a simple application that supports:

• Text-to-slang translation

• Multi-word phrase support

• Sentence capitalization

• Responsive UI

Architectural Overview of Slangify

• Slangify is structured for modern development and deployment:

  • Backend: Node.js + Express

  • Frontend: Plain TypeScript + TailwindCSS

  • Data source: Slang dictionary embedded in utils/slangify.ts

  • API endpoints:

    • /api/slang – POST endpoint for text-to-slang translation

    • /health – GET endpoint for uptime monitoring

The backend uses utils/slangify.ts to perform multi-word phrase matching and text transformation:

// backend/src/routes/slang.ts
import { translateToSlang } from "../utils/slangify";

app.post("/api/slang", (req, res) => {
  const { text } = req.body;
  const slang = translateToSlang(text);
  res.json({ input: text, slang });
});

The frontend communicates with the backend via fetch requests:

// frontend/src/main.ts
async function slangifyText(text: string) {
  const resp = await fetch("/api/slang", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text }),
  });
  const data = await resp.json();
  return data.slang;
}

Root-level scripts handle development and production builds:

// backend/package.json
"scripts": {
  "dev": "ts-node-dev --respawn --transpile-only src/main.ts",
  "build": "tsc -p tsconfig.json",
  "start": "node dist/main.js",
  "lint": "eslint . --ext .ts"
}

// frontend/package.json
"scripts": {
  "dev": "ts-node-dev --respawn --transpile-only src/main.ts",
  "build": "esbuild src/main.ts --bundle --minify --sourcemap --outfile=../backend/public/main.js && cp index.html ../backend/public/index.html"
}

If you don’t have a Node.js project, you can clone the Slangify GitHub repo. The setup is fully configured, so you can follow along and verify each step as you go. The project is clean, modular, and perfect for CI/CD.

Why Deploy to Seenode?

Most cloud platforms expect you to configure infrastructure before writing code. Seenode flips that around—you write code and Seenode handles infrastructure.

And the best part: a dedicated GitHub Action that deploys your app with a single YAML block.

This makes Seenode the perfect choice for modern Node.js applications.

Production Readiness Checklist for Seenode Deployment

Seenode will run your built backend, since we are using TypeScript, in your package.json, confirm you have:

"build": "tsc -p tsconfig.json"

After running npm run build, you should see:

/backend/dist
/frontend/* (plain TypeScript, already copied or bundled manually into backend/public)

Ensure your backend’s entry file is production-ready

Seenode expects your final output to be a Node.js runnable file:

backend/dist/main.js

Confirm your server listens on the correct port

Seenode injects the port using process.env.PORT.

Your server should include this:

const port = Number(process.env.PORT || 80);
const host = "0.0.0.0";
app.listen(port, host, () => console.log(`Server running on ${host}:${port}`));

If you’re using the slangify-app-main repo, this is already set.

Push Your Project to GitHub

Your folder structure should resemble:

/slangify-app
├── frontend
├── backend
├── .github/workflows/deploy.yml
└── README.md

Commit and push everything:

git add .
git commit -m "Initial project setup"
git push -u origin main

Deploy Your Project to Seenode

This is the only manual step before automation kicks in.

Log into Seenode or sign up.

Create your account and connect your Github profile:

Connect the exact app you want to deploy:

Configuring Seenode Build & Start Commands

Once Seenode connects to your GitHub repository, it automatically scans your project structure.
However, the platform still needs to know exactly how to build and start your application, especially when your project uses a split architecture like:

• backend/ : Node.js + Express

• frontend/ : TypeScript + Tailwind + ESBuild

For the Slangify App, these are the exact commands I used during deployment.

Build Command (Full Project Build):

cd backend && npm install && npm run build && cd ../frontend && npm install && npm run build

This command performs the following:

1. Installs backend dependencies

2. Builds the Express backend into /backend/dist

3. Installs frontend dependencies

4. Compiles the TypeScript frontend and outputs files into /backend/public

Start Command (Production Server Start):

cd backend && npm start -- -p 80

This ensures Seenode starts your Node.js API on port 80, which is required for public traffic. In the Port field, enter 80.

Choosing a Deployment Plan

One of the coolest things about Seenode is how minimal and developer-friendly their pricing is compared to other platforms. You can pick the plan that best suits your project needs, and every new deployment comes with a free 7-day trial.

For this Slangify walkthrough, we’ll choose the Basic Plan, starting with the free trial to get everything up and running. Choose “Start” to deploy your app.

If you followed the steps correctly, your app will now be deployed and visible on your Seenode dashboard. Simply copy the URL to open and view your app in the browser.

Setting Up GitHub Actions for Your CI/CD Pipeline

On your Seenode Dashboard, open your Profile menu, then go to Account Settings and select API.

Click on Create new secret key. Enter your preferable name and Generate new secret key.

Copy it (you’ll need it only once)

In your GitHub project repo, open the Settings tab, navigate to Secrets and Variables → Actions, and create a new secret. Add the following:

Name: SEENODE_API_TOKEN
Value: your-generated-secrete-key

Done.

Add the GitHub Actions Workflow in your Project Folder

Inside .github/workflows/deploy.yml, add this:

name: Deploy Slangify to Seenode

on:
  push:
    branches:
      - main # trigger on push to main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      # 1. Checkout repository
      - name: Checkout repo
        uses: actions/checkout@v3

      # 2. Setup Node.js
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "20" # use latest LTS version

      # 3. Install backend dependencies
      - name: Install backend dependencies
        working-directory: ./backend
        run: npm install

      # 4. Install frontend dependencies
      - name: Install frontend dependencies
        working-directory: ./frontend
        run: npm install

      # 5. Build frontend
      - name: Build frontend
        working-directory: ./frontend
        run: npm run build

      # 6. Build backend
      - name: Build backend
        working-directory: ./backend
        run: npm run build

      # 7. Trigger Seenode Deployment
      - name: Trigger Seenode Deployment
        run: |
          curl -X POST \
            -H "Authorization: Bearer ${{ secrets.SEENODE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d '{"gitCommitSha": "${{ github.sha }}"}' \
            "https://api.seenode.com/v1/applications/${{ secrets.SEENODE_APPLICATION_ID }}/deployments"

This is the entire CI/CD pipeline.

Push to Main and Watch Deployment Happen Automatically

Every push to main now triggers:
1. GitHub Actions pulls your code
2. Installs frontend + backend dependencies
3. Builds both projects
4. Sends the output to Seenode
5. Seenode deploys instantly

To test:

git commit -m "Enable CI/CD"
git push origin main

Go to your GitHub Actions

You'll see:

✔ Build completed  
✔ Deploy completed

Your app is now deployed automatically, and it’s forever.

Add a Health Check (Optional but Recommended)

Seenode works great with health endpoints. The backend of slangify app already includes one:

app.get("/health", (_req, res) => {
  res.json({ status: "ok", timestamp: new Date().toISOString() });
});

This allows Seenode (and you) to monitor uptime.

How the Deployment Actually Works Internally

Here’s what happens every time you push code:

• GitHub Actions compiles frontend - /frontend/dist

• Compiles backend - /backend/dist

• Sends code to Seenode

• Seenode detects Node.js, package.json, and server entry

• Injects NODE_ENV and PORT

• Starts the app as a managed Node.js process

No Docker, zero manual configuration!

Final Thoughts — CI/CD Should Not Be Complicated

I’ve worked with different deployment environments, and most of them either oversimplify the process or make it far more complex than it needs to be.

With Seenode + GitHub Actions:

• Deployments are hands-free

• Developers focus on coding, not infrastructure

• Updates happen automatically with every push

So if you want painless deployments for your Node.js apps, give Seenode a try, it takes just 5 minutes.

If you found this guide helpful, please give it a like. For more insightful tutorials, let’s connect on LinkedIn.