DEV Community: Agastya Khati

Credexia: AI-Powered Loan Compliance Built with Google Gemini

Agastya Khati — Wed, 04 Mar 2026 04:05:01 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

Building Credexia: How Gemini Became My 48-Hour Co-Founder

The Event

I built Credexia at the LMA Edge Hackathon, where the theme was loan market innovation. The challenge was to modernize how banks handle loan servicing after the trade is signed. While trading platforms have gone digital, post-closing operations are still stuck in Excel hell. I had 48 hours to change that.

The LMA ecosystem has tools for drafting loans and platforms for price discovery, but there is a massive white space in between. Banks can agree on trades and sign loans digitally, yet post-closing servicing and settlement remain fragmented. Excel sheets, endless email chains, manual data re-entry, broken reconciliation. Liquidity is not blocked by lack of capital. It is blocked by operational friction.

My goal was to build the Operating System for Loans. A unified platform connecting covenant monitoring, trade settlement, and cash distribution in real time.

What I Built

Credexia is a unified desktop platform covering three critical loan lifecycle stages in one dashboard. It is built on Next.js 16 with React 19, TypeScript 5.8, and styled with Tailwind CSS 4, MUI 7, and Framer Motion for animations.

Demo Video

See Credexia in action:

https://youtu.be/3GrR22gW9SU?si=aFDLldcB2vOJYxK8

Live Website

Try the platform:

https://credexia.vercel.app/

GitHub Repository

View the code:

kris70lesgo / Credexia

Credexia

A Next.js + Supabase + Ethers-powered platform for blockchain-verified loan covenant monitoring, OCR-driven data extraction, and portfolio analytics.

Features

AI-assisted chat for covenant guidance (Gemini)
OCR-backed document intake with fallback parsing
Covenant calculations (Debt/EBITDA, ICR, current ratio)
Polygon Amoy sealing for compliance events
Dashboard for loans, uploads, reports, and trade utilities

Stack

Next.js 16, TypeScript, Tailwind
Supabase (auth, DB, storage)
Ethers.js for Polygon interactions
Google Gemini for AI responses and parsing

Prerequisites

Node 18+ and npm
Supabase project with SUPABASE_URL and service key
Polygon Amoy RPC endpoint and funded deployer key
Gemini API key for AI features

Setup

Install deps: npm install
Copy .env.local.example to .env.local (if present) and set:

SUPABASE_URL=
SUPABASE_SERVICE_ROLE_KEY=
SUPABASE_ANON_KEY=
GEMINI_API_KEY=
POLYGON_RPC_URL=
BLOCKCHAIN_PRIVATE_KEY=
API_KEY=                  # optional API auth
ALLOWED_ORIGINS=*         # comma-separated list in prod

Run dev server: npm run dev
Optional: compile contracts: npx hardhat compile

Scripts

npm run dev – start Next.js dev server
npm…

View on GitHub

Monitoring

Tracks financial covenants like Debt/EBITDA and ESG covenants like Carbon Emissions. Users upload a PDF financial report. AI extracts values and calculates compliance. A traffic light system shows status: Green for Safe, Amber for Warning, Red for Breach. If an ESG covenant is breached, the interest rate automatically adjusts according to loan terms.

TradeClear

Digitizes the transfer of loan ownership. Users upload a Notice of Assignment PDF. AI extracts Seller, Buyer, and Trade Amount. After approval, the Ownership Register updates instantly. This removes manual ledger updates entirely.

AgentFlow

Automates the Payment Waterfall. It distributes borrower payments across lender banks, enforces zero rounding error, assigns any remainder to the Agent Bank, and generates SWIFT-ready CSV in seconds.

Global State

All three modules share a Global State. If ownership changes in TradeClear, AgentFlow instantly reflects the new owner without a page reload. This is managed through an in-memory global singleton with hot-reload safety, though this would need Redis or a database for true production multi-instance deployment.

How Gemini Powered Everything

I used Gemini at every layer of the stack. Not as a helper. As a co-builder. The AI layer centers on Google Gemini 2.5 Flash with a 4-tier fallback system: Gemini 2.5 Flash, Gemini 2.5 Pro, Gemini 1.5 Flash, and Gemini 1.5 Pro. OCR.space serves as a raw text backup when needed. A confidence gate at 60% ensures that if AI confidence drops below this threshold, the user must confirm before proceeding.

Document Understanding

The core feature is PDF ingestion. A credit analyst uploads Q4 financials. Gemini extracts the numbers, calculates ratios, and flags breaches. The extraction targets totalDebt and ebitda fields with confidence scoring. When confidence is low or parsing fails, an OCR fallback path activates.

The first extraction test I ran returned a Debt/EBITDA ratio of 47x. The real number was 4.7x. Gemini had misread a table cell. That single failure taught me why finance demands confidence gates and deterministic logic. I rebuilt the extraction layer with strict validation and the 60% confidence threshold.

Code Generation

I wrote maybe 40% of the React components myself. The rest came from Gemini prompts. The traffic light dashboard, the upload flow, the audit log interface. I would describe what I needed, iterate twice, and have production-ready code. The marketing landing page with animated hero, the login authentication flow, the portfolio dashboard with analytics cards, the loan tables, the document intake with OCR processing, the compliance reporting, the trade workflow UI, and the AI agent orchestration view all benefited from Gemini-generated code.

Blockchain Integration

I used Gemini to write the Solidity contracts for Polygon Amoy testnet. The CovenantRegistry.sol contract handles SHA-256 covenant sealing. Each compliance event gets a txHash for immutable audit trails. When I hit the "private key fiasco" at 3 AM, where my .env key had an extra character, Ethereum keys must be exactly 64 hex characters, Gemini debugged the error message with me. I also implemented a demo mode using FNV-1a hash simulation when the network fails, ensuring the demo never crashes regardless of API failure.

Trade Clearing Architecture

The trade module has 7 sub-routes forming a complete lifecycle: upload, parse, validate, owners, approve, confirm, and events. This supports partial ownership transfers between banks. The in-memory trade state singleton prevents loss during Next.js hot reload, though production would need a persistent store.

Payment Waterfall Precision

The waterfall distributes cash to syndicate members by ownership share. Floating-point remainder always assigns to Agent Bank to ensure exact totals. This handles fractional splits and guarantees perfect totals, solving the zero-variance requirement that took six hours to perfect. Not because the math is hard. Because financial systems demand perfection.

AI Chat Assistant

I built a covenant guidance chatbot powered by Gemini. It answers questions about loan covenants, risk analysis, debt-to-EBITDA calculations, document uploads, OCR extraction, blockchain verification, and portfolio insights.

The Pitch Deck

Yes, I even used Nano Banana, Gemini's image generation, for the pitch deck visuals. The LMA judges saw AI-generated diagrams explaining AI-powered compliance. Meta, but effective. Gemini helped structure the narrative and create visuals that made institutional infrastructure feel tangible.

Credexia_ Reinventing Trust, Transparency, and Automation in Loan Markets.pptx - Google Slides

docs.google.com

Technical Architecture

The frontend runs on Next.js 16 App Router with 18 API routes covering loans, chat, OCR, parsing, extraction, covenant calculations, blockchain sealing, compliance events, portfolio data, uploads, waterfalls, and the full trade lifecycle.

All business logic is implemented as pure functions with deterministic outputs. The covenant engine in particular has no side effects, calculating Debt/EBITDA ratios, Interest Coverage Ratios, and Current Ratios with strict mathematical precision.

Database and authentication use Supabase with Postgres and Storage. The blockchain layer uses Ethers.js 6 with Hardhat 3 for smart contract development. Smart contracts are written in Solidity and deployed to Polygon Amoy testnet.

What I Learned

AI Needs Guardrails

My first extraction failure taught me that finance cannot tolerate hallucination. The 47x versus 4.7x error led to the confidence gate system and deterministic validation layers. Every AI output gets verified before it touches a financial calculation.

Model Names Are Chaos

I spent two hours debugging 404 errors before realizing "gemini-2.5-flash" and "gemini-2.5-flash-preview" are different endpoints. The 4-tier fallback system was born from necessity, not planning. Incorrect model names caused API failures that required the retry logic I implemented.

Simulation Beats Broken Reality

OCR on messy financial tables failed constantly. Rather than fight it, I built demo-friendly PDFs with clean formatting and a manual override. The demo worked. The architecture was real. Resilient architecture means the app never crashes during demo regardless of API failure.

The Last Mile Is Process, Not Math

Getting the payment waterfall to sum to exactly 100% with no rounding errors took six hours. Not because the math is hard. Because financial systems require perfection. The operational friction in fintech is not about complex calculations. It is about ensuring those calculations are auditable, deterministic, and zero-error.

Schema Drift Happens Fast

Frontend expected fields that did not exist in Supabase. I adapted the frontend to the database rather than migrating the database mid-hackathon. This pragmatic approach preserved velocity when time was critical.

What Worked and What Didn't

What Worked

Speed. I prototyped a full-stack fintech platform in 48 hours because Gemini accelerated every decision. Multi-modal document understanding. The ability to throw a PDF at an API and get structured JSON back feels like magic when it works. The traffic light UI gave instant risk visibility across the portfolio. Honest error handling meant no silent failures. Users see real confidence and validation errors.

The Friction

Inconsistency. Same prompt, different results across model versions. Structured output sometimes ignored my schema. Financial tables in PDFs remain a hard problem. I needed OCR.space as a backup for messy scans. The messy financial tables broke OCR repeatedly, requiring the demo-friendly PDF approach.

What I Needed

Better documentation on model capabilities. Clearer error messages when context windows overflow. Native support for financial table extraction without custom preprocessing. More predictable structured output formatting for financial data.

Who This Is For

Credexia serves Credit Risk Analysts, Loan Agency Teams, Syndicated Loan Traders, Treasury Operations, ESG Compliance Teams, and Audit & Regulatory Teams. Eventually it will serve rating agencies, regulators, and institutional investors. This is not consumer SaaS. This is institutional infrastructure.

Business Model

Monetization can happen through per-loan subscription, per-document processing fees, per-settlement fees, compliance enterprise licenses, ESG pricing modules, and audit trail services.

What's Next

Credexia is not a hackathon toy. It is institutional infrastructure. I am adding real-time ESG covenant monitoring, expanding to trade settlement workflows, and building out the audit trail for regulatory compliance.

Gemini got me from idea to working demo in 48 hours. The next 48 days are about making it production-grade. The architecture is real. The global state works. The blockchain sealing provides immutable audit trails. The payment waterfall guarantees zero variance. The AI extraction learns from every validation.

The foundation is built. Now it is time to scale.

Built with Next.js, Supabase, Polygon, and Google Gemini.

Bridgy: Helping Overwhelmed Communities Choose the Right Tool, Not Another Tool

Agastya Khati — Mon, 02 Mar 2026 04:32:18 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

A few months ago, a friend reached out to him late at night.

“Do you know any tool that can actually help with this? I’ve been searching for an hour and now I’m more overwhelmed than when I started.”

The friend was a college student. Smart, capable, constantly juggling assignments, exams, and expectations.

He also had ADHD.

The problem wasn’t a lack of tools it was the opposite.

Productivity apps. ADHD planners. Focus tools. Study systems. Recommendation threads. Endless “best apps” lists.

Each search added another decision.

Each decision increased the cognitive load.

By the time the search ended, nothing had been chosen and the overwhelm had only grown.

The person reading that message understood immediately.

He is part of the same overlapping communities:

a college student
a developer
someone living with ADHD

In these communities, the hardest part is often not execution it’s starting.

And starting means choosing. Choosing means evaluating options. And evaluating options is exhausting when your brain is already overloaded.

What actually helped wasn’t finding another tool.

What helped was when someone narrowed the field and said:

“Based on what you’re dealing with right now, start here.”

Bridgy is built for that moment.

What I Built

Bridgy is a transparent, rule based resource matching web app designed to reduce decision paralysis not add to it.

Instead of asking users to browse endlessly, Bridgy:

Accepts natural language input or a simple 3 question guided flow
Interprets context (community, problem, urgency)
Matches users to 2–3 curated resources
Explains why each resource was selected
Suggests one concrete next action

There are:

no black-box recommendations
no scraping
no tracking
no stored personal data

Every recommendation is deterministic and explainable.

AI is used only to understand language and rewrite explanations empathetically never to decide what resources are shown.

Demo

Video Demo

Code

GitHub Repository

kris70lesgo / bridgy

Bridgy

Transparent, rule-based resource matching for neurodivergent minds.

Bridgy helps people with ADHD, autism, dyslexia, anxiety, depression, and related conditions find the right tools and support — without black-box algorithms, data collection, or tracking. Every recommendation is deterministic and explainable.

Overview

Bridgy is a static-first, privacy-first web app. Users describe what they need — either by answering a short guided questionnaire or typing freely — and Bridgy matches them to a curated set of 32+ resources using a fully transparent, deterministic scoring engine.

There is no backend database, no user accounts, no analytics, and no data sent to third parties beyond an optional LLM call to parse free-text input. The entire matching logic lives in client-side code that anyone can read.

…

View on GitHub

The full codebase is open and readable.

All matching logic, scoring rules, and data models live in the repository.

How I Built It

Architecture Philosophy

Bridgy is intentionally:

Static-first
Privacy-first
Explainable by design

There is:

no backend database
no user accounts
no analytics
no stored user data

The app works fully even without an API key.

Tech Stack

Layer	Technology
Framework	Next.js 16 (App Router)
Language	TypeScript (strict)
UI	React 19
Styling	Tailwind CSS v4
Icons	Lucide React
LLM Gateway	OpenRouter (GLM-4.5 → Gemini 2.0 Flash fallback)
Deployment	Vercel

How Bridgy Works

User Input
- Guided mode (community → problem → urgency)
- OR free-text natural language
Intent Parsing
- Free text is parsed into structured intent using GLM-4.5
- Falls back to Gemini 2.0 Flash
- If no API key exists, a keyword-based local parser runs instead
Deterministic Scoring
- Community match: +3
- Problem match: +3
- Urgency match: +1
- Human support (when requested): +2

Same input always produces the same ranked output.

Transparent Results
- 2–3 matched resources
- “Why this?” explanations
- One clear next action

Why These Decisions Matter

Bridgy deliberately avoids:

web scraping
live search
user tracking
black-box AI recommendations

For people who are already overwhelmed, trust and clarity matter more than clever automation.

Every design decision was made to reduce cognitive load not increase it.

Closing

Technology has done a great job building tools for communities.

It has done a much worse job helping people navigate between them.

Bridgy is a small attempt to bridge that gap not by adding more options, but by helping someone take one clear step forward when everything feels like too much.

Sometimes, that’s enough to change the direction of a day.

Copilot Sherlock : Governed Incident Investigation CLI

Agastya Khati — Sun, 15 Feb 2026 16:14:19 +0000

This is a submission for the GitHub Copilot CLI Challenge

Copilot Sherlock — Governed Incident Investigation CLI

AI proposes. Humans decide. The system verifies.

What I Built

I built Sherlock, a CLI-based incident investigation system that demonstrates how to use GitHub Copilot CLI inside a real production-style workflow, not just as a code generator or chat assistant.

Sherlock turns raw production evidence (logs, metrics, deployments) into a governed, auditable incident decision with a strict lifecycle:

AI performs bounded reasoning
Humans explicitly decide (ACCEPT / MODIFY / REJECT)
The system enforces authority and lifecycle rules
Outcomes are recorded as append-only organizational memory
All artifacts are cryptographically verifiable

AI never decides. Humans always decide.

This is not an AI demo.
It’s an incident lifecycle system with AI inside it.

The 90-Second Pitch

Most incident tools do one of two things:

Give you AI suggestions with no governance
Give you checklists with no intelligence

Sherlock separates intelligence from authority:

AI proposes multiple competing hypotheses with evidence and confidence
Humans approve or reject the outcome
The system enforces lifecycle gates, memory isolation, and execution rules
Every decision is immutable and externally verifiable

There are no feedback loops, no auto-approval, and no adaptive behavior.

This is what production-grade AI assistance looks like.

Demo

Video Walkthrough (Full End-to-End Run)

GitHub Repository

https://github.com/kris70lesgo/sherlock-demo

One-Command Demo

./run-demo.sh

This executes the entire incident lifecycle:

Evidence normalization and trust validation
Scope reduction (thousands of log lines → a few signals)
AI hypothesis reasoning using GitHub Copilot CLI
Mandatory human governance (ACCEPT / MODIFY / REJECT)
Organizational memory write (append only, read only)
Operational integration (Slack / JIRA simulation)
Cryptographic provenance and trust report generation

Fresh Incident IDs

To avoid append-only memory conflicts, you can run:

./sherlock investigate INC-999

Copilot Auth vs Offline Mode

Sherlock uses GitHub Copilot CLI for Phase 3 reasoning when authenticated.

If Copilot is not authenticated, Sherlock falls back to an offline post-mortem generator so the demo still completes.

To authenticate Copilot:

gh auth login

My Experience with GitHub Copilot CLI

Copilot CLI was used as a reasoning engine, not as an authority.

Specifically:

Copilot generates multi-hypothesis RCAs from scoped evidence
Each hypothesis includes:
- Evidence FOR
- Evidence AGAINST
- Confidence contribution
Confidence is budgeted and uncertainty is explicit
Hypotheses can be ruled out with justification

Crucially:

Copilot cannot finalize anything
It cannot approve itself
It cannot modify governance rules
Its output is preserved even when rejected

The most valuable aspect of Copilot CLI here wasn’t speed it was structured reasoning under constraints.
Once those constraints were clear, Copilot became a reliable component in a larger system instead of a black box.

Why This Matters

Sherlock demonstrates:

How to use Copilot CLI inside a production workflow
How to prevent AI feedback loops
How to enforce human authority mechanically
How to make AI output externally verifiable
How to integrate AI without letting it run the system

Most tools ask you to trust them.

Sherlock gives you a way to verify them.

That’s the difference between a demo and a product.

Final Notes

Language: Bash + Python
Interface: CLI (interactive and non-interactive modes)
Architecture: 7 phase, strictly isolated pipeline
Status: Frozen, validated, demo ready

Thanks for checking it out.

[Boost]

Agastya Khati — Sun, 01 Feb 2026 03:49:52 +0000

3D-First Portfolio Built with Antigravity

Paimon ・ Jan 31

#devchallenge #googleaichallenge #portfolio #gemini

Building a Portfolio with Gemini - New Year, New You Portfolio Challenge

Agastya Khati — Sat, 31 Jan 2026 13:50:57 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

This project started with a simple question:

What happens when you stop treating AI as a tool that writes code, and start treating it as a creative and technical collaborator?
I wanted to explore how far modern Google AI tools specifically Gemini 3 and Antigravity could take an idea when used for thinking, designing, iterating, and refining, not just generating snippets.

This portfolio is the result of that exploration.

It’s not meant to be flashy for the sake of it. It’s meant to show how clarity, motion, and structure can emerge naturally when ideas are shaped collaboratively with AI from the very first layout decision to the final animation timing.

Portfolio

Video Walkthrough

To better showcase the motion, flow, and animation details, here’s a short walkthrough of the portfolio.

This video highlights:

The hero intro animation
Scroll-based reveals and transitions
Micro-interactions and motion pacing
Overall visual flow and structure

Note on presentation

While the portfolio is fully deployed on Google Cloud Run, embedding it directly inside a DEV post limits viewport size and affects animation timing.

To preserve the intended experience, a short video walkthrough is included below, along with a direct link to view the portfolio in a full browser window.

Live Portfolio:

https://port-709587781727.us-central1.run.app/

--labels dev-tutorial=devnewyear2026

How I Built It

This portfolio was built through an AI-assisted vibe-coding workflow powered by Gemini 3 and Google Antigravity.

Rather than starting with rigid wireframes or a fixed specification, the process focused on momentum — letting ideas evolve quickly while keeping the system coherent.

Gemini 3 as a Creative and Technical Partner

Gemini 3 was used throughout development as a reasoning and design partner.

Instead of asking it to “write code,” I used Gemini to:

Explore multiple animation approaches before choosing one
Reason about motion pacing and visual hierarchy
Design section flow and narrative structure
Stress-test interaction ideas conceptually
Refine micro-interactions and transitions

Gemini helped answer questions like:

How long should an intro animation last before it feels slow?
How do you guide attention without overwhelming the user?
Where should motion stop so content can breathe?

This kind of feedback loop made it possible to move fast without losing intention.

Hero Intro Animation

One of the clearest examples of Gemini’s impact is the hero intro animation.

Instead of dropping the user into a static page, the portfolio opens with a carefully paced sequence:

The hero content begins subtly scaled down and centered
It fades in and scales up smoothly
The layout then transitions into its natural position
Supporting elements appear in a controlled, staggered flow

This animation was iterated multiple times using Gemini to evaluate:

Timing curves
Ease functions
Entry order
Emotional impact vs. speed

The result is an intro that feels cinematic but restrained designed to set tone, not steal attention.

Antigravity as the Execution Engine

While Gemini helped shape ideas, Antigravity made execution fluid.
Antigravity allowed rapid iteration across:

Component structure
Animation tuning
Layout refinements
Refactors without breaking flow

Instead of working file by file, Antigravity made it possible to think system-wide adjusting animation logic, layout, and styling together while maintaining consistency.

This kept the creative momentum high without sacrificing technical cleanliness.

Tech Stack

Next.js (App Router)
React
TypeScript
Tailwind CSS
GSAP for complex timeline animations
Framer Motion for scroll-based reveals and micro-interactions
Radix UI / shadcn for accessible primitives
Deployed on Google Cloud Run

What I’m Most Proud Of

The Flow

Nothing in this portfolio is abrupt.
Sections don’t “appear.”

They arrive.
Animations guide the eye instead of competing for attention, creating a calm, readable experience that still feels alive.

Animation Discipline

Motion is used sparingly and purposefully:

GSAP handles moments that require precision and choreography
Framer Motion handles moments that should feel natural and responsive
CSS handles everything that doesn’t need JavaScript

This balance keeps performance high and interactions smooth.

AI as an Enabler, Not a Gimmick

There’s no visible chatbot.

No AI button.
Yet AI is present in every decision.
Gemini and Antigravity didn’t replace creativity they amplified it. They made it possible to explore more ideas, discard weaker ones faster, and refine the strongest concepts with confidence.

Closing Thought

This project isn’t about a portfolio.
It’s about possibility.
It’s about what happens when developers stop asking AI to do the work and start asking it to think with them.
Gemini 3 and Antigravity didn’t just help build this site they shaped how it came to life.
And that’s the most exciting part.

[Boost]

Agastya Khati — Fri, 30 Jan 2026 05:47:37 +0000

A macOS-Inspired Operating System Portfolio Built using Antigravity

Shobhit Kapoor ・ Jan 30

#devchallenge #googleaichallenge #portfolio #gemini

From RFQ Emails to Winning Proposals: Building Tendr

Agastya Khati — Sun, 14 Dec 2025 17:11:09 +0000

This is a submission for the Xano AI-Powered Backend Challenge: **Full-Stack, AI-First Application**

What I Built

I built Tendr, an AI-powered proposal management system for contractors designed around a clean, scalable backend architecture.

Contractors typically receive RFQs (Requests for Quote) as unstructured emails. They then manually extract requirements, estimate pricing, draft proposals, track revisions, and monitor outcomes. This process is slow, inconsistent, and extremely difficult to scale or audit.

Tendr solves this problem by combining AI-driven automation with a production-grade backend built on Xano.

Instead of treating AI as a black box, Tendr focuses on structuring the entire workflow from RFQ ingestion to proposal delivery with clear data models, secure APIs, and auditable lifecycle tracking.

The application allows users to:

Securely authenticate and manage B2B-style accounts
Parse RFQ emails using AI to extract structured project data
Track RFQs through a defined pipeline (Received → Parsed → Pricing → Drafted → Sent → Won / Lost)
Generate and manage proposals with centralized pricing rules
View timelines, analytics, and historical activity backed by a normalized database

The frontend is intentionally lightweight.

The core goal of this project is to demonstrate how Xano can be used to turn AI-generated backend logic into a scalable, maintainable system, not just a prototype.

Demo

Live Application:

https://tendr-ashen.vercel.app/

Source Code:

https://github.com/kris70lesgo/Tendr

Demo Video:

AI-Assisted Backend Generation

I started by using Xano’s AI and database assistants to generate an initial backend scaffold.

Example prompt:

“Design a scalable backend for a contractor proposal management system with authentication, RFQ ingestion, AI email parsing, proposal generation, pricing rules, timelines, and analytics. Normalize the database and expose secure APIs.”

This produced:

An initial database schema
CRUD APIs for RFQs, proposals, pricing rules, and timeline events
Basic function stacks for request handling

While this AI-generated backend was functional, it was not production-ready.

The schema needed normalization, the APIs lacked ownership enforcement, and the logic was too linear to scale.

This is where human refinement became critical.

How I Refined the AI-Generated Backend in Xano

1️⃣ Database Design & Normalization

Before (AI-generated):

Overloaded tables
Weak separation between RFQs, proposals, and historical events
Limited support for analytics and auditing

After (Human-refined):

Clear, normalized tables:
- rfq
- proposal
- pricing_rule
- timeline_event
- event_log
- account and user
Explicit relationships between users, accounts, RFQs, and proposals
Timeline and event logging to track every state transition

This design makes it easy to add analytics, reporting, and future automation without rewriting core logic.

2️⃣ API Structure & Security

Before:

Generic CRUD endpoints
Minimal authorization logic

After:

Token-based authentication using Xano’s auth system
Ownership checks on all user-scoped endpoints
Clear API group separation:
- Authentication
- Members & Accounts
- RFQs
- Proposals
- Pricing Rules
- Timeline Events
- Event Logs

Each API group has a single responsibility, making the backend easier to reason about and safer to expose to a frontend.

3️⃣ Logic Refactoring & Maintainability

Before:

Long, linear function stacks
Repeated validation and persistence logic

After:

Modular, reusable function stacks
Clear separation of concerns:
- Input validation
- Data persistence
- AI processing
- Response formatting

This refactor significantly improved readability and made future changes safer.

4️⃣ Production Signals Added

To move beyond a prototype, the backend includes:

Secure authentication and role-aware accounts
Centralized pricing rules editable without frontend changes
Timeline events for every RFQ and proposal state change
Event logs for observability and debugging
Input validation and structured error handling

These features turn AI-powered workflows into reliable backend infrastructure.

My Experience with Xano

Xano’s biggest strength is that it allows AI to accelerate backend development without removing architectural control.

What stood out most:

Database Assistant for rapid schema iteration
Visual API and function stacks for complex workflows
Built-in authentication and account management
Clean integration with a Next.js frontend

Instead of fighting generated code, I could refine and harden it into a maintainable backend exactly what this challenge is about.

Final Thoughts

Tendr demonstrates how:

AI jumpstarts backend development
Human judgment makes it production-ready
Xano provides the tooling to bridge that gap cleanly

The focus of this project is not just AI output, but structure, scalability, and long-term maintainability and Xano excels at enabling that.

MedHack - your health companion

Agastya Khati — Sat, 25 Oct 2025 08:24:31 +0000

This is a submission for the Auth0 for AI Agents Challenge

What I Built

MedHack is an AI-powered health assistance platform designed to make basic medical guidance and personalized nutrition planning accessible to everyone—especially in environments where professional healthcare is difficult to reach, expensive, or confusing to navigate.

The application has two core AI agents:

MedScan Diagnostic Agent
This agent analyzes medical images such as X-rays, CT scans, MRIs, and even photos of skin rashes or visible injuries. It helps users understand what might be happening in their body before they reach a doctor.
It does not replace medical professionals—it simply provides early clarity, reduces anxiety, and helps users ask better questions when they do seek treatment.

Diet Planner Agent
Instead of generating generic diet charts, this agent works interactively.
It asks about age, activity, preferences, medical conditions, routine, and even budget.
Then it produces a personalized weekly meal plan with calorie targets, macronutrient breakdowns, grocery list, and ongoing chat-based adjustments.
The structured plan can then be downloaded as a PDF or emailed directly to the user.

Demo

Live Demo: https://med-hack.vercel.app/
Github Repo : https://github.com/kris70lesgo/Medhack

Watch the video for the live demonstration of medhack

Quick Overview

1) Landing Page / Home Section
AI-powered personal health assistant combining diagnosis + nutrition planning

2) MedScan
User uploads an X-ray, skin image, or medical report for analysis.

3) Diet Planner
User provides age, weight, dietary preferences, medical conditions, and goals.

Smart Dialogue Screen
Agent asks clarifying questions to tailor the plan precisely.

7-Day Diet Plan Preview
A complete, structured 7-day meal plan is generated instantly

PDF Download
Plan can be securely downloaded as a formatted PDF

Email integration
The final plan is also delivered via email for convenience

Auth0 Roles and actions
Role-based access differentiates free and premium feature access.
Automated role assignment ensures smooth and secure onboarding

Problem

Healthcare guidance today is fragmented and inefficient:

People rely on Google searching symptoms, which often leads to confusion and anxiety.
Diet plans online are generic, not personalized to health conditions, goals, or daily routines.
Consulting doctors or nutritionists is expensive and often requires waiting time.
Medical reports, scans, or images like rashes or fractures are difficult to interpret without expert help.
There is no unified platform that combines medical insight + lifestyle guidance in a personalized, easy way.

As a result, many individuals end up:

Making unhealthy food decisions
Misinterpreting their symptoms
Or completely ignoring health advice because it feels overwhelming.

Solution : MedHack: Your AI Health Companion

MedHack provides instant, personalized, and actionable health guidance in one place.

1) MedScan — AI-Based Medical Understanding

Upload X-rays, reports, or skin images
AI analyzes the condition and explains it in simple words
Provides possible causes and recommendations
Encourages informed decisions — not blind self-diagnosis

2) Diet Planner Agent — Personalized Meal Planning

Enter your age, weight, lifestyle habits, budget, and goals
The agent asks follow-up questions to understand your real daily routine
Generates a custom 7-day diet plan:
1. Nutritionally balanced
2. Based on personal restrictions (vegan, allergies, etc.)
3. Tailored for weight loss, gain, or general fitness
Plan can be downloaded as PDF or sent via email instantly

Secure by Design (Auth0 Integration)

This ensures the app can scale responsibly and safely.

User authentication protects personal health data
Role-based access lets free users try basic features
Premium role unlocks advanced scanning and detailed diet planning
Auth0 Actions automate role assignment and secure feature access This makes MedHack practical, trustworthy, and ready for real-world use ## How I Used Auth0 for AI Agents to Secure MedHack  MedHack handles personal medical data, so security and controlled access were critical. I integrated Auth0 for AI Agents to handle authentication, authorization, and tool access permissions.

1) User Authentication

Users sign in using Auth0’s hosted login page.
In middleware.ts, I protect private routes:

// middleware.ts
import { auth0 } from "@auth0/nextjs-auth0";

export default auth0.withMiddlewareAuthRequired();

This ensures only authenticated users can access the dashboard, Diet Planner, or MedScan features.

2) Role-Based Access Control (RBAC)
Role: Access
free_user : Basic MedScan + simple diet suggestions
pro_user : Full diet generator, detailed scan reasoning, PDF + email export

Roles are assigned in Auth0 Dashboard (or via Actions when a user upgrades).

Roles defined in code (auth0-fga.ts)

export const roles = {
  FREE_USER: {
    name: 'free_user',
    permissions: [
      "use:vision_agent",
      "read:health_data"
    ]
  },
  PRO_USER: {
    name: 'pro_user',
    permissions: [
      "use:vision_agent",
      "use:diet_agent",
      "read:health_data",
      "write:health_data",
      "export:pdf",
      "send:email"
    ]
  }
};

3) Injecting Permissions into JWT (Auth0 Action)

I added an Auth0 Post-Login Action so user tokens contain permissions:

exports.onExecutePostLogin = async (event, api) => {
  const namespace = "https://medhack.ai";
  const role = event.authorization?.roles?.[0] ?? "free_user";

  const permissions = role === "pro_user"
    ? roles.PRO_USER.permissions
    : roles.FREE_USER.permissions;

  api.idToken.setCustomClaim(`${namespace}/permissions`, permissions);
  api.accessToken.setCustomClaim(`${namespace}/permissions`, permissions);
};

4) Server-Side Permission Enforcement

Before running any agent or API call, I verify permission.

// lib/authorization.ts
import { auth0 } from "@auth0/nextjs-auth0";

export async function withAuthorization(requiredPermission: string) {
  const session = await auth0.getSession();
  const userPermissions = session?.user?.["https://medhack.ai/permissions"] ?? [];

  if (!userPermissions.includes(requiredPermission)) {
    throw new Error(`Forbidden: Missing Permission → ${requiredPermission}`);
  }
}

Example Use (Protect Diet Agent API) :

// app/api/agents/diet/route.ts
import { withAuthorization } from "@/lib/authorization";

export async function POST(request: Request) {
  await withAuthorization("use:diet_agent");

  // ...run AI agent logic
}

✅ Free users cannot call the diet agent.
✅ Pro users can.
5) Token Vault: Secure Tool Access

When agents call external APIs (OCR, vision, food nutrition search, email sender), I use the Auth0 Token Vault, so:

Tokens never reach frontend
AI agents get temporary scoped access

import { getAccessToken } from "@auth0/nextjs-auth0";

const { accessToken } = await getAccessToken({
  scopes: ["send:email", "export:pdf"]
});

6) FGA-Style Ownership Rule (User Data Privacy)

Each user has access only to their own generated plans & scans:

export function canAccessResource(resourceOwnerId: string, currentUserId: string) {
  return resourceOwnerId === currentUserId;
}

✅ No one can view or download someone else’s medical plan or scan.
This is functionally similar to Auth0 Fine-Grained Authorization (FGA) patterns.
MedHack is secure, scalable, and safe to deploy publicly.

Lessons Learned and Takeaways

...existing content...

💭 Development Retrospective

7 Major Challenges & Solutions

1. AI Model Availability Issues

Problem: Qwen2.5-VL-72B failed in production (404: model not found on free tier)
Solution: Implemented automatic fallback system with 3 models (Gemini → Claude → Llama)
Learning: Always research model availability before deploying; test locally first

2. Auth0 Custom Claims Complexity

Problem: Missed namespace requirement for JWT custom claims (claims weren't appearing in token)
Solution: Added namespace to Auth0 Action: api.idToken.setCustomClaim(${namespace}/permissions, ...)
Learning: Authentication should be designed first, not retrofitted later

3. Client-Side Permission Checks (Security Issue)

Problem: Initially checked permissions in localStorage (could be faked by users)
Solution: Moved all permission checks to backend, verified via JWT custom claims
Learning: Never trust client-side security; backend MUST validate every request

4. Token Management & User Isolation

Problem: API keys shared across users (couldn't track usage or revoke access)
Solution: Created TokenVault class to isolate keys per user, verify ownership before access
Learning: Think about data ownership from day 1; every resource needs an owner

5. Next.js 15 `await cookies()` Change

Problem: cookies().get() worked in v14 but failed in v15 (must be awaited)
Solution: Updated all cookie access: (await cookies()).get('demo_role')
Learning: Modern frameworks evolve quickly; read release notes carefully

6. Fallback Strategies & Error Handling

Problem: Single model failure = 500 error; no graceful degradation
Solution: Try-catch loop through 3 models; meaningful error messages; detailed logging
Learning: Resilience beats simplicity in production; always have fallbacks

7. Environment Variables Not Loading in Vercel

Problem: Med Scan worked locally but failed in production (undefined API keys)
Solution: Created /api/debug/env endpoint to diagnose issues; added all vars BEFORE deployment
Learning: Create diagnostic endpoints early; you can't debug production without visibility

Key Learnings

About AI Agents:

Models are different → test multiple early
Prompt engineering matters significantly
Fallback systems are critical
Context improves results dramatically

About Authentication:

Auth0 is powerful but requires understanding OAuth2 basics
JWT tokens are self-contained proofs (cryptographically signed)
HTTPOnly cookies protect against JavaScript theft
Fine-grained authorization requires careful planning

About Full-Stack Development:

Backend must NEVER trust client
Type safety (TypeScript) prevents runtime errors
Logging is your window into production
Comprehensive error handling improves UX

Top 10 Insights

Security is not optional → build it in from day 1
Backend never trusts client → verify everything server-side
AI fallbacks are critical → never rely on single model
JWT tokens are elegant → self-contained, cryptographically signed
Type safety catches bugs → use TypeScript for larger projects
Logging saves hours → simple logs enable production debugging
Resilience beats simplicity → handle failures gracefully
Auth should be first → don't retrofit security later
Diagnostic endpoints save time → create /api/debug/* routes
Test full flow, not just functions → integration testing matters

What Went Well

✅ Auth0 integration was simpler than expected
✅ Fine-grained authorization scales beautifully
✅ Comprehensive error handling improved UX
✅ Clean code organization enables fast development
✅ AI fallbacks eliminated downtime
✅ Secure token vault prevents key exposure

What I'd Do Differently

Start Auth0 setup first (it's foundational)
Create architecture diagram early
Test error cases from day 1 (not just happy path)
Set up monitoring before production
Plan database schema early

Development Stats

Time: ~60+ hours
Challenges: 7 major ones resolved
Models tried: 3 approaches
Permissions: 10 defined across 3 roles
Security layers: 7 (auth, authz, token vault, audit trail, etc.)
Lines of code: ~3,000+
Production issues: 1 (env vars) - fixed in 30 mins with debug endpoint

Advice for Similar Projects

Building AI Applications:

Test multiple models early
Implement fallback strategies from day 1
Have API cost budget
Log which model succeeds

Implementing Auth:

Choose Auth0 or similar (don't build your own)
Plan permissions before coding
Use HTTPOnly cookies
Never check permissions client-side only

Full-Stack Development:

Start with architecture diagram
Plan security first
Use TypeScript
Log everything
Create diagnostic endpoints

Deploying to Vercel:

Set env vars BEFORE first deployment
Redeploy after adding new vars
Update Auth0 callback URLs
Test locally thoroughly

Final Thoughts

Great products are built at the intersection of:

Clean architecture (organized, maintainable code)
Thoughtful security (security-first decisions)
Resilient systems (graceful failure handling)

The best learning comes from challenges. Every problem taught me something that makes me a better developer.

If I could give one piece of advice: "Build security and resilience into the foundation. Create diagnostic tools early. Test the complete flow. And remember: you can debug anything if you can see what's happening."

MedHack proves that with proper architecture, thoughtful security, and resilient systems, you can build impressive AI applications quickly.

Reddit Scraper AI Agent: ThreadLens

Agastya Khati — Sun, 31 Aug 2025 13:59:06 +0000

This is a submission for the AI Agents Challenge powered by n8n and Bright Data

What I Built

AI-driven automation that transforms any public Reddit thread into a concise, actionable insight eliminating hours of manual reading and ensuring teams never miss key points hidden in long discussions.

What Problem It Solves
Researching Reddit discussions for product feedback, hardware recommendations, or emerging trends can take 30–60 minutes per thread. ThreadLens automatically scrapes every comment and reply, analyzes the conversation with a large language model, and delivers a focused summary in under five minutes. This speeds up decision-making, ensures consistency across research, and makes insights easily searchable in our Notion knowledge base.

Demo

https://youtu.be/4TgBGNGRn5o

n8n Workflow

https://gist.github.com/kris70lesgo/c03f64c8b5decb7f7f6da49aeff5e529

Technical Implementation

n8n Chat Trigger: Captures user input (thread URL) via Telegram or web.
Bright Data Verified Node (Web Scraper): Batches all thread URLs into a configured “Web Scraper” recipe, handles proxy rotation, fingerprinting, and CAPTCHAs, then monitors and downloads the snapshot content.
n8n SplitInBatches & IF Nodes: Controls polling loop for snapshot readiness.
n8n Code & Aggregate Nodes: Reshapes the JSON output into a single text payload.
n8n AI Agent Node: Sends the combined comment text to GPT-3.5-turbo and retrieves the summary.
n8n Notion Node: Appends the final summary to a shared Notion database.

Bright Data Verified Node

The Bright Data node powers all scraping and unblocking:
Initiate Batch Extraction: Sends an array of Reddit comment page URLs to a pre-configured Web Scraper recipe.
Monitor Progress: Polls Bright Data’s API until the snapshot is “ready.”
Download Snapshot Content: Retrieves a structured JSON of all comments and metadata, with no HTML parsing on our end.

Journey

Building ThreadLens taught us to handle asynchronous batch APIs and transform their outputs for AI consumption.

Challenge: Managing the polling loop solved by combining IF, Wait, and SplitInBatches nodes to avoid infinite hangs.

Lesson: Aggregating arrays into a single prompt payload reduces repeated API calls and keeps costs down.

Outcome: A robust, end-to-end agent that any team member can trigger via chat, delivering vetted insights in under five minutes.

Study Buddy: AI-Powered Student Success Assistant

Agastya Khati — Thu, 28 Aug 2025 15:09:30 +0000

This is a submission for the Heroku "Back to School" AI Challenge

What I Built

Study Buddy AI Assistant: Intelligent Back-to-School Platform
The Problem We Solve
Academic Overwhelm in Modern Education

Students struggle with time management across multiple subjects
Information overload makes it hard to focus on key concepts
Lack of personalized study plans leads to inefficient learning
Assessment anxiety from unpredictable quiz formats
Isolation when studying complex topics without guidance
Our AI-Powered Solution
Core Features

Intelligent Study Planning

AI Schedule Generator: Creates optimized weekly study plans based on courses, deadlines, and available time
Smart Prioritization: Automatically weights subjects based on deadlines and difficulty
Adaptive Scheduling: Adjusts plans as priorities change

Personalized AI Tutoring

24/7 Study Companion: Patient, encouraging AI tutor available anytime
Step-by-Step Explanations: Breaks down complex concepts into digestible parts
Multi-Subject Support: Handles math (LaTeX formatting), science, humanities, and more
Citation-Ready: Provides source references when working with uploaded materials

Dynamic Assessment Creation

Custom Quiz Generation: Creates practice tests from any study material
Adaptive Difficulty: Adjusts question complexity based on student level
Instant Feedback: Provides explanations for both correct and incorrect answers
Multiple Question Types: Multiple choice, short answer, and essay formats

Progress Analytics

Learning Insights: Tracks study time, mastery levels, and achievement streaks
Visual Progress: Charts and graphs showing improvement over time
Goal Setting: Helps students set and achieve realistic learning objectives
Technical Innovation
Hybrid AI Architecture
Multi-Provider Support: Seamlessly switches between Heroku AI and Google Gemini
Intelligent Fallbacks: Local algorithms ensure functionality even when AI services fail
Cost Optimization: Routes requests to most efficient provide

Demo

github : link

How I Used Heroku AI

Implemented: Managed Inference and Agents
I integrated Heroku Managed Inference and Agents - the core AI service that provides access to foundation models via OpenAI-compatible REST APIs.

Implementation Details
Auto-detects available providers
Prefers Heroku AI over Gemini when configured
Graceful fallback mechanism

Technical Implementation

Primary: Heroku Managed Inference (OpenAI-compatible)
Fallback: Google Gemini API
Local algorithms: When AI services unavailable

AI Response Reliability Challenge: AI services can fail or return malformed JSON

Solution: Multi-layered fallback system

Cross-Provider Compatibility Challenge: Different AI APIs have incompatible formats

Solution: Unified message interface
Future Multi-Agent Opportunities
Potential Enhancements:

RAG Agent - Document processing with pgvector
Progress Tracker Agent - Learning analytics
Recommendation Agent - Personalized study paths
MCP Integration - Tool coordination between agents

DEV Community: Agastya Khati

Credexia: AI-Powered Loan Compliance Built with Google Gemini

Building Credexia: How Gemini Became My 48-Hour Co-Founder

The Event

What I Built

Demo Video

Live Website

GitHub Repository

kris70lesgo / Credexia

Credexia

Features

Stack

Prerequisites

Setup

Scripts

Monitoring

TradeClear

AgentFlow

Global State

How Gemini Powered Everything

Document Understanding

Code Generation

Blockchain Integration

Trade Clearing Architecture

Payment Waterfall Precision

AI Chat Assistant

The Pitch Deck

Credexia_ Reinventing Trust, Transparency, and Automation in Loan Markets.pptx - Google Slides

Technical Architecture

What I Learned

AI Needs Guardrails

Model Names Are Chaos

Simulation Beats Broken Reality

The Last Mile Is Process, Not Math

Schema Drift Happens Fast

What Worked and What Didn't

What Worked

The Friction

What I Needed

Who This Is For

Business Model

What's Next

Bridgy: Helping Overwhelmed Communities Choose the Right Tool, Not Another Tool

The Community

What I Built

Demo

Code

kris70lesgo / bridgy

Bridgy

Table of Contents

Overview

How I Built It

Architecture Philosophy

Tech Stack

How Bridgy Works

Why These Decisions Matter

Closing

Copilot Sherlock : Governed Incident Investigation CLI

Copilot Sherlock — Governed Incident Investigation CLI

What I Built

The 90-Second Pitch

Demo

Video Walkthrough (Full End-to-End Run)

GitHub Repository

One-Command Demo

Fresh Incident IDs

Copilot Auth vs Offline Mode

My Experience with GitHub Copilot CLI

Why This Matters

Final Notes

[Boost]

3D-First Portfolio Built with Antigravity

Paimon ・ Jan 31

Building a Portfolio with Gemini - New Year, New You Portfolio Challenge

About Me

Portfolio

Video Walkthrough

How I Built It

Gemini 3 as a Creative and Technical Partner

Hero Intro Animation

5. Next.js 15 `await cookies()` Change