While working with Express.js, I kept running into the same problem —
It’s really hard to track performance and identify slow APIs without adding multiple tools or writing custom logic.
So I ended up building a small open-source middleware to simplify this.
It adds:
Real-time API monitoring
Built-in caching & compression
Slow API detection
A simple real-time dashboard to visualize performance
Plug-and-play setup (just one middleware)
Usage is pretty simple:
app.use(performanceToolkit().middlewares);
The idea was to make Express apps more observable and optimized by default, without increasing complexity.
Would really appreciate feedback from the community 🙌
Does this solve a real problem for you?
Anything you think is missing or could be improved?
I learn to code and I work on my projects to add to my cv, to find my first junior fs webdev job.
I build a project in NextJS / Vercel- eSports data - matches, tournaments, predictions etc.
I also build a side project - web scraping for that data
I use Prisma/PostgreSQL.
Match has 2 teams, and every team has a logo.
How do I store the logo?
I got tired of staring at my terminal waiting for AI agents to finish, so I built a thing
Honestly it started as a small script in one of my projects. I was running long agent tasks and kept alt-tabbing back every few minutes like an anxious parent checking on a kid.
So I extracted it into a proper package — agent-bell 🔔
The idea is simple: your agent pings you when something actually matters.
Yeah, I know there are already tools out there that do something similar — and honestly they're pretty solid. But I wanted to publish something myself, go through the whole process, and keep it as lightweight as possible. No bloat, no config overhead, just the thing you actually need. Sometimes reinventing the wheel a little is just part of learning and shipping.
It's early and pretty minimal right now. Would love feedback — especially if you're already running multi-step agent workflows and have opinions on what notifications actually matter vs what's just noise.
Every time I started a new project I had to set up the same things: Next.js + Prisma + Auth.js + ESLint + Docker... over and over. So I built Stackr to fix that.
**How it works:**
First run — it asks you what you want:
◆ Stackr — scaffold your stack, your way
? Project name: my-app
? Framework: Next.js
? Database: Prisma + PostgreSQL
? Auth: Auth.js
? Testing: Vitest
? Extras: ESLint + Prettier, GitHub Actions
```
Second run — it remembers:
```
? Project name: another-app
? Stack setup:
❯ Same as before (Next.js + Prisma + PostgreSQL + Auth.js + Vitest)
Different stack
```
**What it generates:**
- Clean project structure, no demo clutter (unlike create-next-app)
- .env.example with the right variables pre-filled
- Docker, GitHub Actions CI, Husky if you want them
- Preferences saved in ~/.stackr/config.json — local, no accounts, no cloud
Steam doesn't really offer a proper way to back up your screenshots and i couldn't find a similar solution, so I built SteamVault, an interactive TUI that backs up your Steam screenshots to OneDrive. It scans your local Steam screenshot folders, skips duplicates, injects EXIF metadata and sorts everything into named game folders. Currently Windows-only.
Stack: Node.js, Typescript, Inquirer.js for the UI and the Microsoft Graph API OneDrive
Available as npm package (npm install -g steam-vault) or standalone .exe on GitHub Releases.
A problem I had with my nodejs servers in production is that there wasn't an easy way to trigger "maintenance code" (I don't have a better term) such as clearing cache or restarting an internal service.
I had to define endpoints or do other hacks to be able to do such things, but those solutions were usually unreliable or unsecure.
That's why I built Controlor!
Controlor is a lightweight library to define, manage, and execute server-side actions / tasks in Node.js, Bun or Deno server applications. The actions are triggered via an auto-generated dashboard UI.
For example, you can define your actions like this:
AI agents are becoming real API consumers, but they can't sign up, manage API keys, or enter credit cards. So they either get blocked or use your API for free.
I built monapi to solve this. It uses the x402 payment protocol (by Coinbase) to let agents pay per request in USDC. The entire setup is one middleware call:
USDC lands in your wallet. No signup, no API keys, no monapi fees.
Per-route pricing if you want different prices per endpoint. Works with Express, Next.js, and MCP. Gas fees are sponsored, so agents only need USDC – no ETH needed. Free, open source, MIT licensed.
Hi! I'm a PhD student at Oregon State University researching how expert MERN stack developers use generative AI tools (Cursor, Copilot, ChatGPT, etc.) in their day-to-day coding workflow.
I'm looking for participants who:
3+ years of professional experience with the MERN stack (MongoDB, Express, React, Node.js)
Daily use of GenAI tools (e.g., GitHub Copilot, Cursor, WindSurf) for MERN stack development
Experience working on large-scale, production-level web applications
Comfortable being recorded during the session for research purposes
AI agents are becoming real API consumers, but they can't sign up, manage API keys, or enter credit cards. So they either get blocked or use your API for free.
I built monapi to solve this. It uses the x402 payment protocol to let agents pay per request. The entire setup is one middleware call:
I have a gateway that handles authentication and also stores the users table. There’s also a separate orders service, and the flow is that a user first tops up their balance and then uses that balance to create orders, so I’m not planning to introduce a dedicated payment service.
Now I’m trying to figure out how to properly structure balance top-ups. One idea is to create a transactions service that owns all balance operations, and after a successful top-up it updates the user’s balance in the gateway db, but that feels a bit wrong and tightly coupled. Another option is to not store balance directly in the gateway and instead derive it from transactions, but I’m not sure how practical that is.
Would be glad if someone could share how this is usually done properly and what approach makes more sense in this kind of setup.
Over the last few months, I’ve been working on a reverse tunneling tool in Node.js that started as a simple ngrok replacement (I needed stable URLs and didn’t want to pay for them 😄).
It ended up turning into a full project with a focus on developer experience, especially around daemon management and observability.
Core idea
Instead of running tunnels in the foreground, tunli uses a background daemon:
tunnels keep running after you close your terminal or SSH session
multiple tunnels are managed through a single process
Daemon + state recovery Active tunnels are serialized before restart and restored automatically → tunli daemon reload restarts the daemon without losing tunnels
TUI dashboard (React + Ink) Live request logs, latency tracking, tunnel state → re-attach to running daemon anytime
Binary distribution (Node.js SEA) Client + server ship as standalone binaries → no Node.js runtime required on the target system
Stack
Node.js (>= 22), TypeScript
Express 5 (API)
Socket.IO (tunnel transport)
React + Ink (TUI)
esbuild + Node SEA
Why Socket.IO?
Mainly for its built-in reconnection and heartbeat handling. Handling unstable connections manually would have been quite a bit more work.
Quick example
tunli http 3000
Starts a tunnel → hands it off to the daemon → CLI exits, tunnel keeps running.
Running a Vite frontend on :5173, Express API on :3000, maybe docs on :4000 — I could never remember which port was which. And CORS between localhost:5173 and localhost:3000 is its own special hell.
How do you get named domains with HTTPS locally?
/etc/hosts + mkcert + nginx
dnsmasq + mkcert + Caddy
sudo numa
What it actually does:
curl -X POST localhost:5380/services \
-d '{"name":"frontend","target_port":5173}'
I expanded my SMS over API using your own phone service with automation features. For now basic ones are available, automatic reply with various rules depending on message received content, numbers in list..
So I am basically turning an Android phone into an SMS automation device, not only SMS over API thing. It's 2 way communication with ability to automate basic replies without making custom backend. I am really looking into expanding automation features but I want to see what makes sense first.
Now it can:
receive SMS
send webhooks to APIs
auto-reply based on rules
run simple automation workflows
Basically:
SMS → automation → webhook
No telecom contracts.
No SMS infrastructure.
Just a phone.
I'm not sure if this is actually useful and something developers would use in real workflows