r/nestjs

Hi everyone, I’m currently learning NestJS and preparing to apply for Fresher Backend Developer positions.

What skills, knowledge, and personal projects should a Fresher NestJS developer have to be considered job-ready?

What would you recommend focusing on the most?

Thanks!

Hi guys, I have a bit knowledge of node js and trying to learn nest js now. How hard is it to learn nest js?

For a small NestJS service, I’m thinking of keeping alert delivery outside the normal response path. If a Telegram or webhook notifier times out, should the exception filter only record the notifier failure and let the request complete, or are there cases where the application error should include delivery failure? How do you keep retries and queue size bounded?

Single-threaded JS execution ≠ single-threaded runtime.

How do you explain the distinction?

Keeping HTTP handlers and queue consumers in one Nest application is convenient at the beginning: one dependency graph, one deployment, and fewer moving parts. The tradeoff appears when worker load, shutdown behavior, or scaling decisions begin affecting request latency.

My current boundary would be to share domain modules and infrastructure providers, but give the API and worker separate bootstrap entry points and separate processes once they need independent scaling or failure isolation. Each should have its own health checks and graceful shutdown path while using the same application services.

Do you split workers from day one, or wait for a concrete operational signal? What signal made the separation worthwhile?

For endpoints that trigger payments, webhooks, or queued work, a retry can produce duplicate side effects. I’ve seen idempotency handled in an interceptor, inside each use case, or at the database boundary with a unique key.

An interceptor is reusable, but it may not know the transaction boundary. Use-case code has the context, but every endpoint must implement the same lifecycle.

For a NestJS service backed by PostgreSQL, where do you store and enforce idempotency keys? How do you handle a second request that arrives while the first one is still processing?

I was facing intermittent ETIMEDOUT errors between my Next.js app and Neon PostgreSQL, mainly while Prisma was running queries. After debugging, I found that my VPS had IPv6 connectivity issues and Node was sometimes trying IPv6 first. I fixed this by forcing Node to prefer IPv4 using NODE_OPTIONS=--dns-result-order=ipv4first and configured a proper PostgreSQL connection pool. It’s working now, but the exact root cause wasn’t confirmed to be heavy traffic; it could have been network connectivity or connection establishment issues. Even now the issue is not fixed but it works and also breaks sometimes with this message please help me with this

I've been building ARCLUX — a repository intelligence tool (CLI + web dashboard) that maps your codebase into a dependency graph, traces impact ("what breaks if I touch this file?"), and runs 18 structural detectors (circular deps, dead code, orphan files, layer violations, etc).

**Verified at meaningful scale** — microsoft/vscode, facebook/react, and vitejs/vite all analyze successfully, not just small toy fixtures.

**Language support:**

- TypeScript, JavaScript, Python — full support

- Go, Java — parsing works, but same-package calls with no import statement (common in both languages) aren't resolved as edges yet

**Honest state (this is `v0.1.0-alpha`):**

- Very large/unusual repos (10k+ files, heavy monorepos) can currently time out or fail without a clear error — no size guard or progress streaming yet, that's next

- Some packages (search, persistent caching) are still stubs

I'm not trying to compete with enterprise tooling — this started as a personal project to actually understand codebases I work in, and it grew from there.

Would love feedback, bug reports, or PRs if any of this is useful to you.

I'm considering buying the official courses by Kamil and the core team. I know they advertise free lifetime updates, but I wanted to see if anyone can confirm if the content has been updated for NestJS 11 or just NestJS 10 and the breaking changes (like the Express v5 switch)?

Are the videos actually up to date, or are some parts starting to show their age?

Thanks in advance

Hey everyone,

After standardizing a top-down grouping model (User -> Group -> Role -> Privilege) to escape the three-way junction table mess in single-tenant applications (URBAC), the next logical challenge was scaling that pattern to multi-tenancy.

I wanted to share the architectural pattern I standardized to solve this, along with the boilerplate implementation as MT-URBAC (NestJS, TypeORM, PostgreSQL, and Angular).

The backend architecture:

1- Tenant-Aware Resolution: The application handles both path-based routing (for local development without touching a hosts file) and subdomain-based routing seamlessly.

2- Strict Role Escalation Safeguards: Horizontal privilege escalation is blocked at the guard level. Roles have a numeric level (e.g., Admin = 50, Super Admin = 100), and custom JWT guards intercept requests to ensure lower-level users can't grant higher privileges regardless of permissions.

3- Clean Decorator-Based Protection:

@Post ('create')
@RequirePermissions('user:create')
async createNewUser() { ... }

The repo includes everything packaged up with a database seed script to instantly provision a PostgreSQL database and a Super Admin account so you can test the guards right away.

If you want to adopt this pattern, review the entity structures, or just skip the auth setup on your next build, I open-sourced the repository here:

https://github.com/kasoir/mt-urbac

Curious how others here handle tenant context switching and guard-level role hierarchies in NestJS at scale. Let me know your thoughts!

mt-urbac

How I know what is the right version I should use it in my nest project???