Expert Talks Chennai

LLM Post-Training & The AI-Ready React + Postgres Stack

Sat, May 30 · 10:30 IST

Holiday Inn Chennai OMR IT Expressway, an IHG Hotel, 110 Rajiv Gandhi Salai, Old, Mahabalipuram Rd, PTK nagar, Thiruvanmiyur, Ch, Chennai, IN

Hi Everyone,
We’re back with the fourth edition of Expert Talks for the year.
Please join us on 30th May 2026, from 10:30 AM to 1:00 PM @ Holiday Inn OMR IT Expressway - Wodeyar Meeting Room.

Agenda :
1. Welcome & Intros (10 mins)
2. Talk 1: Post-Training LLMs for Targeted Capabilities
3. Tea Break (15 mins)
4. Talk 2: React + Postgres - The AI-Ready Stack You Already Know
5. Networking

Talk 1: Post-Training LLMs for Targeted Capabilities
by Harisaran G

Large language models (LLMs) are increasingly deployed as specialists: models that can reliably solve a narrowly defined task better than a general-purpose base model. Yet “fine-tuning” is no longer a single technique—it is a family of post-training paradigms with different assumptions about data availability, feedback signals and stability. This talk presents a structured, task-driven comparison of modern post-training algorithms—ranging from classic Supervised Fine-Tuning (SFT) to reinforcement learning variants, evolutionary learning, and a new wave of self-distillation methods
To make the comparison concrete and decision-relevant, we organize experiments around a three-rung task ladder that increases in supervision complexity and operational realism:

1. Countdown (simple, verifiable): a compact reasoning puzzle with unambiguous correctness. This setting highlights sample-efficiency and optimization stability when rewards are sparse but reliable.
2. SQL query writing (medium, executable): translating natural language to SQL with execution-based correctness. This introduces structured constraints, multiple valid solutions, and evaluation via database execution (e.g., exact match and execution accuracy).
3. Agentic failure resolution for Ops/CS (complex, rich feedback): an agent loop that diagnoses and resolves issues using tool traces, error logs, and remediation actions. This domain is characterized by delayed rewards, non-stationary edge cases, and “textual critiques” (what failed and why) that are often more informative than a single scalar score.

Across these tasks, we compare six training paradigms under matched budgets and consistent evaluation:

• Supervised Fine-Tuning (SFT) as the baseline for learning from demonstrations.
• Reinforcement Learning (RL) (verifiable rewards) as the standard approach when a reward signal exists.
• Evolution Learning (ES) as a derivative-free alternative that can be more tolerant of delayed rewards and training instabilities.
• On-policy distillation as a bridge between demonstrations and on-policy learning.
• Self-Distillation Policy Optimization (SDPO) for settings where environments provide rich textual feedback (e.g., runtime errors, judge critiques, tool traces), enabling dense credit assignment without an external teacher.
• Self-Distillation Fine-Tuning (SDFT) for continual learning, where the goal is to acquire new skills while minimizing catastrophic forgetting.

The core of the talk is not a practical, apples-to-apples framework for answering: Which post-training method should I use for my task, and why? We examine trade-offs along these four axes that practitioners routinely encounter but rarely benchmark systematically:

1. data requirements (demonstrations vs. rewards vs. feedback)
2. stability and reproducibility
3. sensitivity to reward hacking
4. retention vs. forgetting when tasks evolve over time.

The talk concludes with a set of actionable takeaways: a “method selection map” that links task properties (verifiability, richness of feedback, horizon length, and drift) to the most reliable training recipe; practical evaluation metrics like accuracy, pass@k and other metrics and a blueprint for building specialist models that remain robust as tasks move from toy benchmarks (Countdown) to production workflows (Ops/CS failure resolution).

Talk 2: React + Postgres - The AI-Ready Stack You Already Know
by Dani Akash

Modern web apps that deal with AI workloads tend to accumulate services like a junk drawer accumulates batteries. A queue here, a vector database there, a separate auth service, a realtime layer, a search engine... before you know it, you're managing a small country of infrastructure just to ship a feature.
But here's the thing: PostgreSQL has quietly become one of the most capable platforms on the planet. And paired with React Server Components, it unlocks a surprisingly simple way to build apps that would normally require a whole fleet of specialized tools.
In this talk, we'll compare a data-intensive AI application side-by-side built in three different ways:

• Traditional monolith
• Microservices
• The Postgres + React Server Components approach

and compare the results. Spoiler: one of them involves a lot less YAML.

Outline

• Auth without a service: Using Postgres Row Level Security to handle authentication and authorization at the database level
• Vector search without a vector database: Storing and querying AI embeddings with pgvector, right alongside your application data
• Realtime data directly in the DB: Using Postgres LISTEN/NOTIFY as an event source for live updates
• Background jobs simplified: Managing data queues with Postgres-native job runners like graphile-worker and pg-boss
• RAG without the complexity: Leveraging Postgres full-text search for AI data retrieval
• APIs without writing code: Exposing your data layer via pg_graphql or PostgREST
• Less client-side complexity: Using React Server Components to fetch data directly from Postgres on the server, cutting down on client-side state management

Key Takeaways

• PostgreSQL can handle far more of your application's needs than you might think — from vectors to queues to realtime events
• React Server Components fundamentally change how we think about data fetching, making direct database access on the server a first-class pattern
• For small teams and solo developers especially, this approach dramatically reduces operational complexity without sacrificing capability
• You don't always need the "best tool for every job" — sometimes the best tool is the one that does ten jobs well enough and saves you from gluing ten services together

This talk is for anyone who's ever looked at their architecture and thought "there has to be a simpler way." There is. You probably already have it installed.

About the Speakers

Harisaran G is a Search and ML Engineer at Typesense, building search, recommendation, and retrieval systems that power fast, relevant, and intelligent discovery experiences.
Previously at MotorQ, he worked on buildling real-time and batch analytics systems.

Dani Akash is a Founding Engineer at BrowserOS (YC S24), where he's architecting the agentic layer of an open-source AI browser built for autonomous workflows. With a decade of experience shipping production software — from React Native at Pickyourtrail to Chrome extensions at OSlash and developer tooling at Clarifai — he's been at the front lines of how engineers actually build with AI. He speaks regularly at conferences and meetups on agentic systems, the future of browsers, and what it takes to ship AI products that real users trust.