Forem: Yogesh Prasad

🧠 Mastering Goroutines in Go: The Power of Lightweight Concurrency.

Yogesh Prasad — Mon, 03 Nov 2025 08:58:36 +0000

Go (Golang) is known for its simplicity, performance, and concurrency model.
At the heart of this concurrency lies one of Go’s most elegant features — the goroutine.

In this blog, we’ll explore what goroutines are, how they work under the hood, and how you can use them to build concurrent, scalable applications like a seasoned Go developer.

🧩 What is a Goroutine?

A goroutine is a lightweight thread managed by the Go runtime.

When you run:

go doSomething()

you’re telling Go:

“Run doSomething() asynchronously, and don’t wait for it to finish.”

That single keyword go launches a new goroutine.

Unlike traditional OS threads (which can take up megabytes of stack memory), a goroutine starts with only a few kilobytes — making it possible to spawn hundreds of thousands of them effortlessly.

⚙️ How Goroutines Work (Under the Hood)

Go uses an efficient M:N scheduler, meaning it maps:

M = OS threads

N = Goroutines

So, instead of each goroutine needing its own thread, the Go runtime multiplexes thousands of goroutines onto a few OS threads — automatically managing scheduling, context switching, and load balancing.

This is why goroutines are incredibly lightweight and efficient.

🧠 The Lifecycle of a Goroutine

You launch it with go ...

The Go scheduler places it in a run queue

The scheduler assigns it to an available P (processor context)

The goroutine executes

When it finishes (or main() exits), it’s garbage collected

Important: When the main function ends, all goroutines stop — no exceptions.

🧪 Example 1: Your First Goroutine

Let’s start simple:

package main

import (
    "fmt"
    "time"
)

func main() {
    go fmt.Println("Hello from a goroutine!")
    time.Sleep(time.Millisecond * 10)
}

Without the time.Sleep, this program might print nothing — because the main goroutine exits before the child one gets CPU time.

✅ Lesson: The main goroutine must stay alive until others finish.

🧱 Example 2: Launching Multiple Goroutines
package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        go fmt.Println("Goroutine:", i)
    }

    fmt.Scanln() // Wait for user input to prevent exit
}

You’ll notice the output order is unpredictable — and that’s expected!
Each goroutine runs concurrently, not sequentially.

🔗 Communication Between Goroutines — Channels

Goroutines are great, but they’re even more powerful when they communicate safely.
That’s where channels come in.

A channel is a pipe that allows goroutines to send and receive data.

Example:
package main

import "fmt"

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Hello from goroutine!"
    }()

    msg := <-ch
    fmt.Println(msg)
}

ch <- "Hello" sends data

<-ch receives data

Both send and receive block until the other side is ready — ensuring synchronization.

⚙️ Buffered Channels

Want to send without waiting immediately? Use a buffered channel:

ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)

Here, the buffer lets you send two items before blocking.

🧰 Controlling Goroutines with sync.WaitGroup

In real-world apps, you’ll often need to wait for multiple goroutines to finish.
That’s where sync.WaitGroup comes in:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Println("Worker", id, "done")
        }(i)
    }

    wg.Wait() // Wait until all goroutines finish
}

✅ This is the idiomatic Go way to synchronize goroutines.

🏗 Real-World Example: Worker Pool Pattern

A worker pool limits the number of concurrent workers — an essential pattern in production.

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        time.Sleep(time.Second)
        fmt.Println("Worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

💡 Conceptually:

Jobs channel → queue of tasks

Results channel → output

Workers (goroutines) → process jobs concurrently

⚠️ Common Pitfalls

❌ Forgetting to close channels — can cause deadlocks

❌ Starting goroutines without control — can overwhelm system memory

❌ Accessing shared memory without sync — causes race conditions

You can detect races by running:

go run -race main.go

🧭 Key Takeaways

✅ Goroutines are lightweight, cheap, and managed by Go’s scheduler
✅ Channels enable safe communication between them
✅ Always synchronize goroutines using WaitGroups, channels, or contexts
✅ Never start a goroutine you can’t stop

🚀 Final Thoughts

Goroutines are the foundation of Go’s simplicity and power.
Once you master them, you’ll start thinking in concurrent patterns — building systems that scale effortlessly.

In upcoming posts, I’ll dive deeper into:

Context cancellation
Pipelines
Fan-out/Fan-in patterns
Real-world concurrency debugging

✍️ Written by Yogesh Mathankar

💬 Modern MERN & Go developer passionate about building scalable systems and AI-integrated apps.

🧠 Mastering Goroutines in Go: The Power of Lightweight Concurrency.

Yogesh Prasad — Mon, 03 Nov 2025 08:58:36 +0000

Go (Golang) is known for its simplicity, performance, and concurrency model.
At the heart of this concurrency lies one of Go’s most elegant features — the goroutine.

In this blog, we’ll explore what goroutines are, how they work under the hood, and how you can use them to build concurrent, scalable applications like a seasoned Go developer.

🧩 What is a Goroutine?

A goroutine is a lightweight thread managed by the Go runtime.

When you run:

go doSomething()

you’re telling Go:

“Run doSomething() asynchronously, and don’t wait for it to finish.”

That single keyword go launches a new goroutine.

Unlike traditional OS threads (which can take up megabytes of stack memory), a goroutine starts with only a few kilobytes — making it possible to spawn hundreds of thousands of them effortlessly.

⚙️ How Goroutines Work (Under the Hood)

Go uses an efficient M:N scheduler, meaning it maps:

M = OS threads

N = Goroutines

This is why goroutines are incredibly lightweight and efficient.

🧠 The Lifecycle of a Goroutine

You launch it with go ...

The Go scheduler places it in a run queue

The scheduler assigns it to an available P (processor context)

The goroutine executes

When it finishes (or main() exits), it’s garbage collected

Important: When the main function ends, all goroutines stop — no exceptions.

🧪 Example 1: Your First Goroutine

Let’s start simple:

package main

import (
    "fmt"
    "time"
)

func main() {
    go fmt.Println("Hello from a goroutine!")
    time.Sleep(time.Millisecond * 10)
}

Without the time.Sleep, this program might print nothing — because the main goroutine exits before the child one gets CPU time.

✅ Lesson: The main goroutine must stay alive until others finish.

🧱 Example 2: Launching Multiple Goroutines
package main

import "fmt"

func main() {
    for i := 1; i <= 5; i++ {
        go fmt.Println("Goroutine:", i)
    }

    fmt.Scanln() // Wait for user input to prevent exit
}

You’ll notice the output order is unpredictable — and that’s expected!
Each goroutine runs concurrently, not sequentially.

🔗 Communication Between Goroutines — Channels

Goroutines are great, but they’re even more powerful when they communicate safely.
That’s where channels come in.

A channel is a pipe that allows goroutines to send and receive data.

Example:
package main

import "fmt"

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Hello from goroutine!"
    }()

    msg := <-ch
    fmt.Println(msg)
}

ch <- "Hello" sends data

<-ch receives data

Both send and receive block until the other side is ready — ensuring synchronization.

⚙️ Buffered Channels

Want to send without waiting immediately? Use a buffered channel:

ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)

Here, the buffer lets you send two items before blocking.

🧰 Controlling Goroutines with sync.WaitGroup

In real-world apps, you’ll often need to wait for multiple goroutines to finish.
That’s where sync.WaitGroup comes in:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Println("Worker", id, "done")
        }(i)
    }

    wg.Wait() // Wait until all goroutines finish
}

✅ This is the idiomatic Go way to synchronize goroutines.

🏗 Real-World Example: Worker Pool Pattern

A worker pool limits the number of concurrent workers — an essential pattern in production.

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        time.Sleep(time.Second)
        fmt.Println("Worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

💡 Conceptually:

Jobs channel → queue of tasks

Results channel → output

Workers (goroutines) → process jobs concurrently

⚠️ Common Pitfalls

❌ Forgetting to close channels — can cause deadlocks

❌ Starting goroutines without control — can overwhelm system memory

❌ Accessing shared memory without sync — causes race conditions

You can detect races by running:

go run -race main.go

🧭 Key Takeaways

🚀 Final Thoughts

Goroutines are the foundation of Go’s simplicity and power.
Once you master them, you’ll start thinking in concurrent patterns — building systems that scale effortlessly.

In upcoming posts, I’ll dive deeper into:

Context cancellation
Pipelines
Fan-out/Fan-in patterns
Real-world concurrency debugging

✍️ Written by Yogesh Mathankar

💬 Modern MERN & Go developer passionate about building scalable systems and AI-integrated apps.

NestJS Expert Series – Part 5: API Gateway and Service Communication

Yogesh Prasad — Mon, 06 Oct 2025 17:04:20 +0000

Welcome back to the NestJS Expert Series! 👋
In Part 4, we built scalable microservices with RabbitMQ.
Now, it’s time to take the next step — integrating them with an API Gateway and service-to-service communication.

🚀 Why Use an API Gateway?

When your app grows into multiple microservices (Auth, Users, Orders, Payments, etc.), clients shouldn’t need to know where each service lives.

Instead, the API Gateway acts as a single entry point — handling:

Authentication

Routing requests to the right microservice

Response aggregation

Rate limiting, caching, logging

This is the same principle used by Netflix, Uber, and Amazon for their distributed architectures.

⚙️ Step 1 – Setup a New API Gateway Project

Let’s create a separate NestJS project to act as the gateway:

nest new api-gateway

Then, install the microservice package:

npm i @nestjs/microservices

🛠 Step 2 – Connect the Gateway to Microservices

In your app.module.ts of the API Gateway:

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { GatewayController } from './gateway.controller';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'AUTH_SERVICE',
        transport: Transport.TCP,
        options: { host: 'localhost', port: 3001 },
      },
      {
        name: 'USER_SERVICE',
        transport: Transport.TCP,
        options: { host: 'localhost', port: 3002 },
      },
    ]),
  ],
  controllers: [GatewayController],
})
export class AppModule {}

This defines two microservice connections:

AUTH_SERVICE (for authentication)

USER_SERVICE (for user-related operations)

🧩 Step 3 – Build the Gateway Controller

gateway.controller.ts:

import { Controller, Get, Inject, Post, Body } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';

@Controller('gateway')
export class GatewayController {
  constructor(
    @Inject('AUTH_SERVICE') private authClient: ClientProxy,
    @Inject('USER_SERVICE') private userClient: ClientProxy,
  ) {}

  @Post('login')
  async login(@Body() credentials: any) {
    return this.authClient.send({ cmd: 'login' }, credentials);
  }

  @Get('users')
  async getUsers() {
    return this.userClient.send({ cmd: 'get_users' }, {});
  }
}

✅ Here:

The gateway sends messages to different microservices via TCP transport.

Each microservice listens for specific message patterns and responds.

🎧 Step 4 – Listening in the Microservice
Example from user-service:

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class UserController {
  @MessagePattern({ cmd: 'get_users' })
  getUsers() {
    return [
      { id: 1, name: 'Yogesh' },
      { id: 2, name: 'Aditi' },
    ];
  }
}

Now, when the gateway sends { cmd: 'get_users' }, this microservice responds with a list of users.

🧠 Step 5 – Add Authentication Middleware

To protect routes at the gateway level:

import { Injectable, NestMiddleware } from '@nestjs/common';
import * as jwt from 'jsonwebtoken';

@Injectable()
export class AuthMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    const token = req.headers['authorization']?.split(' ')[1];
    if (!token) return res.status(401).json({ message: 'Unauthorized' });

    try {
      const decoded = jwt.verify(token, 'SECRET_KEY');
      req.user = decoded;
      next();
    } catch {
      return res.status(401).json({ message: 'Invalid token' });
    }
  }
}

This ensures centralized authentication — one verification at the gateway before forwarding requests to microservices.

💡 Step 6 – Service Discovery (Optional)
For dynamic scaling, you can integrate Consul or Eureka to allow automatic service registration and discovery.
This prevents hardcoding service URLs and enables horizontal scaling easily.

🧭 Summary

✅ Implemented a central API Gateway
✅ Connected multiple microservices using TCP transport
✅ Added authentication middleware
✅ Laid the foundation for distributed, secure communication

🔮 Coming Up Next (Part 6)

In Part 6, we’ll take it even further:

🔧 “Monitoring, Logging, and Observability in NestJS Microservices.”

You’ll learn how to use Winston, Prometheus, and Grafana to track, debug, and optimize microservice performance.

🧩 NestJS Expert Series – Part 4: Building Scalable Microservices with NestJS and Message Queues

Yogesh Prasad — Sun, 05 Oct 2025 14:00:24 +0000

🚀 Introduction

As your NestJS applications grow, scalability becomes a key challenge. Monolithic apps can become bottlenecks — hard to maintain, deploy, and scale.
In this post, we’ll take the next step toward mastering backend architecture by implementing microservices in NestJS using message queues (RabbitMQ / Kafka).

🧠 What Are Microservices?

Microservices architecture is a design approach where a large application is divided into smaller, independent services.
Each service handles a specific business function and communicates with others through lightweight mechanisms — often a message broker.

✅ Benefits:

Independent deployment & scaling

Fault isolation

Technology flexibility

Simplified development for large teams

⚙️ Setting Up a Microservice in NestJS

Let’s start with a basic setup for microservices in NestJS.

npm i @nestjs/microservices amqplib

Create a main.ts for your microservice:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
    transport: Transport.RMQ,
    options: {
      urls: ['amqp://localhost:5672'],
      queue: 'tasks_queue',
      queueOptions: { durable: false },
    },
  });

  await app.listen();
  console.log('Microservice is listening...');
}
bootstrap();

This creates a RabbitMQ-based microservice that listens for incoming messages from the tasks_queue.

📡 Sending Messages from Another Service

In your main (API Gateway) application, you can send messages to this queue:

import { Controller, Post, Body } from '@nestjs/common';
import { ClientProxy, ClientProxyFactory, Transport } from '@nestjs/microservices';

@Controller('tasks')
export class TaskController {
  private client: ClientProxy;

  constructor() {
    this.client = ClientProxyFactory.create({
      transport: Transport.RMQ,
      options: {
        urls: ['amqp://localhost:5672'],
        queue: 'tasks_queue',
        queueOptions: { durable: false },
      },
    });
  }

  @Post()
  async createTask(@Body() taskData: any) {
    this.client.emit('task_created', taskData);
    return { message: 'Task sent to microservice successfully!' };
  }
}

🎧 Handling Messages in the Microservice

Inside your microservice, handle the event using a simple listener:

import { Controller } from '@nestjs/common';
import { EventPattern, Payload } from '@nestjs/microservices';

@Controller()
export class TaskListener {
  @EventPattern('task_created')
  handleTaskCreated(@Payload() data: any) {
    console.log('Task received:', data);
  }
}

Now, when your API Gateway emits a task_created event, the microservice automatically consumes and processes it.

🔁 Scaling with Message Queues

Using message queues like RabbitMQ or Kafka enables you to:

Distribute workloads evenly among multiple instances

Ensure reliability (retry, acknowledgment)

Achieve async processing for heavy tasks (emails, reports, ML jobs, etc.)

NestJS handles all this natively — no extra boilerplate needed.

🧱 Real-World Use Cases

Background jobs (e.g., sending notifications)

Transactional emails

Payment processing

Video transcoding

Data sync between services

🧭 Best Practices

Use DLQs (Dead Letter Queues) for failed messages.

Keep messages idempotent.

Add monitoring with Prometheus + Grafana.

Ensure graceful shutdowns of microservices.

Document your events for clear communication between teams.

💡 Summary

In this part, we explored how to:

Build a NestJS microservice

Use RabbitMQ for message communication

Emit and listen to events between services

Design scalable and resilient systems

By combining NestJS with message brokers, you can architect truly enterprise-grade distributed systems.

🧠 Coming Up Next (Part 5)

In Part 5, we’ll dive into API Gateway and Service Discovery with NestJS, where we’ll handle inter-service communication and authentication across microservices.

🔑 NestJS Expert Series (Part 3): Authentication & Authorization with JWT and Guards your

Yogesh Prasad — Sat, 04 Oct 2025 14:45:24 +0000

Welcome back to the NestJS Expert Series! 🎉
In Part https://dev.to/devto_with_yog/nestjs-expert-series-part-2-database-integration-with-prisma-typeorm-ica, we integrated our NestJS app with a database using Prisma and TypeORM.

Now it’s time to secure our application with Authentication (who you are) and Authorization (what you can do).

In this article, we’ll build a JWT-based authentication system and use Guards to implement role-based access control.

⚡ Why JWT for Authentication?

JWT (JSON Web Token) is a compact, URL-safe token format widely used for stateless authentication.

✅ Stateless – No need to store session data on the server.
✅ Scalable – Works well in distributed systems.
✅ Cross-platform – Can be used by web, mobile, and microservices.

📦 Step 1: Install Required Packages

🛠️ Step 2: Auth Module Setup

Generate an auth module, service, and controller:


nest g module auth
nest g service auth
nest g controller auth

👤 Step 3: User Entity (with Prisma Example)

If you’re using Prisma, update your schema:

model User {
  id       Int    @id @default(autoincrement())
  email    String @unique
  password String
  role     String @default("user")
}

Run migration:

npx prisma migrate dev --name add_user_model

🔑 Step 4: Auth Service (Register & Login)

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcrypt';

@Injectable()
export class AuthService {
  constructor(private jwtService: JwtService) {}

  async hashPassword(password: string): Promise<string> {
    return bcrypt.hash(password, 10);
  }

  async validatePassword(password: string, hash: string): Promise<boolean> {
    return bcrypt.compare(password, hash);
  }

  async generateToken(user: { id: number; email: string; role: string }) {
    return this.jwtService.sign({ sub: user.id, email: user.email, role: user.role });
  }
}

📜 Step 5: Auth Controller

import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private authService: AuthService) {}

  @Post('register')
  async register(@Body() body: { email: string; password: string }) {
    const hashed = await this.authService.hashPassword(body.password);
    // Save user to DB with hashed password
    return { message: 'User registered successfully' };
  }

  @Post('login')
  async login(@Body() body: { email: string; password: string }) {
    // Find user in DB and validate password
    // If valid, generate token
    return { access_token: await this.authService.generateToken({ id: 1, email: body.email, role: 'user' }) };
  }
}

🛡️ Step 6: Guards for Authorization

NestJS Guards decide whether a request should proceed or not.

Create a roles.guard.ts:

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!requiredRoles) return true;

    const { user } = context.switchToHttp().getRequest();
    return requiredRoles.includes(user.role);
  }
}

Use a custom decorator roles.decorator.ts:

import { SetMetadata } from '@nestjs/common';

export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

Apply it in a controller:

import { Controller, Get, UseGuards } from '@nestjs/common';
import { Roles } from './roles.decorator';
import { RolesGuard } from './roles.guard';

@Controller('admin')
export class AdminController {
  @Get()
  @Roles('admin')
  @UseGuards(RolesGuard)
  findAdminData() {
    return { secret: 'This is admin-only data' };
  }
}

🚀 Conclusion

✅ We built JWT-based authentication.

✅ We secured routes with Guards and Role-based Authorization.

✅ We now have the foundation for a secure, multi-user NestJS application.

In the next part, we’ll tackle Validation & Error Handling with Pipes and Filters to make our APIs more robust.

💡 If you found this helpful, drop a ❤️ on Dev.to and follow me for Part 4 of the NestJS Expert Series.

NestJS Expert Series (Part 2): Database Integration with Prisma & TypeORM

Yogesh Prasad — Fri, 03 Oct 2025 17:07:35 +0000

Welcome back to the NestJS Expert Series! 🎉
In Part 1,we built a simple CRUD API using NestJS fundamentals—Modules, Controllers, and Services.

But any real-world application needs persistent storage. That’s where databases come in.

In this article, we’ll integrate databases with NestJS using two popular ORMs:

Prisma – Modern, type-safe ORM with great DX.

TypeORM – Mature ORM used widely in enterprise projects.

By the end, you’ll be able to hook up your NestJS app to a PostgreSQL database (the same steps apply for MySQL or SQLite).

⚡ Step 1: Setting Up a Database

For this guide, let’s use PostgreSQL. If you have Docker installed:

docker run --name nest-postgres -e POSTGRES_PASSWORD=admin -e POSTGRES_USER=admin -e POSTGRES_DB=tasks -p 5432:5432 -d postgres

📦 Step 2: Adding Prisma to NestJS
npm install prisma --save-dev npm install @prisma/client npx prisma init

This creates a prisma/schema.prisma file. Define a simple Task model:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Task {
  id        Int      @id @default(autoincrement())
  title     String
  isCompleted Boolean @default(false)
  createdAt DateTime @default(now())
}

Run migrations:

npx prisma migrate dev --name init
🛠️ Step 3: Using Prisma in NestJS

`Create a Prisma service:

nest g service prisma`

prisma.service.ts:

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect();
  }
  async onModuleDestroy() {
    await this.$disconnect();
  }
}

Now inject it into your TasksService:

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class TasksService {
  constructor(private prisma: PrismaService) {}

  findAll() {
    return this.prisma.task.findMany();
  }

  create(title: string) {
    return this.prisma.task.create({ data: { title } });
  }

  update(id: number, isCompleted: boolean) {
    return this.prisma.task.update({
      where: { id },
      data: { isCompleted },
    });
  }

  delete(id: number) {
    return this.prisma.task.delete({ where: { id } });
  }
}

Now your Tasks API is connected to PostgreSQL with Prisma 🎉.

🔄 Alternative: TypeORM with NestJS

Some teams still prefer TypeORM for its flexibility. Here’s the quick setup:

npm install @nestjs/typeorm typeorm pg

Add it to app.module.ts:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Task } from './tasks/task.entity';
import { TasksModule } from './tasks/tasks.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'admin',
      password: 'admin',
      database: 'tasks',
      entities: [Task],
      synchronize: true,
    }),
    TasksModule,
  ],
})
export class AppModule {}

task.entity.ts:

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Task {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column({ default: false })
  isCompleted: boolean;
}

Inject repositories with @InjectRepository(Task) in your services.

🚀 Conclusion

Prisma gives you type safety and an amazing developer experience.

TypeORM is feature-rich and widely adopted.

👉 Choose Prisma if you want speed + DX.
👉 Choose TypeORM if you need complex queries and legacy support.

Now your NestJS app can persist data into a database like a real-world backend.

In the next part of the series, we’ll tackle Authentication & Authorization with JWTs and Guards.

💡 Found this useful? Drop a ❤️ on Dev.to and follow me for Part 3 of the NestJS Expert Series.

Ulaa: India’s Next Browser for Developers and Privacy Enthusiasts 🚀

Yogesh Prasad — Tue, 30 Sep 2025 12:35:41 +0000

Ulaa: India’s Next Browser for Developers and Privacy Enthusiasts 🚀

When it comes to web browsers, we usually hear the same big names: Chrome, Firefox, Edge, Brave. Most of them are either from the US or Europe, with data policies that often raise questions in countries like India.

But now, we finally have a strong Made-in-India alternative: Ulaa by Zoho.
Ulaa means journey in Tamil — and it truly feels like the beginning of India’s journey toward building a privacy-first, developer-friendly browser that competes with global giants.

In this blog, I’ll share my experience of using Ulaa as a developer in India, what makes it stand out, and why it deserves to be called India’s next browser.

🌏 Why India Needs Its Own Browser

India is rapidly moving toward data sovereignty — ensuring that user data is stored, managed, and protected within the country. With 1.4 billion people, the need for a browser that is built in India, for Indians, with global standards is huge.

Here’s why:

Dependence on foreign tech → Most browsers rely on US-based companies.

Privacy concerns → Data is often collected, tracked, and monetized.

Local innovation → India has the talent to build world-class software — Zoho’s success proves it.

Ulaa isn’t just another Chromium fork. It’s India’s shot at redefining the browser space with privacy, productivity, and ethical design.

⚡ First Impressions as a Developer

As a developer, here’s what stood out when I started using Ulaa:

Multiple Browsing Modes

Unlike Chrome or Firefox, Ulaa lets you switch modes:

Work Mode – Isolate projects and keep professional sessions separate.

Developer Mode – Tailored for debugging and testing.

Kids Mode – Safe browsing for children.

Personal Mode – Private browsing without trackers.

Open Season Mode – Compatibility for sites that force cookies/trackers.

This separation is a blessing for developers in India juggling client projects, side hustles, and personal life — all in one machine.

Built-in Privacy Features

Ad & tracker blocking by default.

DNS-level blocking for malicious domains.

Zero hidden sync with foreign servers.

In a time when digital privacy is becoming as important as financial privacy, Ulaa stands tall.

Productivity-First Design

Tab grouping & session isolation → Perfect for handling multiple clients.

Built-in screen capture & annotations → Share quick feedback with teams.

Reader mode → Distraction-free learning, ideal for reading Indian govt policies, dev blogs, or long-form docs.

These small details feel made for real working professionals in India.

Feature	Chrome	Brave	Firefox	Ulaa (India)
Origin	USA	USA	USA	🇮🇳 India
Privacy-first	❌	✅	✅	✅✅
Multiple browsing modes	❌	❌	❌	✅
Developer workflow mode	❌	❌	Partial	✅
Built-in productivity	❌	Limited	Limited	✅
Ethical data use	❌	✅	✅	✅✅

With Ulaa, we finally have a homegrown browser that competes globally.

💡 Why Developers in India Should Care

Local trust → Built in India, by Zoho (a trusted SaaS giant).

Better debugging → Separate workflows for development and testing.

No vendor lock-in → Your data isn’t tied to foreign companies.

Project-friendly → Great for freelancers, startups, and agencies in India handling multiple clients.

🚀 Final Thoughts

Ulaa may be new, but it’s a serious contender.

It respects Indian users’ privacy.

It promotes data sovereignty.

It’s designed with developers and productivity in mind.

Is it perfect? Not yet — the extension ecosystem still needs to grow, and some sites behave better in "Open Season" mode. But as India’s first big step in the browser space, Ulaa is both promising and refreshing.

✅ Takeaway

If you want to support a Made-in-India browser that:

Respects your privacy,

Boosts your productivity,

And gives developers thoughtful tools…

👉 Give Ulaa a try. It might just be India’s answer to Chrome and Brave.

💬 Over to you: Do you think India can build a global tech product in the browser space? Have you tried Ulaa yet?

Mastering NestJS: A Modern Approach to Building Scalable Node.js Applications

Yogesh Prasad — Tue, 30 Sep 2025 08:54:12 +0000

🚀 Mastering NestJS: A Modern Approach to Building Scalable Node.js Applications

When it comes to building scalable and maintainable backend applications, developers often find themselves struggling with vanilla Node.js and Express. While they are powerful, they lack structure when your project grows beyond a few routes.

This is where NestJS comes in—a progressive Node.js framework that provides an opinionated yet flexible architecture out of the box, enabling developers to build enterprise-grade applications with confidence.

In this article, we’ll explore why NestJS is becoming the go-to framework for Node.js development and how you can use it to architect applications like an expert.

🔑 Why NestJS?

NestJS is built on top of Express (or optionally Fastify) and leverages TypeScript to enforce clean code structure.

Here’s what makes it stand out:

Opinionated Architecture – Inspired by Angular, it uses modules, controllers, and providers to keep code organized.

Dependency Injection – Built-in support for DI ensures testability and reusability.

Microservices Ready – Built-in support for gRPC, Kafka, RabbitMQ, and more.

Scalable Monoliths & Microservices – Perfect for both startups and enterprises.

Strong Type Safety – Leverages TypeScript for better developer experience.

🏗️ The Core Building Blocks

Before we dive into code, let’s understand the NestJS building blocks:

Modules – Logical units of your app (like UsersModule, AuthModule).
Controllers – Handle incoming requests and return responses.
Providers (Services) – Business logic and reusable code live here.
Dependency Injection – Services are injected where needed.
Middleware, Guards, Interceptors, and Pipes – Powerful tools for cross-cutting concerns like validation, logging, and authentication.

⚡ Quick Start Example: A CRUD API

Let’s build a simple Tasks API to demonstrate NestJS fundamentals.
`

Install NestJS CLI

npm i -g @nestjs/cli

Create a new project

nest new tasks-api`

Now, let’s create a Tasks module:

nest g module tasks nest g controller tasks nest g service tasks

tasks.service.ts

`import { Injectable } from '@nestjs/common';

interface Task {
  id: number;
  title: string;
  isCompleted: boolean;
}

@Injectable()
export class TasksService {
  private tasks: Task[] = [];

  findAll(): Task[] {
    return this.tasks;
  }

  create(title: string): Task {
    const task: Task = {
      id: Date.now(),
      title,
      isCompleted: false,
    };
    this.tasks.push(task);
    return task;
  }

  update(id: number, isCompleted: boolean): Task {
    const task = this.tasks.find((t) => t.id === id);
    if (task) {
      task.isCompleted = isCompleted;
    }
    return task;
  }

  delete(id: number): void {
    this.tasks = this.tasks.filter((t) => t.id !== id);
  }
}`

tasks.controller.ts

import { Controller, Get, Post, Body, Param, Patch, Delete } from '@nestjs/common';
import { TasksService } from './tasks.service';

@Controller('tasks')
export class TasksController {
  constructor(private readonly tasksService: TasksService) {}

  @Get()
  findAll() {
    return this.tasksService.findAll();
  }

  @Post()
  create(@Body('title') title: string) {
    return this.tasksService.create(title);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body('isCompleted') isCompleted: boolean) {
    return this.tasksService.update(+id, isCompleted);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    this.tasksService.delete(+id);
    return { message: 'Task deleted' };
  }
}

With just a few lines of code, you now have a fully working CRUD API with clean architecture.

🛡️

Going Pro: Advanced Features

To really become an expert in NestJS, you need to go beyond CRUD. Here’s what you should explore:

Authentication & Authorization – Use Guards and Passport.js strategies for role-based access.
Validation – Leverage Pipes and the class-validator library for request validation.
Logging & Monitoring – Implement custom Interceptors and connect with tools like Prometheus or ELK stack.
Database Integration – Use TypeORM, Prisma, or Sequelize seamlessly with NestJS.
Microservices & Event-Driven Architecture – Scale your app using message brokers like Kafka or RabbitMQ.
GraphQL Support – Build APIs with GraphQL and schema-first or code-first approaches.
Testing – Take advantage of Nest’s built-in unit and e2e testing support.

🌍

Real-World Use Cases

NestJS is being used in production by companies across fintech, e-commerce, SaaS, and gaming. Some popular scenarios include:
Banking & Fintech Apps – Secure APIs with auditing and transaction handling.
E-commerce Platforms – Scalable APIs with microservices.
SaaS Products – Multi-tenant apps with modular architecture.
IoT & Event-Driven Systems – Real-time communication with microservices.

🚀

Conclusion

NestJS is not just another Node.js framework—it’s a complete architecture solution for building scalable, testable, and enterprise-ready applications.

By mastering modules, controllers, services, guards, and interceptors, you’ll be equipped to build backends that can scale from MVPs to complex microservices.