# How to Vibe Code Your Own BazQux Reader (and Stop Paying for It)

> Your friend for reading feeds, without ads and tracking

- Site: https://bazqux.com
- Category: Web app
- Verdict: **Solid side project** (68/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused development

## Verdict

You can build a functional personal feed aggregator clone, but keeping a reliable background crawler running smoothly across thousands of feeds requires patience.

Building the UI, OPML parser, and basic SQLite storage in Next.js is straightforward. The real engineering weight lies in the background polling worker: scheduling jobs cleanly, handling flaky remote servers, extracting full text without breaking on garbage HTML, and maintaining compatibility layers if you want to sync with third-party RSS apps.

### What you can't replicate

- The 14-year accumulated stability and edge-case handling of the original crawler
- The exact community ecosystem built around BazQux

## What it does

A high-performance commercial feed aggregator, RSS reader, and social media parser designed to replace Google Reader.

### Core features

- Atom, RSS, and JSON feed parsing with background scheduling
- Social media parsing (Telegram channels, social pages)
- Full-text article extraction from truncated web pages
- Secure image proxy to strip tracking pixels
- OPML import and export
- Google Reader API and Fever API emulation for mobile clients
- Smart streams, tags, and filters
- Multiple view modes (list, mosaic, magazine, expanded)

## The business

### Pricing

- Annual Tier (Standard): $30/mo — Annual subscription for feed updates and syncing.
- Annual Tier (Supporter): $50/mo — Functionally identical to the $30 tier; acts as extra support.
- Lifetime Tier: $249 — One-time lifetime subscription.

### Funding

$0 raised.

Founded 2012.
Team size: 1 person.

## The hard parts

- Asynchronous feed polling and scheduling queue scaling dynamically based on historical update frequencies
- Constant scraper maintenance against breaking changes on third-party social platforms
- Emulating legacy third-party sync APIs (Google Reader/Fever) accurately for mobile clients
- Robust full-text extraction heuristics across diverse website structures

## How to vibe code BazQux Reader

### Prerequisites

- Node.js (free): Runtime environment for the Next.js application and background workers.
- GitHub (free): Code repository and CI/CD triggers for deployment.

### Recommended AI tools

- Claude Code: Handles multi-file scaffolding, database schemas, and background worker logic end-to-end.
- Cursor: Ideal for fine-tuning the dense feed-reading UI layouts and keyboard shortcuts.

### Stack

- Frontend: Next.js (App Router) + Tailwind CSS
- Backend: Next.js API routes & server actions with background task queue
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: None (personal use clone)
- Other: rss-parser, cheerio

### Hosting

- Fly.io (Persistent background worker processes and reliable long-running cron pollers for feed ingestion): ~$5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS and configure Turso with better-auth and Drizzle ORM.

```
Create a new Next.js 16 application with TypeScript, Tailwind CSS, and App Router. Set up Drizzle ORM configured for Turso (SQLite). Create database schemas for users, feeds, articles, folders, and tags. Feeds table should store url, title, site_url, last_fetched_at, and error_count. Articles table should store id, feed_id, title, link, content, author, published_at, and read_status. Include indexes on feed_id and published_at for high-performance retrieval.
```

2. **Authentication and User Shell** — Implement authentication using better-auth and design a clean, responsive feed reader layout with a sidebar.

```
Integrate better-auth into the Next.js app supporting email/password login. Build a responsive desktop layout featuring a collapsible sidebar for folders and feeds, a middle column for the article list with multiple view modes (list, expanded), and a right pane for reading the selected article. Implement keyboard shortcuts for navigation (j/k for next/prev article, m for toggle read status).
```

3. **OPML Import/Export and Feed Subscription** — Build feed subscription handling and OPML parsing functionality to import and export feeds.

```
Implement API endpoints for subscribing to a feed URL. Use 'rss-parser' to fetch, parse, and validate RSS/Atom feeds upon addition. Build an OPML import tool that parses uploaded XML files, extracts feed titles and XML URLs, and bulk-inserts them into the user's account under appropriate folders. Also build an OPML export endpoint that generates a valid OPML file from the user's subscriptions.
```

4. **Background Feed Ingestion Worker** — Create a robust background polling system to periodically fetch new articles from subscribed feeds.

```
Create a background worker service using Node.js intervals or a cron schedule that iterates through active feeds in the database. Fetch each feed with proper user-agent headers, timeout limits, and error handling. Parse new items, deduplicate by link or GUID, and insert unread articles into the database. Update feed status and error counts gracefully when feeds fail to load or return HTTP errors.
```

5. **Full-Text Extraction and Image Proxy** — Implement basic full-text content extraction and an image proxy endpoint to protect user privacy.

```
Build a full-text extraction utility using Cheerio or Readability heuristics to fetch an article's target URL and extract its core body text when the RSS feed provides only truncated summaries. Create an image proxy API route that accepts an image URL as a query parameter, fetches the image server-side, strips tracking headers and cookies, and streams it back to the client securely.
```

6. **Google Reader Compatible API Layer** — Expose basic Google Reader API endpoints to allow syncing with third-party RSS mobile clients.

```
Implement a lightweight compatibility API mimicking the Google Reader API endpoints under /accounts/nps/token, /reader/api/0/subscription/list, /reader/api/0/stream/contents/reading-list, and /reader/api/0/edit-tag. Map these endpoints to the local Turso database tables so that standard third-party mobile and desktop RSS clients can authenticate and sync read states.
```

### Cost vs paying

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

- Domain name (optional): $12
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Fly.io backend worker hosting: $5/mo
- Total: ~$5/mo

- Paying for the SaaS instead: $30/yr (~$2.50/mo)
- Build time: 35-50 hours
- AI tool credits: $20
- Break-even: Not rational for financial savings (commercial product is $30/yr); build strictly for learning and customization.

## Sources

- [BazQux Reader Official Website](https://bazqux.com)
- [HaskellWiki - Web/Existing Software](https://wiki.haskell.org/Web/Existing_software)
- [AlternativeTo - BazQux Reader Specs](https://alternativeto.net/software/bazqux-reader/)