# How to Vibe Code Your Own Inoreader (and Stop Paying for It) > Build your own newsfeed - Site: https://inoreader.com - Category: Productivity & Content Curation - Verdict: **Serious undertaking** (48/100 vibecodeable) - Estimated effort: 3-5 weeks of part-time development ## Verdict Build a personal subset for your own RSS reading, but keep paying if you rely on their massive feed index and web scraping infrastructure. While a basic RSS reader loop is straightforward, Inoreader's real complexity lies in scale: thousands of concurrent background polling jobs using conditional HTTP requests, web scraping engines for non-RSS sites, full-text extractors, and an automated rule evaluation engine running continuously. Vibecoding an MVP for your personal subscriptions is entirely achievable, but replicating the robust multi-source ingestion pipeline requires significant background worker infrastructure. ### What you can't replicate - Their 5-million-source indexed discovery catalog - Years of edge-case handling for broken or malformed XML/Atom feeds across the web ## What it does A cloud-based content curation, social listening, and RSS aggregation platform designed to monitor, filter, and manage high volumes of web content. ### Core features - RSS/Atom feed ingestion and polling - Web scraping to generate feeds from non-RSS pages - Full-text article extraction (Readability) - Logical filtering and automation rules engine - AI article summarization and translation - Full-text search indexing across saved items ## The business ### Pricing - Free: Free - Pro: $7.50/mo Founded 2013. Team size: Small-to-medium independent team. ## The hard parts - Managing reliable background polling and rate limits across thousands of disparate RSS sources - Reliable headless browser rendering and change detection for web pages without feeds - Full-text extraction algorithms that handle arbitrary and messy website structures cleanly - Real-time rules engine evaluation at ingestion scale ## How to vibe code Inoreader ### Prerequisites - Node.js (free): Required for running the TypeScript full-stack framework - GitHub (free): Source control and deployment pipeline integration ### Recommended AI tools - Claude Code: Best-in-class multi-file agentic coding tool for scaffolding complex background workers and API routes - Cursor: Ideal for fine-tuning complex UI layouts and reader interfaces ### Stack - Frontend: Next.js - Backend: Next.js API routes with BullMQ / Node background workers - Database: Turso - Auth: better-auth - Payments: none - Other: Vercel AI SDK, Cheerio for HTML parsing, rss-parser ### Hosting - Vercel (Hosting the Next.js frontend and serverless API endpoints): $0-20/mo - Turso (Serverless SQLite database for feeds, articles, and rules): $0/mo - Fly.io (Running persistent background worker containers for high-frequency feed polling): $3-5/mo ### Build guide 1. **Scaffold Project & Setup Database** — Initialize the Next.js application with TypeScript, configure Turso database client, and set up better-auth for single-user authentication. ``` Initialize a new Next.js 16 project with Tailwind CSS and TypeScript. Configure Turso (libSQL) as the database client using Drizzle ORM or Prisma. Set up better-auth for secure user authentication with email and password. Create the initial database schema tables for users, feeds, articles, folders, and rules. Implement a clean dashboard layout with a sidebar for folder navigation and a main content pane for reading articles. ``` 2. **RSS Ingestion & Polling Worker** — Build a robust background worker using `rss-parser` that fetches feeds on a schedule, respects `ETag`/`Last-Modified` headers, and stores new articles. ``` Build a background polling worker service (designed to run on Fly.io) that iterates through subscribed RSS/Atom feed URLs in the Turso database. Use `rss-parser` to fetch feed items. Implement conditional HTTP requests checking `ETag` and `Last-Modified` headers to avoid redundant downloads. Parse items, extract titles, URLs, publication dates, and raw content, and store them idempotently in the articles table to prevent duplicates. Ensure robust error handling for dead or unresponsive feeds. ``` 3. **Full-Text Article Extraction & Reader View** — Implement a reader view scraper that cleans up clutter from arbitrary article links for distraction-free reading. ``` Create a server-side extraction utility using Cheerio and a readability heuristic to strip ads, pop-ups, and boilerplate navigation from arbitrary article URLs when requested. Build a clean, distraction-free reader view UI component in Next.js that displays the cleaned full content with custom typography controls and adjustable dark/light themes. ``` 4. **Rules & Automation Engine** — Implement a conditional rule-evaluation pipeline that executes actions (tagging, starring) when incoming articles match user-defined criteria. ``` Build a rules engine module that executes immediately after new articles are ingested by the worker. Create a rule builder UI allowing users to define conditions (e.g., if title contains keyword X or feed equals Y) and actions (e.g., assign tag Z, mark as starred). Implement the evaluation runner in the backend to automatically apply tags and flags to incoming articles in real-time. ``` 5. **AI Intelligence Integration** — Integrate the Vercel AI SDK to provide article summarization and translation features. ``` Integrate the Vercel AI SDK into the reader interface. Add backend API routes connecting to OpenAI or Anthropic models to support one-click article summarization and multi-language translation. Display generated summaries and translated text cleanly within the article view drawer with loading states and error handling. ``` 6. **Search & Polish** — Add full-text search capabilities across saved articles and polish the keyboard shortcut navigation experience. ``` Implement full-text search across all ingested articles using Turso's SQL search capabilities or SQLite FTS5 extensions. Add a dedicated search results view with keyword highlighting. Implement desktop keyboard shortcuts (e.g., 'j'/'k' for next/previous article, 'm' for mark as read, 's' for star) to mimic a power-user RSS reader experience. ``` ### Cost vs paying **Starting costs (one-time):** - Domain name (optional): $12/yr - Total: ~$12 one-time **Ongoing costs (monthly):** - Fly.io background worker hosting: $3/mo - AI API usage (OpenAI/Anthropic): $2/mo - Total: ~$5/mo - Paying for the SaaS instead: $7.50/mo - Build time: 25-35 hours - AI tool credits: $20 (Claude Pro) - Break-even: Never (built for personal learning and custom control) ## Sources - [Inoreader Features](https://www.inoreader.com) - [Inoreader Pricing](https://www.inoreader.com)