Tangy is building your next step
Shaping the lesson around what you want to make.
Tangy is building your next step
Shaping the lesson around what you want to make.
Computer Science
Learn the core fundamentals of distributed systems—consistency, availability, partition tolerance, and consensus—by building a live, interactive multi-node cluster simulation using Node.js, Express, and React.
Build it yourself, get guided when you are stuck, and leave with proof you can actually show.
Follow the path module by module. The layout keeps the lesson count, your progress, and the module description in one scan.
Scaling Horizontally: Setting up the Cluster
2 lessonsSpin up multiple independent Node.js server instances representing database nodes, and build a React dashboard to monitor their health dynamically.
Replication & Fault Tolerance
2 lessonsDesign a primary-backup replication system. Learn what happens to consistency and availability when nodes go offline or network delays happen.
Network Partitions and Quorum Consistency
2 lessonsSimulate network splits where nodes cannot talk to each other, and implement Quorum Read/Write rules to maintain strong consistency.
Coordination and Consensus Patterns
2 lessonsRemove the single point of failure by implementing node heartbeats and a simplified Leader Election algorithm to automatically select a new coordinator.
Public lesson
To build a distributed system on a single machine, we need a way to simulate multiple independent servers. The simplest way to do this is to run the same codebase on several different ports at the same time. Let's configure a single Express application to spin up multiple instances dynamically, and use TypeScript to make sure they speak the exact same language.
Tasks
Instead of hardcoding a single port like 3000, we can loop through an array of ports and start an Express instance on each one. Create or open your server.ts file. We need to define which ports our nodes will run on, and then initialize an Express app for each one.
Here is the structure:
import express from 'express';
const ports = [3001, 3002, 3003];
ports.forEach((port) => {
const app = express();
app.use(express.json());
// Define endpoints here
app.listen(port, () => {
console.log(`Node server running on port ${port}`);
});
});
import express from 'express';
const ports = [3001, 3002, 3003];
ports.forEach((port) => {
const app = express();
app.use(express.json());
// Define endpoints here
app.listen(port, () => {
console.log(`Node server running on port ${port}`);
});
});
Complete the loop so that every port in the list starts its own active server.
Tasks
Run your server using your TypeScript execution tool (like ts-node or tsx). If your loop is correct, you should see both confirmation logs in your terminal. You can also open a second terminal and test both endpoints.
When Node 4001 sends a message to Node 4002, we need to guarantee both sides agree on the structure of the data. Without this, one change in our payload structure can break the entire network silently. Let's define a strict message shape using TypeScript.
Tasks
In your server.ts, add an interface for our network messages.
Tasks
Now, let's update createNodeServer to handle incoming messages of this type. Add a POST /message endpoint inside your createNodeServer function. The skeleton below parses the request body. You need to assign the typed interface to the parsed body and log the incoming data.
To verify our typed boundary works, we need one node to send a message to another. Let's add a quick trigger route /trigger-ping to our servers. When we hit this route on port 4001, it will send a typed message to port 4002.
Tasks
Add this endpoint inside your createNodeServer function, right below the /message endpoint:
Tasks
To verify your work, restart your server process in your terminal: Trigger the ping from port 4001 using curl in a separate terminal window: Look at your server logs. You should see Node 4002 print the formatted message showing it safely parsed the typed data sent by Node 4001.
4 modules · 8 lessons
Scaling Horizontally: Setting up the Cluster
Replication & Fault Tolerance
Network Partitions and Quorum Consistency
Coordination and Consensus Patterns
Learn by building your own version.
Remix this public project to open the workspace, follow the guided build, and let the AI mentor teach you through the work instead of doing it for you.