DEV Community: Luqman Bolajoko

🔥 What I Learned From OgaVenue’s Rise and Fall — And How IsabiVenues Is Doing It Differently

Luqman Bolajoko — Mon, 30 Jun 2025 08:50:15 +0000

In Nigeria’s fast-growing event industry, one startup once stood out as the go-to for booking venues: OgaVenue. They had funding, visibility, and strong early traction. But despite a great idea and some early wins, the platform faded into obscurity.

As the founder of IsabiVenues, I’ve studied OgaVenue’s journey deeply. Why did it lose steam? What were the traps? And how do we build something more resilient for the Nigerian market?

Here’s what I learned—and how we’re applying it to do better.

❌ What Went Wrong With OgaVenue

Users and Venue Owners Bypassed the Platform After discovering venues on OgaVenue, people often contacted the venue directly to avoid commissions. This killed their revenue engine.
No Real-Time Booking The process wasn’t seamless. Users had to wait for manual confirmation. That’s friction—and friction loses customers.
Venue Owners Were Not Fully Onboard Many venues just used the platform for passive leads but didn’t update availability, respond fast, or stay committed.
No Strong Differentiator It became more of a directory than a platform—making it easy to be bypassed, ignored, or replaced.
Nigeria-Specific Challenges From distrust of online payments to preference for face-to-face negotiation, the product didn’t adapt deeply enough to the local realities.

✅ What We’re Doing Differently With IsabiVenues

Exclusivity & Incentives We’re partnering with venues to offer discounts, perks, and limited-time deals only available via IsabiVenue.
True Real-Time Booking No waiting. We’re building a frictionless experience where users can view availability, book instantly, and pay securely.
Tools for Venue Owners From dashboards and automated confirmations to lead tracking and analytics—we’re making venue owners love using IsabiVenue, not just tolerate it.
Booking Protection & Trust We’re introducing verified listings, secure payments, and cancellation protection. It’s not just about booking—it’s about peace of mind.
Built for the Nigerian Market Our UX and messaging speak the local language—literally and culturally. We’re blending online booking with offline support, WhatsApp follow-ups, and more.

💡 Final Thoughts

OgaVenue walked so others could run. Their story is a goldmine of lessons—not a failure to laugh at, but a roadmap of what to do better.

At IsabiVenues, we’re taking these insights seriously. Our goal is not just to build a website. It’s to build the future of venue booking in Nigeria, powered by trust, technology, and local understanding.

If you're an investor, venue owner, or event planner who wants to be part of that journey—let's talk.

hashtag#EventTech hashtag#IsabiVenues hashtag#StartupLessons hashtag#NigerianTech hashtag#MarketplaceStrategy hashtag#PMF hashtag#StartupAfrica hashtag#EventPlanning hashtag#FoundersJourney

Connecting NestJS and ASP.NET Core with gRPC: A Step-by-Step Guide

Luqman Bolajoko — Mon, 30 Sep 2024 07:09:53 +0000

As microservices continue to grow in popularity, efficient communication between services becomes increasingly important. gRPC, a high-performance RPC framework, is ideal for such scenarios due to its support for language-agnostic, efficient binary serialization. In this article, we'll explore how to create a gRPC service in ASP.NET Core and consume it from a NestJS client.

1. Create the gRPC Service in ASP.NET Core

Step 1: Set Up an ASP.NET Core gRPC Service

First, create a new ASP.NET Core gRPC Service.

dotnet new grpc -n GrpcService
cd GrpcService

Ensure you have the following package in your .csproj file:

<PackageReference Include="Grpc.AspNetCore" Version="2.40.0" />

Step 2: Define the gRPC Service in Proto File

In the Protos folder, define your gRPC service and messages using the .proto format.

syntax = "proto3";

option csharp_namespace = "GrpcService";

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Step 3: Implement the gRPC Service

Now, implement the gRPC service in C# by overriding the SayHello method defined in the .proto file. Create a GreeterService.cs in your project:

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}!"
        });
    }
}

Step 4: Configure ASP.NET Core for gRPC

In the Startup.cs file, configure your gRPC service:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGrpcService<GreeterService>();

        // For gRPC-Web support:
        endpoints.MapGrpcWeb();
    });
}

Run the ASP.NET Core gRPC service:

dotnet run

Now, your gRPC service is running on https://localhost:5001.

2. Connect to the ASP.NET Core gRPC Service from a NestJS Client

Step 1: Set Up a NestJS Project

Create a new NestJS project to act as the client:

nest new grpc-client
cd grpc-client

Step 2: Install gRPC and Protobuf Dependencies

To use gRPC in NestJS, you need to install the following dependencies:

npm install @nestjs/microservices grpc @grpc/proto-loader

Step 3: Define the Proto File in NestJS

Copy the .proto file from the ASP.NET Core service and place it in the NestJS project, inside a protos folder. This ensures both the client and the server use the same contract.

Your protos/greet.proto file should look like this:

syntax = "proto3";

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Step 4: Configure the NestJS gRPC Client

In your app.module.ts, set up the NestJS gRPC client to connect to the ASP.NET Core service:

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { join } from 'path';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'GREETER_PACKAGE',
        transport: Transport.GRPC,
        options: {
          url: 'localhost:5001',
          package: 'greeter',
          protoPath: join(__dirname, './protos/greet.proto'),
        },
      },
    ]),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Step 5: Create the NestJS Service and Controller

Create the service that will call the gRPC method:

import { Injectable } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { Observable } from 'rxjs';
import { OnModuleInit, Inject } from '@nestjs/common';

interface GreeterService {
  sayHello(data: { name: string }): Observable<{ message: string }>;
}

@Injectable()
export class AppService implements OnModuleInit {
  private greeterService: GreeterService;

  constructor(@Inject('GREETER_PACKAGE') private client: ClientGrpc) {}

  onModuleInit() {
    this.greeterService = this.client.getService<GreeterService>('Greeter');
  }

  sayHello(name: string): Observable<{ message: string }> {
    return this.greeterService.sayHello({ name });
  }
}

In your app.controller.ts, create an endpoint that consumes the gRPC service:

import { Controller, Get, Query } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('hello')
  sayHello(@Query('name') name: string) {
    return this.appService.sayHello(name);
  }
}

Step 6: Run the NestJS Client

Start the NestJS client:

npm run start

Now, you can call http://localhost:3000/hello?name=NestJS from a browser or Postman. The NestJS client will call the ASP.NET Core gRPC service, which responds with a greeting message.

Best Practices for Connecting gRPC Services Across Platforms

Shared Proto Files: Ensure that both services (ASP.NET Core and NestJS) use the same .proto file for compatibility.
gRPC Communication: Since gRPC uses HTTP/2, make sure that both your client and server are running in environments that support HTTP/2.
Security: Always use TLS (HTTPS) for gRPC communication, especially in production environments, to secure data transmission.
Load Balancing: When scaling the ASP.NET Core gRPC service, implement load balancing mechanisms to distribute traffic efficiently.
Error Handling: Handle gRPC errors properly, as they differ from traditional REST errors. Implement retry mechanisms and ensure that errors are communicated to clients clearly.

Conclusion

gRPC provides a powerful way to connect microservices across different platforms and languages. By using ASP.NET Core for the gRPC server and NestJS for the client, you can take advantage of gRPC’s performance and binary serialization to build fast, scalable, and reliable APIs.

Whether you're building a distributed system or integrating different services, gRPC offers an efficient communication model that scales well for both simple and complex use cases. Try it out in your next project and experience the power of cross-platform microservices!

Implementing ASP.NET Identity for a Multi-Tenant Application: Best Practices

Luqman Bolajoko — Mon, 23 Sep 2024 09:57:22 +0000

Building a multi-tenant application presents unique challenges, especially when it comes to managing user authentication and authorization across multiple tenants. In this article, I’ll walk you through how to implement ASP.NET Identity in a multi-tenant environment while following best practices to ensure scalability, security, and maintainability.

What is a Multi-Tenant Application?

A multi-tenant application allows multiple organizations (tenants) to use the same instance of an application, with each tenant’s data isolated from others. This architecture is efficient for scaling and cost-sharing but requires special consideration when handling user authentication and authorization.

Setting up ASP.NET Identity for Multi-Tenancy

ASP.NET Identity is a flexible framework for handling authentication and user management. To adapt it for a multi-tenant setup, you need to:

Identify and differentiate tenants in your user store.
Isolate user data so each tenant only sees its own users.
Implement custom authentication and role management tailored to each tenant.

Step 1: Modify the User Model to Support Multi-Tenancy

In a multi-tenant app, each user must be associated with a specific tenant. You can modify the ASP.NET Identity User model by adding a TenantId property to track the tenant a user belongs to.

public class ApplicationUser : IdentityUser
{
    public string TenantId { get; set; }
}

Step 2: Extend IdentityDbContext to Handle Tenant Data

Next, extend the IdentityDbContext to support tenant-specific data by ensuring that queries are filtered based on the TenantId.

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        // Add a global query filter to isolate data by tenant
        builder.Entity<ApplicationUser>().HasQueryFilter(u => u.TenantId == GetCurrentTenantId());
    }

    private string GetCurrentTenantId()
    {
        // Implement logic to retrieve the current tenant's ID, e.g., from the request or context
        return TenantResolver.ResolveTenantId();
    }
}

Step 3: Tenant Resolution

To ensure that each user is associated with the correct tenant, you'll need a tenant resolver to determine which tenant the current request is related to. This can be based on the subdomain, a URL segment, or a custom header.

public static class TenantResolver
{
    public static string ResolveTenantId()
    {
        // Example: Resolve tenant from subdomain or URL segment
        var host = HttpContext.Current.Request.Host.Value;
        return host.Split('.')[0]; // Assuming subdomain is used for tenant identification
    }
}

Step 4: Configure Authentication

In a multi-tenant application, it's essential to ensure that users can only authenticate with their tenant-specific credentials. Customize the login logic to check for the TenantId during authentication.

public class CustomSignInManager : SignInManager<ApplicationUser>
{
    public CustomSignInManager(UserManager<ApplicationUser> userManager,
                               IHttpContextAccessor contextAccessor,
                               IUserClaimsPrincipalFactory<ApplicationUser> claimsFactory,
                               IOptions<IdentityOptions> optionsAccessor,
                               ILogger<SignInManager<ApplicationUser>> logger,
                               IAuthenticationSchemeProvider schemes,
                               IUserConfirmation<ApplicationUser> confirmation)
        : base(userManager, contextAccessor, claimsFactory, optionsAccessor, logger, schemes, confirmation)
    { }

    public override async Task<SignInResult> PasswordSignInAsync(string userName, string password, bool isPersistent, bool lockoutOnFailure)
    {
        // Resolve tenant before signing in
        var tenantId = TenantResolver.ResolveTenantId();
        var user = await UserManager.FindByNameAsync(userName);

        if (user == null || user.TenantId != tenantId)
        {
            return SignInResult.Failed;
        }

        return await base.PasswordSignInAsync(userName, password, isPersistent, lockoutOnFailure);
    }
}

Step 5: Role-Based Access Control (RBAC) by Tenant

Each tenant may have its own set of roles and permissions. Modify your role model to include a TenantId and adjust role checks to account for the current tenant.

public class ApplicationRole : IdentityRole
{
    public string TenantId { get; set; }
}

Step 6: Secure Data Access

With multi-tenant applications, data isolation is crucial. In addition to securing authentication and authorization, ensure that users can only access tenant-specific data. Apply global query filters in your DbContext or use repository patterns to filter data based on the current TenantId.

public class UserRepository : IUserRepository
{
    private readonly ApplicationDbContext _context;

    public UserRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public IQueryable<User> GetUsers()
    {
        var tenantId = TenantResolver.ResolveTenantId();
        return _context.Users.Where(u => u.TenantId == tenantId);
    }
}

Step 7: Testing Multi-Tenancy

When testing a multi-tenant app, ensure you:

Test login and authentication for multiple tenants.
Ensure users and roles are properly isolated across tenants.
Verify data is accessible only to authorized tenants.

Using unit tests and integration tests, mock tenant resolution and ensure tenant-specific logic is applied.

[TestMethod]
public async Task User_Should_Only_See_Tenant_Data()
{
    // Arrange
    var tenantId = "tenant_1";
    var tenantUser = new ApplicationUser { UserName = "user1", TenantId = tenantId };

    // Act
    var result = await _signInManager.PasswordSignInAsync(tenantUser.UserName, "password", false, false);

    // Assert
    Assert.AreEqual(SignInResult.Success, result);
}

Best Practices Recap

Isolate User and Role Data: Ensure that users, roles, and permissions are scoped to specific tenants.
Global Query Filters: Use query filters to automatically scope data access to the correct tenant.
Tenant Resolution: Implement a robust tenant resolution strategy based on subdomains, URL segments, or custom headers.
Custom Authentication: Customize the authentication process to include tenant checks.
Test Thoroughly: Always test your application in multi-tenant scenarios to avoid security and data leakage issues.

Conclusion

Implementing ASP.NET Identity in a multi-tenant environment can be challenging, but with the right practices, you can ensure scalability, security, and data isolation. By following the steps outlined in this guide, you'll be able to build a robust multi-tenant identity management system tailored to the needs of each tenant.

Let me know if you’ve encountered similar challenges or have other best practices for multi-tenant applications. I'd love to hear your thoughts in the comments!

Best Practices for Building .NET Core Web APIs

Luqman Bolajoko — Sat, 14 Sep 2024 14:40:33 +0000

When building APIs in .NET Core, ensuring they are efficient, secure, scalable, and easy to maintain is crucial. In this post, I’ll walk through some best practices for building .NET Core Web APIs, covering areas such as performance, security, and maintainability.

1. Leverage Dependency Injection

One of the biggest advantages of .NET Core is its built-in Dependency Injection (DI) support. DI helps in managing service lifetimes and reducing tight coupling between components. Use it to inject dependencies such as services, repositories, and other layers into your controllers.

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IMyService, MyService>();
}

2. Follow RESTful Principles

Ensure your APIs follow standard RESTful conventions. Use proper HTTP methods (GET, POST, PUT, DELETE) for operations and return appropriate status codes (200 for success, 404 for not found, 201 for created, etc.).

[HttpGet("{id}")]
public async Task<IActionResult> GetUser(int id)
{
    var user = await _userService.GetUserAsync(id);
    return user == null ? NotFound() : Ok(user);
}

3. Secure Your API

Security is critical. Always use HTTPS to encrypt communication between the client and server. Implement JWT (JSON Web Token) for authentication and authorization, allowing only authenticated users to access specific endpoints.

[Authorize]
[HttpGet("secure-data")]
public IActionResult GetSecureData()
{
    return Ok("This data is secured!");
}

4. Centralize Error Handling

Use Middleware for centralized exception handling to ensure that errors are consistently handled across your API. This approach simplifies your controllers and keeps the error-handling logic separate.

public class ErrorHandlingMiddleware
{
    public async Task Invoke(HttpContext context, RequestDelegate next)
    {
        try
        {
            await next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private static Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        context.Response.StatusCode = 500;
        return context.Response.WriteAsync(ex.Message);
    }
}

5. Use Data Transfer Objects (DTOs)

DTOs help manage the data flow between your client and server, ensuring that only required fields are exposed and minimizing data transfer size. They also prevent over-posting and under-posting attacks.

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

6. API Versioning

Over time, your API will evolve, and breaking changes may occur. Use API versioning to maintain backward compatibility and ensure clients can continue using older versions without breaking.

[ApiVersion("1.0")]
[Route("api/v{version:apiVersion}/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult GetV1() => Ok("Version 1");
}

7. Enable Caching for Better Performance

For APIs that return frequently requested data, implement caching to reduce server load and improve response times. You can use In-Memory Cache or Distributed Cache depending on your needs.

[ResponseCache(Duration = 60)]
[HttpGet("{id}")]
public IActionResult GetCachedUser(int id)
{
    var user = _userService.GetUser(id);
    return Ok(user);
}

8. Log Everything

Logging is essential for monitoring and debugging APIs in production. Use libraries like Serilog or NLog to track requests, responses, and errors. Structured logging makes it easier to search and analyze logs.

public class MyService
{
    private readonly ILogger<MyService> _logger;

    public MyService(ILogger<MyService> logger)
    {
        _logger = logger;
    }

    public void Process()
    {
        _logger.LogInformation("Processing request at {Time}", DateTime.UtcNow);
    }
}

9. Validate Incoming Data

Use Data Annotations or Fluent Validation to validate user input and ensure data integrity. Validation should occur at the API boundary to prevent invalid data from flowing through the system.

public class UserDto
{
    [Required]
    [StringLength(50, MinimumLength = 2)]
    public string Name { get; set; }

    [EmailAddress]
    public string Email { get; set; }
}

10. Implement Pagination and Filtering

For large datasets, implement pagination and filtering to avoid sending too much data in a single request. This approach improves performance and provides a better user experience.

[HttpGet]
public async Task<IActionResult> GetUsers([FromQuery] int pageNumber = 1, [FromQuery] int pageSize = 10)
{
    var users = await _userService.GetUsersAsync(pageNumber, pageSize);
    return Ok(users);
}

11. Use Async/Await for Non-Blocking Operations

To improve scalability and responsiveness, always use asynchronous methods for I/O-bound operations. This prevents blocking threads while waiting for external resources.

public async Task<IActionResult> GetUser(int id)
{
    var user = await _userService.GetUserByIdAsync(id);
    return Ok(user);
}

12. Add Swagger for API Documentation

Use Swagger to generate interactive API documentation. It allows developers to easily explore your API’s endpoints, see request/response formats, and test the API in real-time.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSwaggerGen(c =>
    {
        c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    });
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
    });
}

Conclusion

These best practices for .NET Core Web APIs ensure that your application is secure, performant, and scalable. Whether you’re building small APIs or enterprise-level systems, these tips will help make your codebase more maintainable and easier to work with.

Do you have other tips for improving .NET Core APIs? Drop them in the comments below!

Building a Scalable Multi-Tenant Community Management System with ASP.NET and Angular

Luqman Bolajoko — Fri, 13 Sep 2024 10:13:23 +0000

Introduction

Managing multiple communities from a single platform can be a daunting task, especially when data isolation, user roles, and performance are critical requirements. In this post, I’ll take you through how I built Community Hub, a multi-tenant community management system using ASP.NET and Angular. The goal was to create a platform that allowed administrators to efficiently manage multiple communities with separate users, events, and reports, while ensuring system scalability and security.

Why Multi-Tenancy?

Multi-tenancy allows a single software application to serve multiple tenants (in this case, communities) with data isolation and different user roles. This design is cost-effective, scalable, and ideal for businesses and organizations managing several independent groups.

In Community Hub, each tenant is a distinct community that can manage its members, events, and resources independently. This setup ensures that data from one tenant never interferes with another while maintaining performance as the number of communities grows.

Tech Stack

Backend: ASP.NET Core for building scalable web services and APIs.
Frontend: Angular for a responsive user interface.
Database: SQL Server with multi-tenant support using row-level security.
Authentication: JWT for secure access control across tenants.
Implementing the Core Features

Designing a Multi-Tenant Architecture

The core challenge was creating a system where each tenant (community) could operate independently while sharing the same infrastructure. I implemented multi-tenancy using a shared schema approach, where each database table contains a TenantID column. This ensures that data is scoped to the correct tenant by filtering queries based on the tenant's ID.

Role-Based Access Control (RBAC)

Each tenant has its own set of users with distinct roles like Admins, Leaders, and Members. I used ASP.NET Identity to manage role-based access control, ensuring that each user has appropriate permissions based on their role within the community.

Optimizing Performance for Multiple Tenants

As the number of tenants grows, performance can become a bottleneck. To address this, I optimized database queries using indexing and caching. These optimizations reduced response times and ensured that the application could handle higher loads without sacrificing performance.

Challenges Faced and Solutions

Data Isolation Across Tenants
The primary challenge was ensuring that data from one tenant never leaked into another tenant’s workspace. By using TenantID filtering on all database queries, I achieved complete data isolation.

Maintaining Performance at Scale

As the system grew, handling a large number of tenants required further performance optimizations. I implemented database sharding and distributed caching to ensure that frequently accessed data was retrieved quickly, reducing server load and improving user experience.

Conclusion

Building a scalable multi-tenant platform like Community Hub involves careful planning around data architecture, user roles, and performance optimization. ASP.NET and Angular provided the perfect combination of scalability and security for this project.

If you’re looking to build a similar multi-tenant system or have any questions, feel free to reach out or leave a comment below!