Sagar Dolui | RSS Feed

Inside SessionOrbit: Designing an AI-Powered Virtual Classroom Platform

sagar03d@gmail.com — Fri, 10 May 2024 00:00:00 GMT

Managing high-frequency online tutoring sessions requires coordinate-heavy synchronization between students, educators, parents, and administrative staff.

I designed and built SessionOrbit as a modern, centralized operations platform to address these pain points.

Platform Highlights

Centralized Operations & Scheduling: Automated real-time calendar bookings, attendance tracking, and teacher-student matching.
40% Administrative Overhead Reduction: Eliminated manual logging through automated webhook session triggers and instantaneous billing reconciliation.
AI Assistance: Integrated automated session notes, transcript summarization, and key concept indexing for students following each class.
Real-time Synchronized Whiteboards: Low-latency collaborative canvases built on top of WebSockets and canvas rendering.

Technology Stack

Frontend: React.js, TypeScript, TailwindCSS / Custom Design System
Backend: Node.js, Express, Socket.io
Database: PostgreSQL on Cloud SQL / Supabase
AI: OpenAI API with custom prompt chains

Architecting Scalable EdTech Systems for 60K+ Monthly Active Users

sagar03d@gmail.com — Sun, 18 Feb 2024 00:00:00 GMT

Scaling an educational technology platform presents unique architectural challenges. Unlike typical e-commerce traffic where requests are distributed throughout the day, EdTech traffic features massive peak concurrency spikes during live classroom schedules and exam periods.

In this article, I share the architectural decisions and engineering practices we implemented to maintain 99.99% uptime for over 60K+ monthly active users.

The Architecture Overview

Our backend ecosystem consists of decoupled microservices written in Node.js (TypeScript) and Laravel (PHP), containerized with Docker and deployed on Google Cloud Platform (GCP).

Client (Web / Mobile)
        │
   Cloud Load Balancing (NGINX + SSL)
        │
   ┌────┴─────────────────────────────┐
   ▼                                  ▼
Node.js Real-time Service     Laravel Core REST API
(WebSockets / Analytics)      (Auth, Billing, Scheduling)
   │                                  │
   ├──────────────┬───────────────────┤
   ▼              ▼                   ▼
Cloud SQL      Redis Cache         GCS Storage
(PostgreSQL)   (Pub/Sub & Sessions)

Key Engineering Pillars

1. High-Availability Cloud Infrastructure

We migrated our core compute workloads to GCP utilizing Compute Engine managed instance groups with autoscaling and Cloud SQL for PostgreSQL configured with high availability (HA) regional failover.

2. State Synchronization with WebSockets

For real-time classroom telemetry, tutor presence, and live student attendance, we implemented a dedicated Node.js WebSocket cluster with Redis Pub/Sub backplane. This decoupled live events from transactional database operations.

3. Automated Monitoring & 99.99% SLA

By leveraging health checks, structured JSON logging, and Prometheus/Grafana alerting, our team eliminated single points of failure and brought downtime to virtually zero.

Conclusion

Architecting for scale requires proactive load isolation, smart caching boundaries, and resilient failover mechanisms. With the right foundation, platforms can easily handle rapid user growth without performance degradation.

Cost-Effective LLM Integration with OpenAI & Claude APIs

sagar03d@gmail.com — Fri, 01 Dec 2023 00:00:00 GMT

Integrating LLM APIs like OpenAI GPT-4o and Anthropic Claude into high-volume SaaS applications can quickly escalate operational costs if not engineered with token efficiency in mind.

Strategies for Cost Reduction

Semantic Prompt Caching: Using Redis with vector embeddings to return cached responses for semantically identical questions.
Model Tier Routing: Routing simple classification, tag extraction, or formatting tasks to lightweight models (e.g. GPT-4o-mini / Claude 3.5 Haiku) while reserving frontier models for reasoning tasks.
Structured Outputs & Schema Constraints: Enforcing JSON mode with schema guarantees to eliminate repetitive prompt instructions and output truncation re-tries.

Optimizing PostgreSQL Query Performance & Indexing: 800ms to 320ms

sagar03d@gmail.com — Fri, 10 Nov 2023 00:00:00 GMT

When API latency is dominated by database execution time, optimizing database queries yields the highest return on investment. In this post, I detail how we investigated slow endpoints and reduced average API latency from 800ms down to 320ms—a 60% performance improvement.

Pinpointing Bottlenecks with EXPLAIN ANALYZE

The first step in any database tuning effort is quantifying where the database engine spends CPU cycles and I/O reads.

EXPLAIN (ANALYZE, BUFFERS, COSTS, VERBOSE)
SELECT s.id, s.title, f.name, COUNT(a.id) as attendee_count
FROM sessions s
JOIN faculties f ON f.id = s.faculty_id
LEFT JOIN attendance a ON a.session_id = s.id
WHERE s.scheduled_at >= NOW() - INTERVAL '30 days'
  AND s.status = 'COMPLETED'
GROUP BY s.id, f.name
ORDER BY s.scheduled_at DESC
LIMIT 50;

The Problem: Sequential Scans on High-Churn Tables

The query plan revealed sequential table scans across over 2 million attendance records because composite keys were not properly indexed, and filter predicates evaluated unindexed boolean expressions.

Optimization Strategies

1. Composite & Partial Indexes

Rather than indexing whole columns indiscriminately, we created targeted composite and partial indexes for hot queries:

-- Partial index targeting active completed sessions
CREATE INDEX idx_sessions_completed_scheduled 
ON sessions (scheduled_at DESC, faculty_id) 
WHERE status = 'COMPLETED';

-- Covering index on foreign keys with included columns
CREATE INDEX idx_attendance_session_covered 
ON attendance (session_id) 
INCLUDE (student_id, attended_at);

2. Eliminating N+1 Joins in ORMs

In our Laravel and Node.js repositories, we replaced implicit nested relationships with eager loading and window functions (ROW_NUMBER() / DENSE_RANK()), avoiding multiple roundtrips to Cloud SQL.

3. Connection Pooling with PgBouncer

We introduced connection pooling to eliminate the overhead of TCP handshakes and PostgreSQL backend process forking on every request.

Results

Average API Response Time: 800ms ➡️ 320ms (60% decrease)
p99 Latency: 2.4s ➡️ 650ms
Database CPU Utilization: Reduced from 78% peak to 34% steady state.

Building Production RAG Pipelines with Node.js, LangChain & OpenAI

sagar03d@gmail.com — Tue, 05 Sep 2023 00:00:00 GMT

Retrieval-Augmented Generation (RAG) allows Large Language Models (LLMs) to answer queries using dynamic, domain-specific private data without costly fine-tuning.

In building Blogineers and AI classroom capabilities for SessionOrbit, we engineered high-accuracy RAG workflows capable of ingesting raw markdown and documents, vectorizing them, and synthesizing accurate answers.

The Core Pipeline

[Raw Documents / Transcripts]
            │
      Text Splitter (RecursiveCharacterTextSplitter)
            │ Chunks (500 tokens, 10% overlap)
            ▼
   Embedding Generation (text-embedding-3-small)
            │
            ▼
    Vector Store (Supabase pgvector / Pinecone)
            │
   [User Query] ──► Query Embedding ──► Cosine Similarity Top-K
                                                │
                                                ▼
                             Context Injection + Prompt Template
                                                │
                                                ▼
                                    LLM Generation (OpenAI GPT-4o / Claude)

TypeScript Implementation

import { OpenAIEmbeddings } from '@langchain/openai';
import { SupabaseVectorStore } from '@langchain/community/vectorstores/supabase';
import { ChatOpenAI } from '@langchain/openai';
import { PromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

export async function queryRAG(question: string, client: any) {
  const embeddings = new OpenAIEmbeddings({
    modelName: 'text-embedding-3-small',
  });

  const vectorStore = new SupabaseVectorStore(embeddings, {
    client,
    tableName: 'documents',
    queryName: 'match_documents',
  });

  const relevantDocs = await vectorStore.similaritySearch(question, 4);
  const context = relevantDocs.map((doc) => doc.pageContent).join('\n---\n');

  const model = new ChatOpenAI({
    modelName: 'gpt-4o',
    temperature: 0.2,
  });

  const prompt = PromptTemplate.fromTemplate(`
    You are an expert technical advisor. Answer based ONLY on the following context:
    {context}

    Question: {question}
  `);

  const chain = prompt.pipe(model).pipe(new StringOutputParser());
  return await chain.invoke({ context, question });
}

Best Practices

Chunk Overlap: Always preserve 10-15% chunk overlap to maintain context across boundary splits.
Metadata Filtering: Filter by tenant ID and date before similarity ranking to enforce multi-tenant isolation.
Low Temperature: Use temperatures between 0.0 and 0.3 for factual question-answering systems.

Database Connection Pooling and High-Concurrency Handling in Node.js

sagar03d@gmail.com — Fri, 14 Jul 2023 00:00:00 GMT

Under sudden traffic bursts, Node.js applications that create database connections on the fly can quickly exhaust PostgreSQL max_connections, leading to cascading gateway timeouts.

Here are the best practices we used to keep database connections stable and resilient under heavy concurrent loads.

Architecture & Configuration

PgBouncer in Transaction Pooling Mode: Allows thousands of client connections to share a small pool of 50–100 actual PostgreSQL backend processes.
Pool Tuning in Node.js:

const { Pool } = require('pg');

const pool = new Pool({
  host: process.env.DB_HOST,
  port: 5432,
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  max: 20, // Max clients in local process pool
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

Circuit Breakers: Implementing graceful backoff and read-replica fallbacks when primary pool latency crosses established thresholds.

High-Availability Cloud Migration to GCP: Compute Engine & Cloud SQL

sagar03d@gmail.com — Wed, 12 Apr 2023 00:00:00 GMT

Migrating live production databases and microservices without downtime requires rigorous planning, shadow traffic testing, and multi-stage cutover procedures.

Here is the migration roadmap we used to transition from legacy VPS infrastructure to a managed, autoscaling Google Cloud Platform (GCP) environment.

The Strategy

Dual-Write / Replication Phase: We provisioned a Cloud SQL PostgreSQL instance configured as a read replica of the primary master. Continuous logical replication kept latency under 100ms.
Containerization & CI/CD: All Node.js and Laravel applications were packaged with multi-stage Docker builds and pushed to Google Artifact Registry. GitHub Actions automated automated test suites (>90% coverage) before staging deployments.
Traffic Splitting: Using NGINX and GCP Cloud Load Balancing, traffic was progressively shifted from 5% ➡️ 25% ➡️ 100% while observing telemetry.

Infrastructure as Code & Scalability

Using Terraform and Docker Compose, environments became completely reproducible across development, staging, and production environments.

Building Real-Time Faculty & Student Analytics Dashboards with WebSockets & React

sagar03d@gmail.com — Sat, 20 Aug 2022 00:00:00 GMT

Real-time visibility into student engagement, attendance, and session progression is vital for instructors and operations teams in EdTech.

In this article, I discuss designing real-time analytics dashboards in React.js powered by a WebSocket streaming layer and Redis Pub/Sub.

Front-End Architecture

On the client side, React components subscribe to granular channel topics rather than polling endpoints every few seconds.

import { useEffect, useState } from 'react';
import io from 'socket.io-client';

export function useLiveFacultyTelemetry(sessionId) {
  const [telemetry, setTelemetry] = useState(null);

  useEffect(() => {
    const socket = io('/telemetry', {
      auth: { token: localStorage.getItem('token') },
      query: { sessionId },
    });

    socket.on('stats:update', (data) => {
      setTelemetry((prev) => ({ ...prev, ...data }));
    });

    return () => socket.disconnect();
  }, [sessionId]);

  return telemetry;
}

Key Optimizations

Throttling State Updates: Batching incoming WebSocket payloads using requestAnimationFrame to prevent React render thrashing.
Heartbeat & Exponential Backoff: Automatic reconnection routines with state re-synchronization on network reconnects.

Dockerizing Microservices with NGINX Load Balancing for Zero-Downtime Deployments

sagar03d@gmail.com — Mon, 18 Apr 2022 00:00:00 GMT

Zero-downtime rolling updates ensure that user sessions are never severed during active code pushes or configuration changes.

In this guide, I share the multi-stage Docker configurations and NGINX upstream proxy architectures we deployed across our SaaS backends.

Multi-Stage Dockerfile for Node.js Services

# Stage 1: Build & Prune
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
RUN npm prune --production

# Stage 2: Minimal Production Image
FROM node:20-alpine
WORKDIR /app
USER node
COPY --from=builder --chown=node:node /app/dist ./dist
COPY --from=builder --chown=node:node /app/node_modules ./node_modules
COPY --from=builder --chown=node:node /app/package.json ./package.json

EXPOSE 3000
CMD ["node", "dist/main.js"]

NGINX Upstream Configuration

upstream node_cluster {
    least_conn;
    server 127.0.0.1:3001 max_fails=3 fail_timeout=10s;
    server 127.0.0.1:3002 max_fails=3 fail_timeout=10s;
    keepalive 32;
}

server {
    listen 80;
    server_name api.platform.com;

    location / {
        proxy_pass http://node_cluster;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Designing Scalable Multi-Tenant SaaS Backends Supporting 300K+ Users

sagar03d@gmail.com — Fri, 15 Jan 2021 00:00:00 GMT

When scaling a B2B SaaS platform, multi-tenancy enables a single application instance to serve multiple corporate customers while ensuring strict data separation and custom domain routing.

At Arobit Business Solutions, we built a multi-tenant backend architecture serving over 300K+ registered users and processing 50L+ INR monthly.

Tenant Resolution & Routing

We solved custom domain mapping through dynamic NGINX proxy headers passed into our Node.js and Laravel middleware:

Request: customer1.platform.com OR customdomain.com
                    │
                    ▼
          NGINX (Reverse Proxy)
     Sets Host & X-Tenant-Domain
                    │
                    ▼
          Tenant Resolution Middleware
   (Lookup Tenant by Hostname in Redis Cache)
                    │
                    ▼
     Scoped Database Schema / Row Context

Payment Processing Integration

Handling global and domestic billing across tenants required integrating both Stripe and Razorpay with automated webhook verification, recurring subscription state machines, and idempotent charge processing.