Who else is excited about the upcoming v12 release 🙂

https://github.com/nestjs/nest/pull/16391

Hello everyone,
Many of you here work on  Database design, so I thought I’d share a tool I’ve built.

I’d been planning for a long time to create a database design tool that truly fits my workflow. And finally, I’ve released my NoSQL (Indexed DB) Powered SQL Database Design Tool (yes, this sounds a bit funny  IMO).

It’s free and open source — anyone can use it. You’re also welcome to give feedback or contribute.
You can create unlimited diagrams with no restrictions. It’s a privacy-focused app — your data stays with you.

After designing a database, you can export directly to Laravel, TypeORM, or Django migration files.
It also comes with zones (with lock/unlock functions), notes with copy and paste capabilities, keyboard shortcuts, and many other features to boost productivity. It’s built to handle large diagrams and is highly scalable.

I hope you’ll like it! Everyone’s invited to try it out:
GitHub: https://github.com/AHS12/thoth-blueprint
App: https://thoth-blueprint.vercel.app/

All good things are coming to Nestjs 😊

Migration guide here

This is such a quality of life improvement.

Finally my multistage docker builds will be much faster.

Not only local development cycles becomes faster but also faster CI pipelines, faster multi-stage Docker builds, faster feedback loops.

This is such a Banger drop for typescript by not writing more JavaScript but Go.

The Math: Tasks that used to take minutes in large projects (like a full type check) are completing roughly 8x to 12x faster due to native code execution and multithreaded worker utilization in Go.

Docker Impact: If step RUN npm run build previously took 2 minutes, t could shrink down to just a fraction of that time inside the ontainer build pipeline.

I was done building my backend and i needed a frontend for that.

When i started with project i thought that i would just build backend and frontend seperately and then figure out how to bind them both.

But then i thought what if there was a better way to tackle this, and i came to know about Monorepos. I knew what the term monorepo was but never worked on it, it was just vaguely an information in my mind.

But then i learned how monorepos are widely used by startups now and hobbyists too.

In the end in just booted up my first monorepo and the whole concept really amazes me.

.

.

I WOULD LOVE TO GET SOME TIPS, FEEDBACKS OR SUGGESTIONS FROM YOU GUYS.

Doing this in Nest.js (see img):
I am using class-validator and class-transformer (the imports from class-validator are not visible in the SS)

2 ideas to remove this long decorator list:
- Combine them for each property. For example, instead of 5 different validators for 'password' (MinLength, HasUppercase, HasLowercase, HasNumber, HasSymbol), they can be combined into a single one (IsStrongPassword, ik class-validator already has one, but I prefer a custom one).
- Use Schema-based validation, zod

OR should I leave it as it is?

P.S.: I have a lot to improve in that code like, the error messages should probably be handled by an Exception Filter. I am trying to learn and improve progressively so, I'll get there

Hey folks,

Working on a large Nest.js codebase at the moment and intrested in seeing how some other teams are working with it.

I'm aware, for example, that Cal.com is built on Nest.js (https://github.com/calcom/cal.com/tree/main/apps/api/v2).

Are ther other open source projects on Nest.js that are worth looking at as a reference for best practices in coding and code org?

Yesterday I was just a NestJS user. Today two of my PRs are merged into the framework, so I wanted to share what the bugs were, in case anyone hit them.

1. Redis microservices with wildcards: true (PR #17866)

If you register a handler like u/MessagePattern('users.*') and call it with client.send('users.created', ...), the handler ran fine, but the reply was published to users.*.reply. Redis PUBLISH doesn't expand globs, and the client was listening on users.created.reply, so every request-response call timed out. Events were unaffected, which is why it went unnoticed since 2022. The fix is one line: publish the reply on the channel the request actually came from (same as the MQTT server already did).

2. Fastify adapter and Content-Type (PR #17867)

FastifyAdapter.reply() checked getHeader('Content-Type') !== 'application/json' literally. A value like application/json; charset=utf-8 was treated as non-JSON, so error responses logged a misleading "Content-Type doesn't match Reply body" warning and the header was rewritten without the charset. Express had the same check and fixed it years ago with startsWith; Fastify now matches.

How I found them: not from issues. I read the code and compared sibling code paths (Redis vs MQTT, Fastify vs Express). When two implementations of the same thing differ, one of them is usually wrong. Each PR came with a test that fails before the change and passes after, and both were merged in under 24 hours.

Links:

• https://github.com/nestjs/nest/pull/17866

• https://github.com/nestjs/nest/pull/17867

Happy to answer questions about the contribution process if anyone wants to get started.

I built Vitrin — an open-source backend architecture project built mostly with NestJS microservices.

The project started as a social content platform backend, but I gradually turned it into a systems-design playground for a Twitter/X-inspired feed architecture.

The goal was not to clone Twitter as a product. I wanted to model the backend problems behind that kind of system: feed fanout, candidate generation, ranking, graph signals, event-driven communication, ML scoring, workflow orchestration and observability.

The domain is simple: users can create posts around movies, series and games. The interesting part is how the backend serves feeds.

There are two main feed paths:

• Following feed — Redis-backed timelines with fanout planning

• Home feed — graph/vector/trending/exploration candidate retrieval, filtering, feature hydration, ML scoring and reranking

The backend includes:

• NestJS / TypeScript microservices

• API Gateway and Realtime Gateway

• gRPC + Protocol Buffers

• RabbitMQ with outbox/inbox pattern

• Redis-backed feed/session state

• PostgreSQL per service boundary

• Neo4j for graph-based recommendation signals

• Qdrant for vector retrieval

• ClickHouse for feed/interaction events

• Python ml-service for scoring/training

• LightGBM ranking pipeline

• workflow-service for sagas

• OpenTelemetry, Prometheus, Grafana, Loki and Tempo

Repo: https://github.com/canccevik/vitrin

Here is the changelog https://github.com/nestjs/nest/releases/tag/v11.0.0

And here is the migration guide https://docs.nestjs.com/migration-guide

Cli is somehow broken for me but else looks fine. (doesnt detect the include args in the config) Please share your experiences with this.

Hello folks, I've created a starter NestJS template that leverages the perks of Bun runtime & API for a more seamless and faster DX. Some of the features worth mentioning in this template are:

• Running entrypoint (main.ts) directly with Bun -> faster server startup, tsc can be added for type checking

• A custom build script using Bun Build API which produces JS output containing bundled source code & bundled node_modules dependencies -> faster server startup, up to twice faster than bun run start:dev of this template

• Leveraging Bun test runner instead of Jest

I also have some other plans such as building a Nest-like dedicated CLI tool (using Bun runtime, ofc) only for this template, testing out other most common libraries used with Nest, and building a documentation for Libraries Guides, ...

The template is ready for experiments. Be sure to read the README carefully, and please report any issues you encounter.

Template URL: https://github.com/dung204/bunest

Diagnose and fix your NestJS code in one command.

nestjs-doctor is a CLI that audits your NestJS app in one command

npx nestjs-doctor@latest .

catches things like slop code from peers or AI in a tipical nestjs project, and gives you a score from 0 to 100.

42 rules across security, performance, correctness, and architecture. zero config.

works in CI too:

npx nestjs-doctor . --min-score 75

fully open source. would love feedback especially on rules people want added.

https://nestjs.doctor/

I’m building Rentyx, a RESTful API for car rental operations using NestJS 11, TypeORM + PostgreSQL, JWT / Clerk, Cloudinary for media, Socket.IO for realtime, and Swagger for docs. I’m sharing my folder layout and key configuration snippets (validation, guards, custom exception filter, pipes, and utilities) to get feedback and maybe help someone starting a similar stack.

• Building “Rentyx” – a NestJS + TypeORM API with Clerk/JWT, Cloudinary & Swagger

• My NestJS project structure and config choices (Auth, DB, Swagger, DX)

• NestJS 11 in practice: validation, guards, exception filters, and more

• Sharing my NestJS setup: modules, auth strategy union, and dev tooling

What I’d love feedback on

• How would you evolve the auth union pattern (Clerk ↔ local JWT) for larger teams?

• Any TypeORM tips for clean migrations across environments?

• Favorite patterns for Cloudinary (caching, eager transforms, signed delivery)?

• Opinions on keeping autoLoadEntities vs explicit imports as the app grows?

Senior web dev at fortune 10. I stumbled upon NestJS two weeks ago and got so excited about it I decided to put together a demo for our broader group of 30ish.

For context, we use dated stacks and work in legacy patterns here, something I’ve been trying to push away from as I come from more modern stacks. Nobody even does presentations here or anything, nobody has motivation to learn new things.

I decided to go all out and made a wonderful PowerPoint, presented with my camera, did some actual whiteboarding on it about an example nest architecture and then did a live coding example where I built some things.

I spun up a nest server with graphql and typegraph with prisma and created then queried data in my db thru prisma and graphql from scratch. I added and used bull to show an example of distributed workload by then setting up another nest micro service to process stuff I dropped in the queue from the main nest server. I also implemented JWT token authentication.

I did this all with my whiteboarding and PowerPoint presentation and live coding example in 45 minutes from no code. It was amazing. Every single thing went perfectly, I had developed a good 700 line read me with the step by step setup process.

I love this tech! The team was extremely impressed despite the fact that they will probably just keep making heavy .net 6 apps and calling them microservices…

The best Nest.js boilerplate now uses Better-Auth for everything authentication and authorization related. Email login, OAuth, Magic Link, Pass Keys, Two-Factor Authentication, etc. everything ready out of the box. Check it out!

https://github.com/niraj-khatiwada/ultimate-nestjs-boilerplate

Hello everyone, I am familiar with the Node.js and build a few backends with it. I want to up skill and thinking of learning a new technology for backend. I learned Nest follows Angular like architecture which I reall worry about as I am working with Angular at my work.

Looking forward for great advice.

Hey Reddit! I've been working with NestJS for about 3 years now, and honestly, it's been great. It's stable, powerful, and truly helps maintain a structured and scalable backend architecture.

Here are 5 things I absolutely love about NestJS:

1. Modular Architecture: Easy to structure code clearly, keeping everything organized and maintainable.

2. TypeScript Integration: Makes debugging and refactoring seamless, significantly reducing runtime errors.

3. Dependency Injection: Simplifies testing and ensures components remain decoupled.

4. Robust GraphQL Support: Out-of-the-box integration, saving tons of setup time.

5. Excellent Documentation and Community: Helpful resources and an active community make learning and troubleshooting effortless.

What excites me most about NestJS, especially after working with it for three years, is how it brings a clear, scalable structure to Node.js development. With pure Node.js, I often found myself reinventing the wheel or spending extra effort managing complexity as projects grew. NestJS, on the other hand, provides powerful building blocks out-of-the-box—like dependency injection, middleware, interceptors, and guards—that simplify complex patterns, making my codebase predictable, maintainable, and much easier to onboard new developers.

P.S. My team at Popcorn is hiring a Backend Engineer! We're building a modern, AI-native telco with an exciting stack including NestJS, GraphQL, AWS, and Terraform. Feel free to check it out here: https://careers.popcorn.space/backend-developer

@nestjstools/messaging a modular and extensible messaging library for NestJS that helps you handle async workflows across queues, topics, and pub/sub systems.

• Clean message handling with MessageHandler() decorators

• Support for multiple buses and routing

• Auto-setup consumers

The library now supports 4 adapters:

Redis
RabbitMQ
Amazon SQS (new)
Google Cloud Pub/Sub (new)

You can mix and match them across different buses for flexible message handling.

Ideas so far:

• ZeroMQ ?

• NATS ?

• MQTT ?

• Azure Service Bus ?

Coming next: Kafka — but I’d love your input!

I’d really appreciate your feedback — let me know if you run into any issues, need clarification, or have ideas for improvements!