Node.js or PyTorch First: What Beginners Should Learn

// Node.js — a small API in 30 lines.
// The minimum viable backend — and a real portfolio piece.

const express = require("express");
const app = express();

app.use(express.json());

let todos = [
  { id: 1, title: "Learn Node", done: true },
  { id: 2, title: "Build an API", done: false },
];

// GET — list everything
app.get("/api/todos", (req, res) => {
  res.json(todos);
});

// POST — add one
app.post("/api/todos", (req, res) => {
  const newTodo = {
    id: Date.now(),
    title: req.body.title,
    done: false,
  };
  todos.push(newTodo);
  res.status(201).json(newTodo);
});

// DELETE — remove one
app.delete("/api/todos/:id", (req, res) => {
  todos = todos.filter((t) => t.id !== Number(req.params.id));
  res.status(204).end();
});

app.listen(4000, () => console.log("API running on http://localhost:4000"));

// What this teaches:
// - HTTP methods and status codes
// - JSON request/response handling
// - Basic routing
// - A real, deployed skill you can put on a resume

// Why Node first for most beginners:
// - Prerequisites: JavaScript only
// - Time to first real project: 2–4 weeks
// - Time to job-ready: 6–9 months
// - Job market: enormous, in every city
//
// A backend role is the fastest and most reliable
// entry into a paid software career.

# PyTorch — a minimal training loop.
# This is the "hello world" of deep learning.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Build a tiny model
class TinyNet(nn.Module):
    def __init__(self, in_features, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, 64),
            nn.ReLU(),
            nn.Linear(64, num_classes),
        )

    def forward(self, x):
        return self.net(x)

# Dummy data — replace with your real dataset
X = torch.randn(1000, 20)          # 1000 samples, 20 features
y = torch.randint(0, 3, (1000,))   # 3 classes
loader = DataLoader(TensorDataset(X, y), batch_size=32, shuffle=True)

# Model, loss, optimizer
model = TinyNet(in_features=20, num_classes=3)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# The training loop — this is the pattern to memorise
for epoch in range(10):
    for batch_X, batch_y in loader:
        optimizer.zero_grad()
        logits = model(batch_X)
        loss = criterion(logits, batch_y)
        loss.backward()
        optimizer.step()
    print(f"epoch {epoch+1} | loss {loss.item():.4f}")

# What this teaches:
# - The training loop (forward, loss, backward, step)
# - Tensors, batches, and optimisers
# - The core pattern behind every deep learning model

# What PyTorch requires BEFORE it makes sense:
# - Python fluency
# - Basic linear algebra (vectors, matrices, dot products)
# - Basic calculus (derivatives, chain rule)
# - Some intuition for probability and loss functions
#
# This is why PyTorch is not the right first tool
# for most beginners — the prerequisites take months
# to build, and the reward (a job) takes longer.

# Serving a PyTorch model from Node.js — the full picture.
# This is what "backend + ML" actually looks like in production.

# ── Step 1: A Python service that loads and serves the model ──
# model_service.py

from fastapi import FastAPI
from pydantic import BaseModel
import torch
import torch.nn as nn

class TinyNet(nn.Module):
    def __init__(self, in_features, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, 64),
            nn.ReLU(),
            nn.Linear(64, num_classes),
        )
    def forward(self, x):
        return self.net(x)

app = FastAPI()
model = TinyNet(in_features=20, num_classes=3)
model.load_state_dict(torch.load("model.pt"))
model.eval()

class PredictRequest(BaseModel):
    features: list[float]

@app.post("/predict")
def predict(req: PredictRequest):
    x = torch.tensor([req.features], dtype=torch.float32)
    with torch.no_grad():
        logits = model(x)
    probs = torch.softmax(logits, dim=1)[0].tolist()
    return {"probabilities": probs}

# ── Step 2: A Node.js backend that calls the Python service ──

const express = require("express");
const app = express();
app.use(express.json());

app.post("/api/predict", async (req, res) => {
  const response = await fetch("http://localhost:8000/predict", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ features: req.body.features }),
  });
  const data = await response.json();
  res.json(data);
});

app.listen(4000, () => console.log("Node backend on :4000"));

# ── Step 3: The result ──
# Frontend → Node.js API → Python/PyTorch service → prediction
#
# This is a real production architecture:
# - Node handles the web layer (auth, routing, user data)
# - Python handles the ML layer (model inference)
# - Each is used where it is strongest

# What this teaches:
# - Node and PyTorch are not competitors — they are layers
# - The order depends on where you want to sit in the stack
# - A backend developer + an ML engineer is the ideal team
#   (and one person can hold both skills over time)
#
# This is the reason "Node or PyTorch first?" is not
# really the right question. The right question is:
# "What role do you want to play, and in what order
#  does the market pay for the skills?"