# How to Vibe Code Your Own FlySoar AI (and Stop Paying for It)

> AI-driven flight and travel discovery platform

- Site: https://flysoar.ai
- Category: Travel
- Platforms: Web app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 4-6 weeks of dedicated work

## Verdict

Build a personal flight discovery wrapper, but expect significant friction integrating real flight inventory APIs and building secure vaults for payment credentials.

While spinning up a Next.js frontend with Server-Sent Events and an MCP server is straightforward with AI tooling, getting real live flight inventory requires integrating expensive or heavily rate-limited GDS or travel aggregator APIs like Duffel or Amadeus. Furthermore, storing payment methods and traveler passport details introduces immense security overhead and compliance liabilities that make a fully functional one-click booking clone a serious engineering challenge for a solo developer.

### What you can't replicate

- Direct commercial agreements with airlines and OTAs
- Proprietary GDS integration pipelines with zero-latency caching
- User trust and institutional compliance frameworks for handling sensitive passport and financial data

## What it does

Aggregates live airfares from multiple airlines and online travel agencies simultaneously to highlight optimal pricing tiers, featuring one-click booking and a built-in travel assistant.

### Core features

- Multi-source live flight price aggregation and comparison
- Streaming search results using Server-Sent Events (SSE)
- Secure traveler profile and payment method vault
- Model Context Protocol (MCP) server for external AI agent integration
- Text-based travel assistant interface ('Sky')
- Automated flight check-in simulations and gate update feeds

## The business

### Pricing

- Free Search: Free — Public flight search and price aggregation interface.

Founded 2026.
Team size: Solo founder / micro-team.

## The hard parts

- Sourcing reliable live flight inventories and airfares without official GDS partner access or incurring massive API costs
- Handling real-time seat availability changes and rate limits across various airline and OTA endpoints
- Designing a secure, PCI-DSS compliant payment and sensitive traveler data vault for one-click bookings
- Standardizing and maintaining an external Model Context Protocol (MCP) server with OAuth authentication for agentic tool use

## How to vibe code FlySoar AI

### Prerequisites

- Node.js (free): Required for running the Next.js development environment and backend services.
- GitHub (free): Version control and deployment pipeline integration.
- Travel API Provider Account (Free tier / Usage-based): Needed to source mock or live flight schedule and pricing data (e.g., Duffel Sandbox or Amadeus Self-Service).

### Recommended AI tools

- Claude Code: Best-in-class multi-file agentic coding tool for scaffolding full-stack Next.js apps, setting up streaming routes, and configuring MCP endpoints.

### Stack

- Frontend: Next.js with Tailwind CSS
- Backend: Next.js API Routes with Server-Sent Events (SSE) and MCP Server implementation
- Database: Turso (SQLite at the edge for storing user profiles and mock bookings)
- Auth: better-auth
- Payments: Stripe (or stubbed local payment vaults for personal test scenarios)
- Other: Anthropic API for the Sky assistant persona

### Hosting

- Vercel (Hosting the Next.js frontend and serverless streaming API endpoints): $0-20/mo
- Turso (Persistent SQLite database for user preferences and travel history): $0/mo

### Build guide

1. **Project Scaffolding & Design System** — Initialize the Next.js project with Tailwind CSS, configure font pairings, layout containers, and global color variables to match a clean travel discovery interface.

```
Create a new Next.js project using App Router, TypeScript, and Tailwind CSS. Set up a clean, modern travel search layout with a dark/light mode toggle, a prominent origin-destination search form bar, and responsive navigation headers. Establish a component structure for flight result cards, filter sidebars, and chat drawers.
```

2. **Flight Search & Aggregation API Integration** — Implement backend API routes that interface with a flight aggregation provider (or mock flight data generation fallback) to retrieve fares.

```
Implement a Next.js API route at `/api/search` that accepts origin, destination, dates, and passenger counts. Integrate the Duffel API or a robust fallback mock generator that returns structured JSON arrays containing flight pricing tiers categorized by 'Best', 'Cheapest', and 'Fastest', including airline names, durations, and stop counts.
```

3. **Streaming Search Results via Server-Sent Events (SSE)** — Build a streaming endpoint and frontend consumer to progressively render live airfare results as they load from multiple simulated provider streams.

```
Build a Server-Sent Events (SSE) API route at `/api/search/stream` that yields progressive flight search batches to the client. Update the frontend search results page to consume this stream using an EventSource or fetch reader, displaying dynamic loading indicators such as 'checking airline direct' and 'scanning OTA sources' alongside live updating price items.
```

4. **User Vault & Secure Profile Management** — Set up Turso database with better-auth and create a traveler profile vault schema for storing encrypted passenger details and payment metadata.

```
Configure better-auth with Turso database integration using libSQL. Create database schemas for user profiles, stored traveler details (names, passport numbers, dates of birth), and encrypted payment method references. Build a settings dashboard UI where users can securely view and edit their saved travel vault information.
```

5. **Model Context Protocol (MCP) Server Implementation** — Develop a standalone or integrated Model Context Protocol (MCP) endpoint that exposes flight search and booking tools for external AI clients.

```
Implement an MCP server endpoint (e.g., `/api/mcp`) adhering to the Model Context Protocol specification. Expose tools for searching flights (`search_flights`), retrieving fare details (`get_fare_details`), and initiating bookings using stored user profile parameters. Ensure proper OAuth client authentication token checks for agentic tool requests.
```

6. **Travel Assistant Interface ('Sky')** — Create a text-based conversational assistant interface that connects to the LLM backend and can invoke the flight search tools and MCP capabilities.

```
Build a slide-over chat assistant interface named 'Sky' within the Next.js app. Connect it to an API route utilizing the Anthropic SDK with tool-use definitions mapped to the flight search and MCP backend functions. Allow users to text natural language queries like 'Find me a flight from JFK to LAX next Tuesday' and render interactive flight recommendation cards directly inside the chat stream.
```

### Cost vs paying

**Starting costs (one-time):**

- Domain registration: $12
- AI coding credits: $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby / Edge Hosting: $0-20/mo
- Turso Database: $0/mo
- Total: ~$0-20/mo

- Paying for the SaaS instead: Free / Variable
- Build time: 40-60 hours
- AI tool credits: $20
- Break-even: N/A (Personal project clone)

## Sources

- [flysoar.ai Homepage & Feature Descriptions](https://flysoar.ai)
- [Smithery / MCP Registry - Flight Booking MCP (Soar)](https://smithery.ai)