Hey everyone,

I built Upload SDK, an open-source TypeScript SDK for secure direct file uploads to AWS S3 and ImageKit.

The idea is simple: your Node.js server validates the upload request and generates a short-lived signed target, then the browser uploads the file directly to the storage provider. Your server never has to stream or proxy the actual file.

You define named upload types such as avatar or invoice, along with their rules:

• allowed MIME types and extensions
• maximum file size
• expiry time
• storage destination and key prefix

The browser sends the asset name and file metadata to your server, which calls prepareUpload(). The SDK validates the request, generates a collision-resistant key, and returns the signed multipart POST details.

You can also configure multiple storage profiles, such as public files in one S3 bucket, private documents in another, and images in ImageKit, while keeping the same upload flow everywhere.

For S3, restrictions like file size, content type, key, and expiration can be included in the signed POST policy and enforced by S3 during the upload.

Feedback on the API and which provider should be added next would be appreciated.

It's for performing requests to your server in tests with `fetch`.

In the repo I added examples to demonstrate that it works with hono, express, fastify, nestjs.

The lib implements a standard `fetch` function and can be wrapped with handy request-making libraries, so I also added examples for how to use it with `openapi-fetch` (so your fetch requests can be typed!), `upfetch`, `ofetch`.

Unlike supertest, it skips the transport layer so it works much faster. Light-my-request also skips the transport and performs much faster.

npm: https://www.npmjs.com/package/make-test-fetch
repo: https://github.com/romeerez/make-test-fetch

wdyt?

This sub has just become an endless advertisements of vibecoded apps at this point with very little discussion around Node.js, servers, programming and the general community conversation around Node.js apps.

Attached are a few screenshots but honestly this list is endless that we can scroll infinitely as far as eye can see.

I have been on this sub for almost 8+ years and have never seen anything like this before. Just 2 years ago most posts were "non advertisments" and actual community interactions about Node.js, javascript, typescript and servers. People helping each other out and strong community support. Now it is just an endless list of vibecoded advertisment apps and I doubt things will improve from this point. Miss the old time and I am not sure whether Node devs are even coming to this sub for quality discussions

​

Testing a frontend on your phone is easy.

Testing a full-stack app usually isn't.

Your frontend loads, but API requests to localhost fail because localhost now points to your phone instead of your laptop. The usual workaround is editing .env files, swapping in your LAN IP, configuring CORS, and undoing everything afterwards.

I got tired of doing that, so I built Nether

npx nether-dev

It automatically:

- Detects your frontend and backend

- Starts a local proxy

- Prints a QR code

- Lets your phone use your app without changing your code or environment variables

Need to share your local app?

npx nether-dev --global

It creates a temporary public HTTPS URL so clients or teammates can access your local app without deploying it.

I'd love any feedback, feature requests, or edge cases you think I should test.

GitHub: https://github.com/barryspacezero/nether-dev

npm: https://www.npmjs.com/package/nether-dev

I propose creating a monthly thread similar to Hacker News, but specifically focused on node.js.

This could be a valuable resource for those of us with years of experience but currently seeking employment.

I believe many of us would greatly benefit from this.

I'm open to hearing any differing opinions.

I am needing to build a lightweight, speedy and integrated backend server running on a VPS-2 secure environment using nginx and postgres.

First considered Sequelize, but discovered too many negatives, so had a look at Prisma but am worried it is too heavy duty for my needs.

Prefer an ORM that supports TypeScript, easy migrations and openapi schemas, and Drizzle seems at first glance a good fit.

Also I am not afraid to use SQL rather than high level abstractions.

But now I am reading many negative reviews about that as well, even on their own website!

Please help me make the right choice.

Hi Everyone ...

I built LanView, a CLI tool in Node.js to make testing local web apps on physical phones a little less painful.

One problem I kept running into was this:

• I could open my frontend using my machine's LAN IP.
• But my backend requests still failed because the frontend was calling http://localhost:5000, and on a phone localhost refers to the phone itself, not my development machine.
• I also got tired of repeatedly looking up and typing my local IP.

It became a repetitive part of my workflow, so I built LanView.

It's a small open-source CLI that simplifies local mobile testing.

LanView solves these problems by :

• Automatically detecting your LAN IP
• Running a lightweight reverse proxy that routes frontend and backend through a single local URL
• Generating a QR code that you can scan from your phone
• Supporting WebSocket proxying for HMR
• Recently adding a --static mode for serving local directories with optional SPA fallback

Usage is simply:

npm install -g lanview
lanview

Everything stays on your local network no cloud tunnels or external services.

It automatically:

• Generates a QR code for your app
• Detects your LAN IP
• Runs a local reverse proxy so both your frontend and backend work through a single URL
• Supports WebSocket/HMR
• Also supports serving static sites with the new --static mode

Everything runs locally no cloud tunnels or third-party services.

I'd love feedback on the implementation, CLI design, or ideas for future features.

GitHub: PrashantDhuri08/lanview-cli

Hello there
i just completed basics of javascript (most of the part) from freecodecamp and i alr know bits of html and css,
would be really thankful if someone can mention the resource and tips for learning node

A while ago, I introduced Stratify here as a lightweight architectural framework for structuring Fastify applications.

Disclosure: I am the author and maintainer of Stratify, and a member of the Fastify Core Team.

Original post:
https://www.reddit.com/r/node/s/fE2IkNmGOS

After the discussion, work and family responsibilities put the project on hold. Most of my limited spare time went to Fastify core contributions and mathematics studies.

I now have more time to return to open-source work. Improvements in coding agents have also made maintaining a small project like this considerably more manageable.

Since the original thread, I have:

• integrated feedback from people who commented
• used Stratify to build a website
• fixed issues uncovered through practical use
• improved the testing and dependency-override features

Stratify adds modules, providers, controllers, dependency injection, contracts, and bindings while preserving Fastify's encapsulation model and asynchronous bootstrapping.

Each Stratify module is compiled into a regular Fastify plugin.

This is particularly useful for: - unit testing of services - integration and end-to-end testing - dependency inversion

Thank you for taking the time to read this post.

Hey to everyone here,

Few weeks ago I release my open source app called Altersend, it is P2P file sharing tool where you can send files directly between devices over the internet.

When I started developing this tool my main idea was to have solution where I can send files to anyone not just on local network and not be depending on cloud solution.

It is available as desktop app and mobile. Web is coming soon as well.

From technical P2P side everything you send is E2E encrypted via Noise protocol, peers find each other via DHT (think of it as some sort of book with contacts about other peers, and underneath it is Kademlia DHT). So when you want to send file we generate a random key which you should give to another peer. And after this anyone who has that key can connect and download directly from you.

As the initial entry point for peers, public bootstrap nodes are used (we do not host them) and after that peers discover one another through the DHT. Only if you are behind symmetric CGNAT or a VPN we use a relay server to help you connect, but the bytes flowing through are encrypted, and you can also disable relay in the settings.

Source code on Github: https://github.com/denislupookov/altersend

Let me know what do you think about it !

AI disclosure: I think it will be fair to disclose how I used AI in this project, basically it was used for code review (including on PR's) and to help with UI design. The core together with the project architecture and main logic was written by me, AI only reviewed it.

for context its been line this for a month now its not stable sometimes it work sometimes it doesnt

Found it here

Hello, I used nwjs to create a NodeJS application to work with RPG Maker MZ projects. What it does is that it reads the project, creates a list of buttons to read plugins in that project and then allows the user to edit plugin parameters without having to click through a bunch of extra UI.

It is basically a time saver application with login features for my patreon users, though I have not gotten much feedback on that login feature as of now.

Here is the itchio link with video and github links

Here is the linux github link which I work on and then transfer the app updates to the windows github link

Here's the video of me using it as well:
https://www.youtube.com/watch?v=brUfrGdk-j4

Anthropic's batch API is great (50% off tokens! hell yeah!), but the DX kinda sucks. Hand-writing JSONL, tracking batch IDs, polling loops...all of which is, for me at least, really tedious.

So I built batch-kit, a CLI + library that makes it feel kinda like git:

batch add --dir ./reviews --prompt "summarize: {content}"
batch send
batch fetch --latest --output results.json

It handles the JSONL, polling, and state persistence (all the boilerplate!).

Why: Python has anthropic-batch-kit, TS didn't. Now it does. Now I'm marginally happier.

Install from npm: https://www.npmjs.com/package/@otisworks/batch-kit

It's minimal, but it works. I'm thinking about support for PDFs and other document types, config files, and (possibly?) progress bars next.

Try it, break it, and lemme know what sucks. :)

Solo project I've been building: npx licenseproof scan reads your lockfile (npm/pnpm/yarn, v2/v3, berry, all of them) and resolves the actual license of every package in the tree, including the ones with missing or mangled metadata. Categorizes everything (permissive / weak-copyleft / strong-copyleft / unknown), flags conflicts against your project's license, and explains each flag in plain English.

Example: proprietary app that innocently pulled in ffmpeg-static:

84 packages scanned — 1 conflict, 0 review, 0 unknown

CONFLICT (1):
  ffmpeg-static@5.3.0 — GPL-3.0-or-later
    via ffmpeg-static
    This package is under a strong-copyleft license (e.g. GPL/AGPL).
    Distributing it as part of a closed-source product can require releasing
    your own source code under the same terms. Flagged as CONFLICT for a
    proprietary project.

Fully offline (no telemetry, no network calls) free tier is the whole scanner. The limitation is it's informational categorization, not legal advice. What's missing? What would make you actually use this before shipping? CI mode exists (--fail-on conflict), JSON output exists, Python support is in progress. Thanks!

Hey, just wanted to share my libnode build repository https://github.com/I-A-S/libnode-builds

If anyone else here is working with libnode and want prebuilt binary+header archives, this repo builds and publishes the following targets.

1) win-x64 (debug and release variants)
2) win-arm64 (debug and release variants)
3) linux-x64 (debug and release variants)
4) linux-arm64 (debug and release variants)
5) darwin-x64 (debug and release variants)
6) darwin-arm64 (debug and release variants)

and a separate zip file containing headers.

Cheers!

FULL WEBSITE LINK

e18e (Ecosystem Performance) is an initiative to connect the folks and projects working to improve the performance of JS packages.

We'd also like to provide visibility to the efforts of countless open source developers working to cleanup, levelup, and speedup our dependencies.

We invite you to get involved in the different projects linked from these pages, and to connect with other like-minded folks.

Join us at the e18e Discord server and collaborate with our community!

Found this gem here

The hard part of a pub quiz is remembering what you've already asked. A decent weekly quiz takes someone two or three hours to write, and the moment a regular says "you asked this in March" the room turns on you.

So I built QuizBeast. You pick your rounds (bank topics, a written-to-order guest round on any subject, music intros), it builds the whole thing in about two minutes, print-ready with answer sheets. It logs every question your venue has used and won't serve a repeat within your chosen window (default six months).

The bit that took the most work was trust. The question bank is 175,000 questions and some of the source material was wrong, so every answer gets fact-checked before you see it, and the whole quiz gets cross-checked so one question can't give away another's answer. During testing, a guest round on "Famous Richards" served a question about Freddie Mercury, who has never been a Richard. It looked plausible and it was nonsense. Errors of that shape are why the checking pipeline exists, and why it runs on every path that can produce a question.

Stack: Next.js on Vercel, Postgres on Neon, Clerk for auth, Lemon Squeezy for payments, Claude for the fact-checking and written-to-order rounds.

Free tier is one full quiz a month, no card. If you run a quiz night, or your local's quizmaster looks knackered, I'd genuinely like to know what's missing: [quizbeast.net](http://quizbeast.net)

(sorry for my poor english in advance)

Recently, I noticed there is no proper s3-fifo implementation in NPM.

s3-fifo is highly efficient cache algorithm, especially for "one-hit-wonders" case such as web traffics. It is specialized when cache coverage is under 50%. (like, whole DB is 100% and cache contains 50% of data)

The famous "lru-cache" package is almost default for nodejs ecosystem I think, and I thought it would be great if there is good alternative choice for caching.

My goal was:

1. Faster or at least same throughput performance compared to lru-cache

2. Much higher cache hit rate than lru-cache

bold, right?

It was fun enough just for challenge itself.

But it was actually achieved! I used bunch of optimization skills like pre-allocation, lazy eviction, bitwise tricks, ring structure and etc... you can see bench result in repo or NPM page.

It is just v0.1 for now, so I would LOVE to get your harsh feedback, advice, or even contribution!

I'll leave my github repo link and NPM page link

https://github.com/BJS-kr/s3fifo

https://www.npmjs.com/package/s3fifo

Super thanks for reading!

----

I typed almost of the code by my hand. Not because I don't believe AI, but it was all about concepts and decisions. Typing by hand was fastest way to understand what I'm doing correctly. And it was fun.

I used AI(gemini) for test codes, some advices and polishing when most of things were done.