From RFQ Emails to Winning Proposals: Building Tendr

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.