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

> Social bookmarking for introverts

- Site: https://pinboard.in
- Category: Web app
- Verdict: **Solid side project** (72/100 vibecodeable)
- Estimated effort: 2-3 weeks part-time

## Verdict

Build a personal clone in about 2 weeks of part-time coding, with the biggest catch being the background web archiver crawler and full-text search pipeline.

Pinboard's frontend is intentionally minimalist and text-driven, making the UI straightforward to build. However, the core engineering challenge of a personal clone lies in the backend worker: a robust crawling utility that fetches bookmarked URLs, respects timeouts, strips out bloat, and feeds a full-text search engine. Since this is for personal use, you can skip payment infrastructure and multi-tenant billing entirely, turning a commercial SaaS into a clean self-hosted personal tool.

### What you can't replicate

- The 17-year brand history and trust of Maciej Cegłowski
- The exact 30,000-user community network effect

## What it does

A fast, minimalist, ad-free social bookmarking and personal web archiving service designed for privacy-minded users.

### Core features

- URL bookmarking and metadata extraction
- Flexible tagging system with case-insensitive search and auto-complete
- Privacy states (public, private, unread, privacy lock)
- Automated web archiving crawler for static page snapshots
- Full-text search engine index over saved HTML and document text
- Netscape HTML bookmark import and export parser
- RSS feeds for user and tag combinations
- Minimalist, text-heavy server-rendered UI

## The business

### Pricing

- Basic Account: $22/yr — Standard bookmarking and tagging service
- Archival Account: $39/yr — Archival bookmarking with full-text search

### Funding

$0 raised.

Founded 2009.
Team size: 1 person.

## The hard parts

- Reliable background web crawler handling timeouts, rate limits, and 32MB link size caps
- Full-text search indexing across hundreds of thousands of scraped pages and documents
- Fast database performance on lean SQL schemas without complex distributed infrastructure
- Netscape bookmark export/import parsing edge cases with duplicate merging rules

## How to vibe code Pinboard

### Prerequisites

- Node.js (free): Required for running the Next.js runtime and build tooling locally.
- GitHub (free): Source code repository and deployment pipeline integration.

### Recommended AI tools

- Claude Code: Best-in-class terminal coding agent for scaffolding full-stack applications and writing robust background scraping workers.
- Cursor: Excellent AI editor for iterative UI polish on the minimalist dashboard views.

### Stack

- Frontend: Next.js (App Router) + Tailwind CSS
- Backend: Next.js Server Actions + Node.js Background Worker
- Database: Turso (libSQL/SQLite)
- Auth: better-auth
- Payments: None (personal use)
- Other: Cheerio for HTML parsing and metadata extraction, Playwright / Firecrawl API for web archiving snapshots

### Hosting

- Cloudflare (Hosting frontend and edge serverless routes via Cloudflare Pages/Workers): $0/mo
- Fly.io (Running long-lived background workers for crawling and full-text indexing): ~$3-5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Turso (SQLite) database connection, and set up better-auth for single-user or private multi-user access.

```
Create a new Next.js project using App Router, TypeScript, and Tailwind CSS. Configure Turso (libSQL) as the database client using Drizzle ORM or Prisma. Design the database schema for bookmarks: tables for users, bookmarks (id, url, title, description, extended, createdAt, updatedAt, shared, toread, hash), and tags (id, name, bookmarkId). Ensure foreign key constraints and proper indexes on URL hashes and creation dates. Set up better-auth with email/password authentication configured strictly for personal use.
```

2. **Bookmark CRUD and Tagging System** — Build the core bookmark management interface, supporting adding URLs, editing descriptions, and managing comma-or-space-separated tags with auto-complete.

```
Build the bookmark management UI and server actions in Next.js. Implement a form to add new bookmarks with URL, title, description, public/private toggle, and 'to read' status. When a URL is submitted, automatically fetch the target page title using a lightweight fetch request if no title is provided. Implement tag parsing (splitting by whitespace/commas, cleaning special characters) and store them in the tag relation. Create a sidebar tag cloud component that lists user tags sorted by frequency with counts, and an auto-complete endpoint for tags.
```

3. **Filtering, Searching, and List Views** — Implement bookmark listing views with reverse chronological sorting, tag composition filters (up to 4 tags), and search query filtering.

```
Implement the main bookmark list view supporting pagination and sorting (reverse chronological by default, title sort on tag pages). Build URL route handling for tag filtering matching the pattern /u:username/t:tag1/t:tag2 supporting up to four composed tags using intersection logic. Add a basic search input that queries bookmark titles and descriptions using SQL LIKE or SQLite FTS5 full-text search tables. Add support for public vs private visibility checks based on the authenticated user.
```

4. **Netscape Bookmark Import and Export** — Build importers and exporters compatible with standard Netscape HTML bookmark files and JSON backup formats.

```
Build an import and export feature for bookmarks. Create an API endpoint and UI form that accepts Netscape-style HTML bookmark export files (as generated by browsers and legacy services like Delicious). Parse the HTML file using Cheerio to extract URLs, titles, creation timestamps, tags, and private status flags, bulk-inserting them into the database while avoiding duplicate URLs. Also implement an export endpoint that generates a valid Netscape HTML bookmark file and a JSON backup of all bookmarks.
```

5. **Web Archiving Background Worker and Crawler** — Create a background worker service that fetches bookmarked pages, saves static HTML snapshots, and handles size caps and timeouts.

```
Build a background archiving worker script in Node.js designed to run on Fly.io or as a cron job. The worker queries unarchived bookmarks, fetches the target URL using an enhanced request wrapper with a 32MB size limit and polite timeout headers, and stores the raw HTML response in object storage (or local disk/R2). Update the bookmark record with an archival status code and timestamp. Implement a manual re-crawl trigger endpoint accessible from the bookmark detail view.
```

6. **Full-Text Search Indexing and UI Polish** — Set up SQLite FTS5 full-text search indexing over archived bookmark content and polish the minimalist information-dense UI styling.

```
Implement full-text search over archived bookmark content. Set up an SQLite FTS5 virtual table synchronized with bookmark archival text content. Create a search results page that highlights matching query terms in snippets. Refine the CSS styling across the application to match Pinboard's intentionally minimalist, information-dense aesthetic: clean typography, muted color palette, fast page loads, and zero tracking scripts.
```

### Cost vs paying

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

- Custom domain (optional): $12/yr
- AI coding tools (Claude Pro): $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Fly.io worker compute: $3-5/mo
- Cloudflare Pages/Turso: $0/mo
- Total: ~$4/mo

- Paying for the SaaS instead: $3.25/mo ($39/yr archival plan)
- Build time: 25-35 hours
- AI tool credits: $20 (1 month of Claude Pro)
- Break-even: Never (built for personal ownership and privacy)

## Sources

- [Pinboard Home Page](https://pinboard.in)
- [Pinboard About Page](https://pinboard.in/about/)
- [Pinboard FAQ Page](https://pinboard.in/faq/)
- [Pinboard Security Page](https://pinboard.in/security/)