NestJS Developer Skills Assessment — Questions and Answers

Question 1: You need to add OpenTelemetry tracing to a NestJS app so every HTTP request gets a trace ID propagated to downstream services. Which integration point is correct?

Configure tracing inside a TypeORM subscriber for database calls only
Add a custom decorator to every controller method
Initialize the OTEL SDK before NestFactory.create() in main.ts and use the @opentelemetry/instrumentation-http package (Correct answer)
Use APP_INTERCEPTOR to manually generate UUIDs per request

Correct answer: Initialize the OTEL SDK before NestFactory.create() in main.ts and use the @opentelemetry/instrumentation-http package

The OTEL SDK must initialize before any modules load so auto-instrumentation can patch Node.js's http module and establish context propagation from the start.

Question 2: What is Middleware in NestJS and when does it execute?

A decorator that runs after the response is sent
A pipe that validates route parameters
A service that transforms database results
A function that runs before the route handler, with access to req and res (Correct answer)

Correct answer: A function that runs before the route handler, with access to req and res

Middleware functions execute before the route handler and can modify the request/response or call next() to pass control forward.

Question 3: When writing a NestJS unit test for a controller that depends on a service, what is the recommended approach for providing the service?

Provide a mock object using `useValue` with jest mock functions (Correct answer)
Use `useFactory` to instantiate the real service without a database
Import the real service module and let NestJS inject it
Use `useClass` to provide an alternate real implementation

Correct answer: Provide a mock object using `useValue` with jest mock functions

Using `useValue` with a mock object (containing `jest.fn()` stubs) isolates the controller under test from real service logic and external dependencies.

Question 4: A NestJS service depends on an external API. Which pattern best manages the risk of cascading failures when that API is unavailable?

Repository pattern
Saga pattern
Decorator pattern
Circuit breaker pattern (Correct answer)

Correct answer: Circuit breaker pattern

A circuit breaker stops forwarding requests to a failing dependency after a threshold, preventing resource exhaustion and cascading failures.

Question 5: What does the `synchronize: true` TypeORM option do and why is it dangerous in production?

It automatically alters the DB schema to match entities — risking data loss on production (Correct answer)
It keeps entity files in sync with migration files
It syncs multiple databases together
It synchronizes database replicas

Correct answer: It automatically alters the DB schema to match entities — risking data loss on production

`synchronize: true` auto-runs ALTER TABLE statements on startup to match entity definitions, which can drop columns or tables with production data.

Question 6: What is Role-Based Access Control (RBAC) in the context of NestJS guards?

An OAuth2 scope validation mechanism
A built-in NestJS feature that auto-assigns roles from JWT claims
A database middleware that filters rows by user role
A pattern where guards check user roles stored in metadata to allow or deny access (Correct answer)

Correct answer: A pattern where guards check user roles stored in metadata to allow or deny access

RBAC in NestJS is implemented by attaching role metadata via custom decorators and checking it inside a guard using Reflector.

Question 7: What is database connection pooling and why is it important in NestJS?

Caching database query results to avoid repeated SQL
Sharding database writes across multiple servers
Batching multiple queries into a single network round trip
Maintaining a set of reusable DB connections to reduce connection overhead under concurrent load (Correct answer)

Correct answer: Maintaining a set of reusable DB connections to reduce connection overhead under concurrent load

Connection pooling reuses established database connections across requests, avoiding the overhead of creating and tearing down connections for every query.

Question 8: What does the `@Render()` decorator do in NestJS?

Renders an HTML template view using the configured template engine (Correct answer)
Converts a class to a render-safe DTO
Enables server-side rendering for React components
Serializes the response as JSON

Correct answer: Renders an HTML template view using the configured template engine

@Render() tells the controller method to render a named template file using the configured view engine (e.g., Handlebars, Pug).

Question 9: Which NestJS guard implementation correctly enforces the principle of least privilege for a multi-tenant SaaS application?

A guard that restricts access by IP address
A guard that checks JWT role claims against a static roles array
A guard that validates the JWT subject matches the resource's tenant_id in the database before allowing access (Correct answer)
A guard that allows access if any valid JWT is present

Correct answer: A guard that validates the JWT subject matches the resource's tenant_id in the database before allowing access

Validating the JWT subject against the resource's tenant ownership in the database prevents cross-tenant data access, enforcing least privilege at the resource level.

Question 10: How do you inject Prisma Client as a service in NestJS?

Import PrismaModule.forRoot() and use @Prisma() decorator
Create a PrismaService that extends PrismaClient, mark it @Injectable(), and inject it by class type (Correct answer)
Use @InjectPrisma() decorator from @nestjs/prisma
Prisma auto-registers with NestJS when installed

Correct answer: Create a PrismaService that extends PrismaClient, mark it @Injectable(), and inject it by class type

The idiomatic pattern is creating a PrismaService extending PrismaClient, decorating it with @Injectable(), and providing it in AppModule so it can be injected anywhere.

Question 11: Which decorator transforms a plain class into a NestJS injectable service?

@Provider()
@Injectable() (Correct answer)
@Singleton()
@Service()

Correct answer: @Injectable()

@Injectable() marks a class as a provider that the NestJS IoC container can instantiate and inject into other classes.

Question 12: Which method in a TypeORM QueryBuilder is used to add a WHERE clause with a named parameter?

.where('entity.field = :value', { value }) (Correct answer)
.filter('condition', params)
.condition('field', 'value')
.addFilter('field = ?', [value])

Correct answer: .where('entity.field = :value', { value })

.where() (or .andWhere()) accepts a string condition with named `:param` placeholders and a params object to safely parameterize queries.

Question 13: A NestJS app must comply with GDPR's 'right to erasure'. What database strategy best supports this in a Drizzle ORM setup?

Soft deletes with a deleted_at column
Archiving rows to a cold storage table
Encrypting PII columns with a per-user key then discarding the key (Correct answer)
Hard deletes with cascading foreign keys

Correct answer: Encrypting PII columns with a per-user key then discarding the key

Discarding a per-user encryption key renders PII unreadable (cryptographic erasure), satisfying right-to-erasure even when hard deletes are impractical.

Question 14: Which NestJS built-in pipe should be used to prevent oversized request payloads?

ValidationPipe with `maxBodySize`
ParseFilePipe with size validator
The `rawBody` limit in NestFactory options (Correct answer)
MaxBodySizePipe

Correct answer: The `rawBody` limit in NestFactory options

Request body size limits are configured at the HTTP adapter level via NestFactory options (e.g., `bodyParser` limit), not through a NestJS pipe.

Question 15: How do you implement soft deletes in TypeORM within a NestJS application?

Set `softDelete: true` in TypeOrmModule.forRoot()
Add `deleted: boolean` and filter manually in every query
Use the @DeleteDateColumn() decorator and call repository.softDelete() (Correct answer)
Use a TypeORM AfterRemove subscriber

Correct answer: Use the @DeleteDateColumn() decorator and call repository.softDelete()

@DeleteDateColumn() adds a nullable timestamp column; repository.softDelete() sets it instead of removing the row, and find queries automatically exclude soft-deleted records.

Question 16: What is the name of the framework that helps build Node. JS server-side applications?

React
Express
Backbone
Nest (Correct answer)

Correct answer: Nest

NestJS is a progressive Node.js framework specifically designed to build efficient, scalable, and reliable server-side applications. It adopts a structured approach, drawing inspiration from Angular's architecture, and combines elements of object-oriented programming, functional programming, and reactive programming to streamline backend development.

Question 17: What is the difference between Scope.TRANSIENT and Scope.REQUEST in NestJS?

TRANSIENT creates a new instance per injection site; REQUEST creates one instance per HTTP request (Correct answer)
TRANSIENT is for WebSocket only; REQUEST is for HTTP only
TRANSIENT is global; REQUEST is module-scoped
They are identical in behavior

Correct answer: TRANSIENT creates a new instance per injection site; REQUEST creates one instance per HTTP request

TRANSIENT providers get a new instance every time they are injected, while REQUEST providers share one instance across all injections within a single request lifecycle.

Question 18: What is a Lazy-loaded module in NestJS and when should it be used?

A module that defers DI resolution until first use
A module loaded on-demand to reduce initial startup time in serverless environments (Correct answer)
A module whose providers are destroyed after each request
A module loaded from a CDN at runtime

Correct answer: A module loaded on-demand to reduce initial startup time in serverless environments

Lazy-loaded modules are instantiated only when first requested, which reduces cold-start time — especially beneficial in serverless (Lambda) deployments.

Question 19: What is the role of a NestJS Interceptor?

To validate incoming request data
To manage database connections
To bind extra logic before/after a method execution and transform results (Correct answer)
To route requests to the correct controller

Correct answer: To bind extra logic before/after a method execution and transform results

Interceptors implement the NestInterceptor interface and can add extra logic around method calls, transform results, and extend basic function behavior.

Question 20: Which NestJS architectural concept is analogous to Angular's NgModule?

Module (Correct answer)
Guard
Controller
Provider

Correct answer: Module

NestJS Module (decorated with @Module()) mirrors Angular's NgModule concept, serving as a cohesive block of related functionality.

Question 21: Which TypeORM feature allows you to automatically set `createdAt` and `updatedAt` timestamps?

Set `timestamps: true` in entity options
@CreateDateColumn() and @UpdateDateColumn() decorators (Correct answer)
@Timestamp() with auto option
@Auto() decorator

Correct answer: @CreateDateColumn() and @UpdateDateColumn() decorators

@CreateDateColumn() and @UpdateDateColumn() are TypeORM column decorators that automatically populate timestamp fields on insert and update respectively.

Question 22: In a NestJS e2e test, how do you initialize the application before running tests?

Use `jest.setup()` to bootstrap the app globally
Call `Test.createTestingModule().compile()` without calling `init()`
Import the AppModule directly and call its constructor
Call `NestFactory.create()` and `app.init()` inside `beforeAll()` (Correct answer)

Correct answer: Call `NestFactory.create()` and `app.init()` inside `beforeAll()`

For e2e tests you use `NestFactory.create(AppModule)` followed by `app.init()` inside `beforeAll()` so the full application is available to all tests in the suite.

Question 23: What is a compliance management system in NestJS practice?

A software application only
A structured framework of policies, procedures, and controls that ensure regulatory adherence (Correct answer)
An optional business tool
A government reporting requirement

Correct answer: A structured framework of policies, procedures, and controls that ensure regulatory adherence

This is fundamental to NestJS practice. A structured framework of policies, procedures, and controls that ensure regulatory adherence represents the professional standard for regulatory in the NestJS certification framework.

Question 24: What type of experience does it take to use the Nest framework?

Back-end development
Front-end development (Correct answer)
Mobile development
Full stack development

Correct answer: Front-end development

While NestJS is a backend framework, its architecture and design principles are heavily inspired by Angular, a prominent front-end framework. Developers with experience in front-end development, especially with Angular, will find NestJS's use of decorators, dependency injection, and modular structure very familiar. This makes the transition to backend development with NestJS smoother for those with a front-end background.

Question 25: What is the role of the `AppModule` in a NestJS application?

It defines global guards
It serves as the root module that bootstraps the entire application (Correct answer)
It manages database connections
It handles HTTP requests directly

Correct answer: It serves as the root module that bootstraps the entire application

AppModule is the root module passed to NestFactory.create(), which NestJS uses as the starting point to build the dependency graph.

Question 26: Which pattern does NestJS primarily use for organizing application logic?

Modular architecture with DI (Correct answer)
Microkernel
MVC
MVVM

Correct answer: Modular architecture with DI

NestJS uses a modular architecture combined with dependency injection (DI) to organize and decouple application components.

Question 27: Which NestJS decorator is used to define a class as a module?

@Controller()
@Injectable()
@Module() (Correct answer)
@Component()

Correct answer: @Module()

The @Module() decorator marks a class as a NestJS module that organizes related providers, controllers, and imports.

Question 28: Which SOLID principle is most directly enforced by NestJS's dependency injection system?

Interface Segregation
Single Responsibility
Open/Closed
Dependency Inversion (Correct answer)

Correct answer: Dependency Inversion

NestJS DI enforces the Dependency Inversion Principle by having high-level modules depend on abstractions (tokens/interfaces) rather than concrete implementations.

Question 29: Which NestJS concept allows a module to be shared across the entire application without re-importing?

Dynamic Module
Feature Module
Core Module
Global Module (Correct answer)

Correct answer: Global Module

A Global Module decorated with @Global() makes its exported providers available everywhere without requiring explicit imports.

Question 30: Which NestJS-compatible ORM uses a code-first approach with a schema builder instead of decorators?

Sequelize
MikroORM
Prisma (Correct answer)
TypeORM

Correct answer: Prisma

Prisma uses a declarative schema file (schema.prisma) and generates a type-safe client, making it code-first without requiring entity class decorators.

Question 31: In a NestJS microservices architecture, what is the role of the @MessagePattern() decorator?

It defines a REST endpoint
It publishes events to a message broker
It maps a message pattern to a handler method (Correct answer)
It validates incoming DTO shapes

Correct answer: It maps a message pattern to a handler method

@MessagePattern() maps an incoming message pattern string to the controller method that should handle it.

Question 32: What is the N+1 query problem in TypeORM, and how is it solved?

Loading N related entities with N separate queries instead of 1 JOIN — solved with eager loading or QueryBuilder joins (Correct answer)
Running N queries then 1 aggregate — solved with GROUP BY
Having N connections open — solved with connection pooling
Calling findOne() N+1 times — solved with caching

Correct answer: Loading N related entities with N separate queries instead of 1 JOIN — solved with eager loading or QueryBuilder joins

N+1 occurs when fetching a list of N entities and then loading each one's relation separately; use eager relations or explicit JOIN in QueryBuilder to fetch everything in one query.

Question 33: How do you protect NestJS endpoints from Cross-Site Request Forgery (CSRF)?

Set SameSite=Strict on all cookies automatically via NestJS
Enable CSRF via app.useCsrf() built-in method
CSRF protection is built into NestJS guards by default
Use the `csurf` middleware with Express adapter and store tokens in cookies (Correct answer)

Correct answer: Use the `csurf` middleware with Express adapter and store tokens in cookies

CSRF protection in NestJS (Express adapter) uses the `csurf` middleware to generate and validate synchronizer tokens stored in cookies or sessions.

Question 34: How do you create a circular dependency between two NestJS providers without causing errors?

Use @Inject() with lazy references
Circular dependencies are impossible in NestJS
Use a shared Global module
Use forwardRef() in both @Inject() decorators (Correct answer)

Correct answer: Use forwardRef() in both @Inject() decorators

forwardRef() wraps the class reference to defer its resolution, allowing NestJS to break the circular dependency loop during instantiation.

Question 35: What is the execution order of NestJS request lifecycle components?

Middleware → Interceptors → Guards → Pipes → Controllers
Middleware → Guards → Interceptors → Pipes → Controllers (Correct answer)
Guards → Middleware → Interceptors → Pipes → Controllers
Interceptors → Guards → Pipes → Controllers

Correct answer: Middleware → Guards → Interceptors → Pipes → Controllers

The NestJS request pipeline executes in this order: Middleware → Guards → Interceptors (before) → Pipes → Controller → Interceptors (after) → Exception Filters.

Question 36: Which decorator marks a NestJS microservice message handler for a specific pattern?

@Listen()
@EventHandler()
@Subscribe()
@MessagePattern() (Correct answer)

Correct answer: @MessagePattern()

@MessagePattern() decorates a method in a microservice controller to handle messages matching a specific pattern sent by a client.

Question 37: What does enabling `helmet` in a NestJS application provide?

CSRF token generation
HTTP security headers that protect against common web vulnerabilities (Correct answer)
Rate limiting for API endpoints
Input sanitization for request bodies

Correct answer: HTTP security headers that protect against common web vulnerabilities

Helmet sets various HTTP response headers (like Content-Security-Policy and X-Frame-Options) to mitigate common attacks such as XSS and clickjacking.

Question 38: In NestJS, what is the purpose of the ConfigModule?

To configure routing rules
To set up database migrations
To load and manage environment variables and configuration across the application (Correct answer)
To configure Swagger documentation

Correct answer: To load and manage environment variables and configuration across the application

ConfigModule (from @nestjs/config) loads .env files and provides a ConfigService to access environment variables throughout the app.

Question 39: In NestJS, what is an injection token used for?

Uniquely identifying a provider in the DI container (Correct answer)
Authenticating HTTP requests
Namespacing module routes
Labeling log messages

Correct answer: Uniquely identifying a provider in the DI container

An injection token (string, Symbol, or class) uniquely identifies a provider in NestJS's IoC container so the correct value is injected.

Question 40: What does the 'exports' array in @Module() define?

Routes exposed publicly
Controllers visible to the app
Providers that other modules can import and use (Correct answer)
Guards applied globally

Correct answer: Providers that other modules can import and use

The 'exports' array specifies which providers from the current module should be available to other modules that import it.

Question 41: Documentation research reveals that NestJS provides which decorator to override a provider with a mock value in a testing module?

{provide: Token, useFactory: () => mock}
{provide: Token, useValue: mock}
Both A and C are correct (Correct answer)
{inject: Token, mock: mock}

Correct answer: Both A and C are correct

Both useValue and useFactory are valid override strategies in the testing module's providers array, serving different needs.

Question 42: Which NestJS package provides first-class TypeORM integration?

@nestjs/orm
@nestjs/database
@nestjs/entity
@nestjs/typeorm (Correct answer)

Correct answer: @nestjs/typeorm

@nestjs/typeorm provides TypeOrmModule with forRoot() and forFeature() methods for integrating TypeORM into the NestJS DI system.

Question 43: What is the name of the built-in microservice abstraction?

Apache OpenWhisk
NestJS (Correct answer)
Azure Functions
Node.js

Correct answer: NestJS

NestJS is a comprehensive framework that offers robust, built-in support for developing microservices. It provides abstractions and tools for various transport layers, such as TCP, Redis, and gRPC, making it a complete solution for building distributed applications within the Node.js environment. Thus, NestJS itself serves as a powerful microservice abstraction.

Question 44: What is the purpose of TypeORM migrations in a NestJS production application?

To seed the database with test data
To synchronize entity definitions automatically on startup
To safely evolve the database schema in a controlled, versioned manner (Correct answer)
To back up the database before schema changes

Correct answer: To safely evolve the database schema in a controlled, versioned manner

Migrations provide versioned, reversible SQL scripts that alter the database schema without losing data — essential in production where `synchronize: true` is dangerous.

Question 45: In NestJS testing, what does `Test.createTestingModule()` return?

An HTTP test client
A TestingModuleBuilder used to compile and create a testing module (Correct answer)
A mock of the AppModule
A ready-to-use NestApplication instance

Correct answer: A TestingModuleBuilder used to compile and create a testing module

Test.createTestingModule() returns a TestingModuleBuilder, which you then call .compile() on to get the actual TestingModule.

Question 46: Which decorator applies a guard to an entire controller in NestJS?

@Protect() on the module
@Guard() on each method
@UseGuards() on the controller class (Correct answer)
@ApplyGuard() on the controller class

Correct answer: @UseGuards() on the controller class

@UseGuards() placed on a controller class applies the specified guard(s) to every route handler within that controller.

Question 47: What is the benefit of interdisciplinary collaboration in NestJS practice?

It brings diverse expertise and perspectives that improve outcomes and innovation (Correct answer)
It is only for complex projects
It creates confusion
It slows down decision making

Correct answer: It brings diverse expertise and perspectives that improve outcomes and innovation

This is fundamental to NestJS practice. It brings diverse expertise and perspectives that improve outcomes and innovation represents the professional standard for practical in the NestJS certification framework.

Question 48: In a NestJS project using Jest, which command runs only tests whose file names match a specific pattern?

jest --watch=<pattern>
jest --include=<pattern>
jest --testPathPattern=<pattern> (Correct answer)
jest --filter=<pattern>

Correct answer: jest --testPathPattern=<pattern>

--testPathPattern accepts a regex that is matched against the full path of each test file.

Question 49: What does `useExisting` do in a NestJS custom provider?

Marks a provider as optional
Creates an alias that points to an already-registered provider (Correct answer)
Imports a provider from another module
Creates a new instance of an existing class

Correct answer: Creates an alias that points to an already-registered provider

`useExisting` creates a provider alias so two different tokens resolve to the same underlying provider instance.

Question 50: What does the `exports` array in @Module() control?

Which providers can be used by other modules (Correct answer)
The order of middleware execution
Which controllers are public
Which guards are applied globally

Correct answer: Which providers can be used by other modules

The `exports` array specifies which providers from the current module are available for other modules that import it.

Question 51: What is the purpose of the `useValue` option in a custom provider definition?

To alias an existing provider
To inject a factory function
To define an async provider
To provide a static value or mock object as a provider (Correct answer)

Correct answer: To provide a static value or mock object as a provider

`useValue` registers a static value (such as a config object or mock) directly as a provider without instantiation.

Question 52: How do you configure TypeORM for asynchronous configuration (e.g., from ConfigService) in NestJS?

DatabaseModule.withConfig() factory
TypeOrmModule.forRootAsync() with useFactory (Correct answer)
TypeOrmModule.forRoot() with a factory
TypeOrmModule.configure() with async option

Correct answer: TypeOrmModule.forRootAsync() with useFactory

TypeOrmModule.forRootAsync() accepts a useFactory (or useClass/useExisting) that can inject ConfigService and return the database options asynchronously.

Question 53: How do you share a provider from one module so other modules can use it?

Use @Shared() decorator on the provider
Declare it as global in main.ts
Add it to the imports array
Add it to the exports array of the providing module (Correct answer)

Correct answer: Add it to the exports array of the providing module

A module must list a provider in its exports array for other modules that import it to access that provider.

Question 54: Which testing framework does NestJS use by default for unit and integration tests?

Jest (Correct answer)
Jasmine
Mocha
Vitest

Correct answer: Jest

NestJS uses Jest as its default testing framework, which is pre-configured when you scaffold a project with the Nest CLI.

Question 55: What is a Dynamic Module in NestJS?

A module with runtime-generated controllers
A module loaded at runtime via lazy loading
A module that dynamically creates routes
A module that exports configuration-based providers at import time (Correct answer)

Correct answer: A module that exports configuration-based providers at import time

A Dynamic Module returns a module configuration object (including providers) at import time, enabling customizable, reusable modules like ConfigModule.forRoot().

Question 56: What is the purpose of the `providers` array in the @Module() decorator?

To export public APIs
To list imported modules
To declare HTTP controllers
To register services that can be injected within the module (Correct answer)

Correct answer: To register services that can be injected within the module

The `providers` array registers services (and other injectables) with the NestJS IoC container so they can be injected within that module.

Question 57: Which provider option allows asynchronous initialization, such as reading from a database?

useFactory with async function (Correct answer)
useExisting
useValue
useClass

Correct answer: useFactory with async function

`useFactory` accepts an async function, so NestJS will await the resolved value before making the provider available for injection.

Question 58: What does the `imports` array in @Module() accept?

Middleware functions
NPM package names
Other module classes whose exported providers are needed (Correct answer)
Service class references

Correct answer: Other module classes whose exported providers are needed

The `imports` array takes other NestJS module classes, making their exported providers available for injection within the importing module.

Question 59: How do you handle database seeding in a NestJS TypeORM project?

Seeds run automatically from the entities/seeds folder
Use @Seed() decorator on a provider method
Use TypeOrmModule's built-in seed option
Create a seed script that uses DataSource directly and run it via a npm script (Correct answer)

Correct answer: Create a seed script that uses DataSource directly and run it via a npm script

Database seeding in TypeORM is typically done via a standalone TypeScript script that initializes DataSource and uses repositories to insert data, run manually or in CI.

Question 60: How do you inject a non-class provider (e.g., a string token) in NestJS?

Automatic injection by type
@Value(TOKEN) decorator
@Inject(TOKEN) in the constructor parameter (Correct answer)
@InjectToken(TOKEN) decorator

Correct answer: @Inject(TOKEN) in the constructor parameter

@Inject(TOKEN) explicitly specifies the injection token to use when NestJS cannot infer it from the TypeScript type.

NestJS Developer Skills Assessment

Evaluates proficiency in the NestJS Node.js framework, covering core architecture, dependency injection, decorators, database integration, and advanced patterns for building scalable server-side applications.

Questions

75 min

Time Limit

70%

To Pass

Checking for saved progress...

Exam Rules

You can skip questions and return to them later
Flag questions for review before submitting
No feedback shown until you submit the entire exam
Unanswered questions count as wrong — answer everything
10 pretest questions are mixed in and don't affect your score
Timer auto-submits when time runs out
Your progress is auto-saved every 30 seconds