# How to Vibe Code Your Own Feedbin (and Stop Paying for It) > Follow your passions with RSS, email newsletters, podcasts, and YouTube - Site: https://feedbin.com - Category: RSS Aggregator / News Reader - Platforms: Web app - Verdict: **Solid side project** (68/100 vibecodeable) - Estimated effort: 3-4 weeks of focused coding and debugging ## Verdict Build a personal RSS aggregator subset with AI assistance, but keep paying for Feedbin if you rely on its bulletproof uptime and ecosystem client sync. Feedbin looks straightforward on the surface—a web UI displaying items stored from RSS feeds—but the background polling machinery is where solo developers hit a wall. Managing cron jobs to fetch feeds asynchronously, handling malformed XML/Atom schemas, parsing partial HTML for full-text extraction, and processing inbound emails for newsletters require careful error handling. While an AI coding agent can scaffold the Next.js frontend and PostgreSQL database rapidly, keeping background feed scrapers robust against dead servers, rate limits, and SSL errors takes real engineering stamina. ### What you can't replicate - The decade of edge-case handling for broken XML feeds and weird encodings - Native sync compatibility with every third-party iOS and Mac feed reader out-of-the-box ## What it does A feature-rich, commercial RSS aggregator and content consumption service with support for full-text extraction, newsletters, podcasts, and native app synchronization. ### Core features - OPML import and export - RSS/Atom feed background polling and parsing - Email newsletter forwarding ingestion pipeline - YouTube playlist and channel RSS ingestion - Full-text extraction for partial feeds - Article organization with tags/folders and starring - Advanced persistent search and saved searches - Automated article rules and actions - API syncing for third-party mobile/desktop readers ## The business ### Pricing - Monthly: $7 / month - Yearly: $70 / year ### Funding $0 raised. Founded 2013. Team size: Micro-team. ## The hard parts - Scaling concurrent RSS polling across thousands of disparate feeds without hitting rate limits or blocking workers - Robust HTML cleaning, full-text scraping, and image proxying to avoid mixed-content issues - Maintaining high-performance RSS sync endpoints compatible with legacy and modern third-party clients ## How to vibe code Feedbin ### Prerequisites - Node.js (free): Required for running the Next.js development environment and backend scripts. - GitHub (free): Source control and deployment pipeline integration. - Resend Account (free tier): Handles transactional email sending and inbound parsing for newsletter subscriptions. ### Recommended AI tools - Claude Code: Executes multi-file scaffolding, builds database migrations, and iteratively fixes background scraping errors. - Cursor: Ideal for fine-tuning the complex three-column reading interface and keyboard shortcuts. ### Stack - Frontend: Next.js (App Router) with Tailwind CSS and TypeScript - Backend: Next.js API Routes & Server Actions - Database: Neon (Serverless Postgres) - Auth: better-auth - Payments: None (Personal use) - Other: rss-parser for feed ingestion, cheerio for HTML full-text extraction, Upstash Redis for background job queue scheduling ### Hosting - Vercel (Hosting the Next.js web application and serverless API endpoints.): $0/mo (Hobby tier) - Neon (Serverless Postgres database storing feeds, articles, and user state.): $0/mo (Free tier) - Upstash (Serverless Redis for background polling job queues and rate limiting.): $0/mo (Free tier) ### Build guide 1. **Project Scaffolding & Database Schema** — Initialize a Next.js project with TypeScript, Tailwind CSS, and better-auth. Set up Neon Postgres tables for users, feeds, articles, and read states. ``` Scaffold a new Next.js 16 application with TypeScript, Tailwind CSS, and App Router. Configure Drizzle ORM to connect to Neon Postgres. Create a complete database schema with tables for users, feeds (url, title, site_url, last_fetched_at), articles (id, feed_id, title, url, author, content, published_at, guid), and user_articles (user_id, article_id, read_status boolean, starred boolean). Integrate better-auth for secure email/password authentication. Ensure proper foreign key constraints and indexes on feed_id and published_at. ``` 2. **OPML Import & Feed Parser Service** — Build an OPML parser module to allow bulk importing subscription lists, paired with an RSS/Atom ingestion utility using rss-parser. ``` Create an OPML import API endpoint in Next.js that parses uploaded XML files using fast-xml-parser, extracting feed URLs and titles. Implement a background ingestion service using rss-parser that fetches a feed URL with proper user-agent headers, handles XML/JSON parsing edge cases, catches timeouts gracefully, and upserts articles into the database while ignoring duplicates based on article guid or url. ``` 3. **Background Polling Worker Setup** — Configure Upstash QStash or Vercel Cron triggers to periodically fetch and update active RSS feeds in the background. ``` Implement a cron-triggered API route in Next.js secured by a secret header that queries feeds table ordered by last_fetched_at ASC limit 20. For each feed, fetch new items asynchronously, parse them, and store unread entries. Update the feed's last_fetched_at timestamp. Configure error logging for failing feeds so they do not crash the worker loop. ``` 4. **Three-Column Reader Web Interface** — Develop a responsive, keyboard-navigable three-column web layout (folders/feeds, article list, article reading pane) with dark mode. ``` Build a responsive three-column web reader UI using Tailwind CSS and React. Column 1 displays feeds and folders with unread counts. Column 2 lists articles for the selected feed with title, author, date, and read/unread status badges. Column 3 shows the full article reading view with clean typography and image styling. Add keyboard shortcuts (j/k for article navigation, m for toggle read, s for star) using a global event listener. ``` 5. **Full-Text Extraction Service** — Implement a scraping utility using Cheerio and Readability heuristics to extract clean article text for partial RSS feeds. ``` Create a full-text extraction API route that takes an article URL, fetches its HTML content via fetch with a browser user-agent, and uses cheerio alongside a readability algorithm to extract the main article body text and remove clutter (ads, sidebars, navigation). Add a button in the reading pane UI that triggers this extraction and replaces partial content dynamically. ``` 6. **Search & Saved Searches** — Add PostgreSQL full-text search capabilities across article titles and content, allowing users to save custom search queries. ``` Implement full-text search on the articles table using PostgreSQL tsvector and tsquery. Build a search input bar in the frontend that queries articles instantly. Add a 'Save Search' feature storing search query strings in a saved_searches table, displaying them in the sidebar alongside feeds for one-click access. ``` 7. **Newsletter Ingestion via Email Forwarding** — Integrate Resend inbound webhook parsing to convert forwarded newsletters into clean reading items inside the feed reader. ``` Configure an API endpoint to receive inbound email webhooks from Resend. Generate a unique forwarding email address for each user profile (e.g. user_hash@yourdomain.com). When an email arrives via Resend, parse the HTML body, sanitize it with DOMPurify, convert it into a pseudo-article entity, and assign it to a special 'Newsletters' feed category for that user. ``` ### Cost vs paying **Starting costs (one-time):** - Custom Domain (optional): $12 / year - Total: ~$12 one-time **Ongoing costs (monthly):** - Vercel / Neon / Upstash Free Tiers: $0 / mo - Total: $0 / mo - Paying for the SaaS instead: $7 / month - Build time: 40-50 hours - AI tool credits: $20 (Claude Pro / Cursor) - Break-even: N/A (Built for personal use and learning) ## Sources - [Feedbin Official Website](https://feedbin.com) - [Feedbin About Page](https://feedbin.com/about) - [GitHub - feedbin/feedbin](https://github.com/feedbin/feedbin)