Digestify

You save useful links & resources, then forget why. Digestify turns your growing pile of bookmarks into bite-sized AI digests you can scan, tag, and actually use later.

Comment

Project Story

Inspiration

I kept running into the same problem: I would save links, Reels, or Youtube videos because they looked useful, tell myself I would come back to it later, and then slowly accumulate a huge list that I'd hardly ever touch.

The problem was not saving them. Saving is easy. The problem was remembering what was actually useful in that list.

This happens everywhere: YouTube videos, Threads post, Instagram posts/reels, technical documentation, articles, tutorials, and random resources found while researching something. After enough time, the saved list becomes a collection of things you might need rather than something you can confidently use.

That led to the idea behind Digestify:

What if every link could carry a little bit of its own context?

Instead of making users reopen every saved page to remember what it contains, Digestify creates a short AI digest when the link is saved.

What it does

Digestify turns a public web URL into a compact, scannable digest.

The current MVP:

  • Accepts and validates a public HTTP/HTTPS URL
  • Retrieves readable page content through Jina AI Reader
  • Sends the extracted content to Qwen/Qwen2.5-7B-Instruct through Featherless AI
  • Generates a title, three key takeaways, and topic tags
  • Saves the result into a personal digest library
  • Lets users filter the library by generated tags
  • Supports opening the original source, copying a digest, and deleting saved items

The goal is not to replace the original content. The digest gives enough context to answer a simpler question first:

“Is this actually the resource I was looking for?”

How I built it

I built Digestify as a Next.js application using TypeScript and Tailwind CSS.

The core pipeline is:

[Public URL] ➔ [Jina AI Reader] ➔ [Readable page content] ➔ [Qwen 2.5 7B] ➔ [Title + 3 Takeaways + Tags] ➔ [Digest Library]

Jina AI Reader handles the web-content retrieval layer, which lets the application work with extracted page text without building a browser-based scraping system from scratch.

For summarization, I used Qwen 2.5 7B through Featherless AI. The model is prompted to return a structured JSON response containing the title, summary points, and tags.

I also added several small reliability measures around the AI pipeline:

  • Limit retrieved content to 8,000 characters before inference
  • Extract and parse the model's JSON response defensively
  • Filter malformed summary/tag values and provide fallbacks
  • Validate URLs on both the client and server
  • Handle loading and error states in the UI

For the hackathon MVP, saved digests are stored in browser localStorage. This keeps the prototype simple and avoids introducing authentication and database infrastructure before the core experience was proven.

Challenges I ran into

The hardest part was not generating a summary. It was everything around the model.

1. Getting usable content from arbitrary URLs

A URL does not necessarily give you clean article text. Web pages can contain navigation, scripts, ads, or other content that is not useful to a summarization model.

Rather than building a full scraping stack during the hackathon, I used Jina AI Reader as the content extraction layer.

2. LLM output is not guaranteed to be perfectly structured

The application expects JSON, but an LLM can still return extra text or wrap the JSON in Markdown.

The API therefore does not blindly assume that the response is valid. It extracts the expected JSON object, parses it, sanitizes the returned arrays, and falls back when necessary.

3. Keeping the MVP small

There were many ideas I could have implemented on this project: semantic search, accounts, cloud storage, full-text search, recommendations, batch processing, and more.

To ensure a working first prototype, I intentionally kept the first version focused on one complete workflow:

save a link → understand it quickly → keep it for later.

That made it possible to get a functional MVP rather than 10 unfinished features.

Accomplishments I'm proud of

The biggest accomplishment was turning a simple idea into a working (minimalist) end-to-end product rather than stopping at an AI summarization demo.

A saved URL now travels through a complete pipeline:

[URL input] ➔ [Content retrieval] ➔ [LLM summarization] ➔ [Structured digest] ➔ [Saved library] ➔ [Tag filtering]

I'm also proud of the small details that make the prototype feel like an actual application rather than an API wrapper: loading states, error handling, deletion, source links, and visual feedback when copying a digest.

Most importantly, the MVP demonstrates the core product hypothesis: adding context to saved resources makes a growing collection easier to revisit.

What I learned

I learned that building an AI feature is mostly about designing everything around the model, not just calling the model.

Reliable output depends on controlling the input, handling broken/imperfect responses, validating data, and designing sensible fallbacks.

I also learned the difference between a feature that sounds useful and a feature that is actually worth implementing first. Semantic search, recommendations, and AI conversations over the saved library are exciting, but they only become useful after the application has enough structured content to search through.

That significantly shaped the project into a more incremental architecture:

[Save resources]
       ↓
[Build structured context]
       ↓
[Retrieve relevant resources]
       ↓
[Synthesize useful answers]

The MVP focuses on the first two steps. The next versions can build on top of them.

What's next for Digestify

The next step is to move beyond simply summarizing saved links and make the collection useful based on what the user needs right now.

For example:

“I want to learn RSA.”

Digestify could search the user's saved resources, identify the most relevant links, and give the user a concise path through them instead of making them manually search the entire collection.

Planned improvements include:

  • Supabase-backed persistence for a larger, more durable library
  • Batch and parallel processing for saving multiple resources
  • Editing for titles, summaries, and tags
  • Semantic search using embeddings
  • AI-assisted retrieval and synthesis across multiple saved resources
  • Personalized learning paths and search-term recommendations
  • Daily curated briefings based on recently saved content
  • Rate limiting and stronger production security

The long-term vision is not just an AI bookmark manager. It is a way to turn the resources you keep SAVING into something you can actually RETRIEVE and use when you need them.

Built With

Share this project:

Updates

Submission history