Full-Stack Web Development

Detailed Technical Deep Dive: Full-Stack Web Development

Summary: This document outlines Jishnu Mahanta's architectural approach to constructing high-performance React applications, securing web form endpoints, and styling fluid, interactive animations.

1. Next.js App Router & Server Components (RSC)

Traditional React applications rely on Client-Side Rendering (CSR), downloading massive JavaScript bundles that delay initial page load and complicate search engine indexing. By implementing Next.js App Router and Server Components (RSC), page layouts are compiled to static HTML on the server, ensuring sub-second load times and optimal SEO.

To keep telemetry and public project detail routes fast, I configure dynamic static paths. Below is the Next.js pattern I implement inside detail routes to ensure static generation while maintaining dynamic update caches:

import { notFound } from "next/navigation";
import { getProject, getProjectSlugs } from "@/lib/db/projects";

// Configure Incremental Static Regeneration (ISR) revalidation cycle
export const revalidate = 3600; // Revalidate static page cache every 1 hour

// Generate static parameters for all existing database rows at build time
export async function generateStaticParams() {
  const slugs = await getProjectSlugs();
  return slugs.map((slug) => ({ slug }));
}

export default async function ProjectDetailPage({
  params,
}: {
  params: Promise<{ slug: string }>;
}) {
  const { slug } = await params;
  const project = await getProject(slug);
  
  if (!project) {
    notFound();
  }
  
  return (
    <article className="pt-28">
      <h1>{project.name}</h1>
      <p>{project.tagline}</p>
    </article>
  );
}

2. Endpoint Hardening & Bot Protection

Web contact forms are major vectors for automated spam. I secure API endpoints without degrades user experience (avoiding annoying CAPTCHAs) by deploying Zod verification schemas, Token Bucket rate limiters, and invisible honeypot fields.

The Hardened API Validation Workflow:

• Zod Schema Verification: Parse inputs against schemas.
• Honeypot Trap: Add a field styled as hidden. If a bot fills it, abort immediately.
• Token Bucket Rate Limiting: Log visitor IP hashes in memory or a database to prevent DDoS attacks.

import { NextResponse } from "next/server";
import { z } from "zod";

// Declare schema boundaries
const contactSchema = z.object({
  name: z.string().min(2).max(100),
  email: z.string().email(),
  message: z.string().min(10).max(5000),
  website: z.string().max(100).optional(), // Honeypot field
});

export async function POST(req: Request) {
  try {
    const json = await req.json();
    const payload = contactSchema.parse(json);
    
    // Honeypot check: If the hidden 'website' field is populated, a bot filled it
    if (payload.website && payload.website.trim().length > 0) {
      return NextResponse.json({ success: true }, { status: 200 }); // Silent drop
    }
    
    // Process verified data (e.g. send email via Resend API)
    return NextResponse.json({ success: true });
  } catch (err) {
    return NextResponse.json({ error: "Invalid parameters" }, { status: 400 });
  }
}

3. GSAP Scroll Sequencers & Lenis Synchronization

To build luxury digital storytelling experiences (like Anyak tea estate showcase), I sequence complex CSS animations using GreenSock (GSAP) and synchronize momentum scrolling with Lenis:

• Lenis Smooth Scroll: Eliminates browser scroll jumps and ensures animations match the user's touchpad velocity.
• GSAP ScrollTrigger: Binds CSS transforms, scales, and clip-paths directly to the viewport scroll position.
• Performance Budget: Animates exclusively GPU-accelerated CSS properties (transform: translate3d/scale, opacity) to maintain 60FPS fluid motion on mobile screens.