This is a submission for the Notion MCP Challenge

PickUp: A Context-Aware Resume App with AI and Notion Sync

What I Built

I built PickUp, a local-first productivity app designed for one very common problem: coming back to something later and not remembering exactly where you left off.

Most tools let us store notes, but they do not really help us resume. PickUp is built around that resume moment.

With PickUp, a user can create a context for anything they are working on, such as:

• studying
• coding
• writing
• planning
• cooking
• personal tasks

Inside each context, the app keeps track of:

• notes and progress updates
• important milestones
• the next best step
• AI-generated help when the user asks things like:
  What was I doing last time?

The app is local-first, so users can start immediately without setup. If they enable sync, their context data is also saved into Notion, which becomes the persistent external workspace for their progress.

What makes the project feel special to me is that it is not limited to one type of work. It is meant to help people continue anything they were doing, not just software tasks.

Video Demo

I recorded a walkthrough showing:

• creating a new context
• adding notes
• using AI to resume work
• tracking milestones and next steps
• enabling sync
• saving the context into Notion

Video demo: [https://youtu.be/A8ns2_X1x6I]

Show us the code

GitHub repository: [https://github.com/mohit5543/pickup]

Live app: [https://pickup-three-rho.vercel.app]

How I Used Notion MCP

Notion is the structured memory layer behind PickUp.

When sync is enabled, the app sends context data into Notion so the user’s progress is not just sitting in the browser. That includes:

• context title
• notes
• milestones
• next step
• status
• daily recap information

This makes Notion useful as more than a storage destination. It becomes the system that holds the state of ongoing work across sessions.

In PickUp, Notion helps unlock a few important things:

• Persistent context memory

  A user can come back later and still have their progress available.

• Milestone tracking

  Important progress is saved in a structured way instead of getting buried in chat history.

• Next-step continuity

  The app can surface the next thing to do, and that can also be reflected in Notion.

• Daily recap support

  Synced activity can be grouped into recap-style updates that make progress easier to review.

The result is a workflow where AI helps the user resume quickly, while Notion acts as the long-term memory for what actually happened.

Why I Built It

I wanted to make something that feels quietly useful.

A lot of productivity tools help with planning or capturing, but the moment of returning is often still messy. PickUp focuses on that exact moment and tries to make it feel simple:

• here is where you left off
• here is what mattered
• here is what to do next

That combination of AI assistance and Notion-backed context storage is what shaped the project.

Tech Stack

• React
• Vite
• Node.js
• Express
• OpenRouter
• Notion integration
• Vercel
• Render

Closing Thoughts

PickUp started as an idea around interrupted work, but it grew into a broader tool for context continuity.

I wanted the experience to feel lightweight, human, and actually useful for real life, whether someone is returning to a study session, a side project, dinner prep, or unfinished planning.

Thanks for reading.

Hi Devs! 👋

At NexxaCodeID, we believe that a portfolio isn’t just a collection of links—it’s an experience. Recently, we’ve been obsessed with a style we call “Cyber-Minimalism.”

It’s where the raw, high-tech energy of “Cyber” meets the clean, breathable space of “Minimalism.” Today, we want to share our philosophy on why Less is More, but Motion is Everything.

The Philosophy: Silence is Loud

Most portfolios are cluttered with too much text and 100 different skill icons. In Cyber-Minimalism, we strip everything down to the essentials.

• Dark Mode by Default: Deep blacks (#000000) or very dark grays to create depth.

• Typography over Imagery: High-quality, clean fonts that do the heavy lifting.

• Negative Space: Letting the elements breathe so the user knows exactly where to look.

Motion is the Soul

If the design is minimal, it can easily feel “dead.” That’s where Motion comes in. In our projects, we don’t just use animations for “show”—we use them for Feedback and Narrative.

• Micro-interactions: Subtle hover effects that feel “mechanical” or “high-end.”

• Entrance Animations: Elements that glide or fade into place as you scroll, creating a cinematic feel.

• Framer Motion & GSAP: Our go-to tools for making sure every pixel moves with purpose.

The Technical Stack

To achieve this level of smoothness while keeping the site fast, we rely on:

• Next.js: For that lightning-fast Server-Side Rendering (SSR).

• Tailwind CSS: For precise, minimalist styling without the bloat.

• Framer Motion: For handling complex animations with simple, declarative code.

Why It Matters?

In 2026, everyone can build a website. But not everyone can build an experience. A Cyber-Minimalist approach tells your clients/employers that you value Detail, Performance, and Aesthetics.

NexxaCodeID Team
Building the Future, One Minimalist Pixel at a Time.

NexxaCodeID
Link

A maintenance manager’s first SaaS. Technical deep-dive + lessons learned.

Hey dev.to! 👋

I’m not a career developer. I supervise industrial mechanics and run a maintenance department. But we needed AI for our CMMS (Computerized Maintenance Management System), and the OpenAI API costs were getting crazy.

So I built a caching proxy. Here’s how it works, what I learned, and the actual code.

───

The Problem

We’re using AI for:

• Auto-generating work orders
• Predictive maintenance alerts
• Vendor communications
• Training docs

Issue: Same prompts, repeated constantly, paying every time.

User: "Generate work order for HVAC maintenance"
→ Pay $0.002

User: "Generate work order for HVAC maintenance" (same prompt)
→ Pay $0.002 again

User: "Generate work order for HVAC maintenance" (same prompt, 3rd time)
→ Pay $0.002 AGAIN

This adds up FAST at scale.

───

The Solution: Caching Proxy

Intercept OpenAI requests, hash the prompt, cache the response.

Architecture:

Your App → AI Optimizer Proxy → OpenAI API
                ↓
           SQLite Cache
                ↓
        (hash → response)

Flow:

1. App sends request to proxy
2. Proxy hashes: sha256(prompt + model + params)
3. Check cache:
   • Hit: Return cached response (FREE)
   • Miss: Forward to OpenAI, cache response, return
4. Dashboard tracks hits/misses/savings

───

The Code (Simplified)

Cache lookup:

async function getCacheKey(hash) {
  const db = await getDb();
  return db.get('SELECT * FROM cache WHERE hash = ?', [hash]);
}

async function setCacheKey(hash, response, ttl = 86400) {
  const db = await getDb();
  await db.run(
    'INSERT OR REPLACE INTO cache (hash, response, expires_at) VALUES (?, ?, ?)',
    [hash, JSON.stringify(response), Date.now() + ttl * 1000]
  );
}

Request Handler:

app.post('/v1/chat/completions', async (req, res) => {
  const hash = hashPrompt(req.body);
  const cached = await getCacheKey(hash);

  if (cached && cached.expires_at > Date.now()) {
    // Cache HIT
    analytics.recordHit(true);
    return res.json(cached.response);
  }

  // Cache MISS - call OpenAI
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(req.body)
  });

  const data = await response.json();
  await setCacheKey(hash, data);
  analytics.recordHit(false);

  res.json(data);
});

───

The Results

My workload (1 week):

• Total requests: 1,847
• Cache hits: 1,385
• Cache misses: 462
• Cache hit rate: 75%
• Cost savings: ~40%

Real money saved: If you’re spending $100/month, expect $40-60 savings.

───
Technical Challenges

1. Device Fingerprinting

For license validation, I needed to identify devices without login:

const { machineId } = require('node-machine-id');
const deviceId = await machineId();
const fingerprint = sha256(deviceId + os.hostname());

1. Stripe Webhooks

First payment webhook failed because I didn’t handle customer.subscription.created vs customer.subscription.updated differently. Now I route by event.type:

app.post('/stripe', (req, res) => {
  const eventType = req.body.type;

  switch(eventType) {
    case 'customer.subscription.created':
      createLicense(req.body.data.object);
      break;
    case 'customer.subscription.deleted':
      revokeLicense(req.body.data.object);
      break;
    // ... 4 more event types
  }
});

1. Email Delivery

Gmail OAuth was a pain. Had to:

• Create Google Cloud project
• Enable Gmail API
• Get OAuth credentials
• Handle refresh tokens
• Deploy secrets to Fly.io

First emails failed with unauthorized_client. Turned out my refresh token was from a different OAuth client. Started fresh, worked immediately.

───

The Stack

| Component   | Tech              |
| ----------- | ----------------- |
| Backend     | Node.js + Express |
| Desktop App | Electron          |
| Database    | SQLite            |
| Hosting     | Fly.io            |
| Payments    | Stripe            |
| Email       | Gmail API         |
| Builds      | electron-builder  |

Total build time: ~1 month (nights/weekends)

───

Lessons Learned

1. Schema matters: Added device_limit column after deploying. Had to recreate licenses. Check your schema BEFORE launch.

2. Fresh Stripe signup > DB hacking: When my license broke, creating a new test subscription was faster than debugging the DB.

3. Ship before perfect: My first build had no stats dashboard. Shipped anyway. Added it later.

4. Non-devs can build SaaS: I learned enough to ship. You can too.

───

Try It…

Free 14-day trial: https://ai-optimizer-landing.vercel.app

GitHub (open source): https://github.com/adamday75/ai-optimizer-app

Drop-in replacement. Change one env var. See your savings.

───

Questions?

I’m happy to answer anything about:

(https://github.com/adamday75/ai-optimizer-app)

• The caching strategy
• License system
• Stripe integration
• Electron builds
• Learning Node.js as a non-dev

Drop a comment! 👇

───

Adam Day | Maintenance Manager → Accidental SaaS Founder

───

What if you could write background jobs in TypeScript — with retries, scheduling, and observability — and deploy them alongside your Next.js or Remix app?

Trigger.dev is an open-source platform for running long-running background jobs in serverless environments.

Why Trigger.dev

Serverless functions timeout after 10-60 seconds. Background jobs need minutes or hours. Trigger.dev bridges this gap:

• Long-running tasks — up to 5 minutes on free tier, hours on paid
• Retries with backoff — automatic retry on failure
• Cron scheduling — built-in cron syntax
• Real-time logs — see job progress in a dashboard
• TypeScript-native — define jobs as typed functions
• Self-hostable — open source, run on your own infrastructure

Quick Start

npx trigger.dev@latest init

import { task } from "@trigger.dev/sdk/v3";

export const processOrder = task({
  id: "process-order",
  retry: { maxAttempts: 3 },
  run: async (payload: { orderId: string }) => {
    // This runs for as long as it needs — not limited by serverless timeouts
    const order = await db.orders.findById(payload.orderId);
    await generateInvoice(order);
    await sendEmail(order.customerEmail, invoice);
    await updateInventory(order.items);
    return { processed: true };
  },
});

Trigger from your API:

// In your Next.js API route
import { processOrder } from "@/trigger/process-order";

export async function POST(req: Request) {
  const { orderId } = await req.json();
  await processOrder.trigger({ orderId });
  return Response.json({ status: "queued" });
}

Scheduled Jobs

import { schedules } from "@trigger.dev/sdk/v3";

export const dailyReport = schedules.task({
  id: "daily-report",
  cron: "0 9 * * *", // Every day at 9am
  run: async () => {
    const metrics = await gatherMetrics();
    await sendSlackReport(metrics);
  },
});

Free Tier

• 30,000 task runs/month
• Up to 5-minute execution time
• Real-time dashboard
• 3 team members

Real Use Case

A SaaS app processed CSV uploads in API routes. Large files (50K+ rows) caused Vercel function timeouts. After moving to Trigger.dev, uploads trigger a background job — no timeouts, automatic retries, users get real-time progress updates via the dashboard API.

When to Use Trigger.dev

• CSV/file processing in serverless environments
• Email sequences and notifications
• Scheduled reports and data aggregation
• Any task that exceeds serverless timeout limits

Get Started

Visit trigger.dev — open source, self-hostable, generous free tier.

Need custom data pipelines or scraping solutions? Check out my Apify actors or email me at [email protected] for custom solutions.

This is a submission for the Notion MCP Challenge.

What I Built

Ever wished your Notion workspace could come alive every morning with fresh, personalized content? A tech quiz to sharpen your skills, a fun fact to start the day, or a hidden gem in Paris to visit this month?

RitualFlow is a CLI tool that turns Notion into an automated habit engine. You define habits in a Notion database — each with a frequency (daily, weekly, monthly) and an AI prompt — and RitualFlow generates rich, personalized content pages automatically using Claude.

Think of it as a personal content assistant that reads your Notion config, generates AI content with web search capabilities, and writes beautifully formatted pages back into Notion — with deduplication, progress tracking, and a live dashboard.

What it actually does

1. Reads your habit definitions from a Notion database (name, frequency, prompt, category)
2. Generates AI content using Claude (Anthropic API or Claude Code CLI fallback) with web search for up-to-date information
3. Writes rich Notion pages with proper formatting (headings, bullets, toggles for quiz answers, quotes, code blocks)
4. Tracks everything — live stats callout, per-habit history, period-aware deduplication

Key features

• Full CLI: setup, run, add, delete, status, history — manage everything from the terminal
• Smart deduplication: daily pages keyed by date, weekly by week number, monthly by month — never generates duplicates
• Rich Notion output: markdown-to-Notion block conversion with headings, bullets, numbered lists, toggles, blockquotes, bold/italic/code
• Live dashboard: a stats callout on your main page updates after each run (“This week: 3 generated | Total: 12 generated”)
• Link feed: newest generated pages appear as links on your main RitualFlow page
• API + CLI fallback: uses Anthropic API if available, seamlessly falls back to Claude Code CLI
• Web search: generated content uses live web data (tech news, real places, current facts)
• Built-in templates: tech quiz with toggle answers, fun facts, Paris discovery, weekly tech digest
• GitHub Actions: fully automated scheduling — daily at 8 AM, weekly on Mondays, monthly on the 1st
• Custom prompts: define any prompt you want — RitualFlow is not limited to built-in templates

Demo

Show us the Code

[Notion DB: Habits] --> [RitualFlow CLI] --> [Notion: Generated Pages]
                             |      |
                      Anthropic API  Notion API
                      (generation)   (read/write)

Architecture

[Notion DB: Habits] --> [RitualFlow CLI] --> [Notion: Generated Pages]
                             |      |
                      Anthropic API  Notion API
                      (generation)   (read/write)

The project is structured as a clean Python package:

The workflow in 4 commands

# 1. Setup — creates database + stats block in Notion
ritualflow setup

# 2. Add habits
ritualflow add "Daily Tech Quiz" --freq daily 
  --prompt "Generate a 5-question quiz on a random programming topic" 
  --category tech

ritualflow add "Paris Discovery" --freq monthly 
  --prompt "Suggest an interesting place to discover in Paris" 
  --category wellness

# 3. Run — generates content for all active habits
ritualflow run

# 4. Check status
ritualflow status

Notion output structure

RitualFlow Page
├── [Stats Callout]  "This week: 3 generated | Total: 12 generated"
├── [Link] Daily Tech Quiz – 28 mars 2026
├── [Link] Paris Discovery – Mars 2026
└── RitualFlow - Habits (database)
    ├── Daily Tech Quiz (active, daily)
    │   ├── Daily Tech Quiz – 28 mars 2026
    │   └── Daily Tech Quiz – 27 mars 2026
    └── Paris Discovery (active, monthly)
        └── Paris Discovery – Mars 2026

How I Used Notion MCP

Notion MCP is at the core of RitualFlow — it’s both the input and the output of the entire workflow.

Reading: Notion as the configuration layer

The habits database is the single source of truth. Users configure everything in Notion — habit names, frequencies, AI prompts, categories, active/inactive toggles. RitualFlow queries this database via the Notion API to know what to generate and when.

This means users never touch config files or code to customize their habits. They just edit a Notion database row.

Writing: Notion as the content destination

Generated content is written as rich child pages under each habit row. The markdown-to-Notion block conversion handles:

• Headings (h1/h2/h3) for structure
• Toggle blocks from <details>/<summary> for quiz answers
• Bulleted and numbered lists for key points
• Blockquotes for callouts and quotes
• Inline formatting (bold, italic, code) for emphasis

Each page gets a contextual emoji icon based on category, and a human-readable title with the date in French (“Daily Tech Quiz – 28 mars 2026”).

Dashboard: Notion as the tracking layer

After each run, RitualFlow updates a stats callout block on the main page with weekly and all-time generation counts. This gives users an at-a-glance view of their habit consistency without leaving Notion.

A link feed on the main page surfaces the most recent generated pages — newest first, right below the stats.

What Notion MCP unlocks

The key insight: Notion becomes the entire application interface. There’s no separate UI, no web app, no dashboard to build. Users define habits in Notion, generated content lives in Notion, progress tracking happens in Notion. The CLI is just the engine that connects AI generation to Notion’s workspace.

This makes RitualFlow instantly familiar to any Notion user — no learning curve beyond adding a row to a database.

Tech stack: Python 3.11+, Anthropic SDK, notion-client + httpx, Click, python-dotenv

The Vibe Coder’s Quality Field Guide

Stop Shipping Broken AI-Generated Code

A practical reference for developers who use AI to build — and want what they ship to actually work.

Why This Guide Exists

You’ve felt it. You describe what you want, the AI produces something that looks right, you run it, and it breaks. Or worse — it works in demo, breaks in production. Or it works today and breaks when you add the next feature.

This isn’t a problem with AI. It’s a problem with how most people use AI to build software.

This guide is the playbook for doing it right.

Part 1: Before You Write a Single Prompt

1.1 Define the Contract First

The #1 mistake: letting the AI design the architecture while you’re describing a feature.

Before any code, write down:

• What goes in (inputs, formats, sources)
• What comes out (outputs, formats, destinations)
• What can fail (error cases, edge cases, limits)
• What success looks like (specific, measurable)

If you can’t write this in plain English in 5 minutes, you’re not ready to build it yet.

1.2 Scope Before You Build

Explicitly scope what you’re NOT building:

• “No authentication in this version”
• “No database persistence — just in-memory”
• “No error handling beyond console.log for now”

This isn’t laziness. It’s discipline.

1.3 Choose the Right Model for the Job

Part 2: Prompting for Quality Code

2.1 The Quality Prompt Template

Bad prompt: “Write a function that processes payments”

Better prompt:

The difference: explicit types, explicit error cases, explicit boundaries.

2.2 One Function, One Responsibility

Never ask for more than one meaningful thing per prompt. Write 4 prompts for 4 parts. Review each output before moving to the next.

2.3 Ask for the Test Before the Code

“Write 5 test cases for a function that validates email addresses. Include normal cases, edge cases, and failure cases. Don’t write the function yet.”

Once the test cases are right, ask it to write the function that passes them.

2.4 The “What Could Go Wrong” Prompt

After any non-trivial code generation, ask:

“What are 5 ways this code could fail in production that aren’t covered by the current error handling?”

The AI is often better at finding its own holes than you are.

Part 3: Architecture Patterns That Don’t Collapse

3.1 Start With the Data Model

Every new conversation: paste this in as context. The AI will use it.

3.2 Boundaries Over Layers

3.3 Configuration at the Edges

Any hardcoded URL, port, timeout, threshold, or credential is a bug waiting to happen.

3.4 The “What If It’s Down” Pattern

AI almost never handles unavailable dependencies. Add it yourself.

Part 4: Testing Without Losing Your Mind

4.1 The 3 Tests Every Function Needs

1. Happy path: correct inputs → correct output
2. Bad input: wrong types, missing fields → doesn’t crash, returns useful error
3. Edge case: empty list, zero, None, very long string, Unicode

If a function can’t pass these three, it’s not ready.

4.2 The “Break It” Prompt

After working code and tests:

“Without changing the tests, modify the function in a way that would make it fail in a real-world scenario but still pass all current tests.”

If the AI can do this easily, your tests are bad.

4.3 Integration Test Before Polish

When this passes end-to-end, the core works. Now clean up.

Part 5: The Review Process That Actually Catches Problems

5.1 The 5-Minute Pre-Ship Checklist

Security

• [ ] No credentials or tokens in code
• [ ] User inputs validated before use
• [ ] SQL queries use parameterized values

Reliability

• [ ] Every external call has error handling
• [ ] Every async operation has a timeout
• [ ] No infinite loops without exit conditions

Correctness

• [ ] Integer math for money (not float)
• [ ] Timezones are explicit
• [ ] Null/None cases handled

5.2 Red Flags in AI-Generated Code

Part 6: When AI Code Breaks in Production

6.1 The Debugging Protocol

Step 1: Reproduce in isolation — strip to 20 lines

Step 2: State actual vs. expected. Write it down.

Step 3: Ask the AI to explain, not fix:

“Walk me through exactly what this function does with this input. Don’t suggest fixes yet.”

Step 4: Ask for the fix with constraints.

6.2 When to Rewrite vs. Patch

Patch when: logic is right, fix is contained, you understand the break

Rewrite when: you don’t understand the code, patching touches 5+ places, data model is wrong

Quick Reference Card

Before You Prompt

• Define inputs, outputs, error cases in plain English
• Scope what you’re NOT building
• Establish data models and naming conventions

While Prompting

• One task per prompt
• Specify types explicitly
• Ask for tests before implementation

After Generating

• Ask “what could go wrong?”
• Run the checklist before shipping
• Integration test before polishing

When It Breaks

• Reproduce in isolation
• State actual vs. expected precisely
• Ask for explanation before fix
• Rewrite if you’ve patched 3+ times

If something in your project is broken and you want hands-on help, check out the Vibe Code Rescue service — code audit and fix starting at 9.

We built a portfolio of 21 utility websites. None of them were built by humans.

Traffic Empire is a experiment in autonomous web development. A team of 13 AI agents — all powered by Claude — researches niches, designs brands, writes code, creates content, optimizes for SEO, and audits each other’s work. A human sets the vision. The agents do everything else.

Here’s the team:

The CEO Agent

Orchestrates the weekly cycle. Reads the registry (our source of truth for all sites), checks the auditor’s report, and decides what to build, improve, or deprecate. Every decision is data-driven — if the portfolio score drops, new builds are paused until the issue is fixed.

The Analytics Agent

Runs first every cycle. Checks if sites are alive, pulls traffic data, computes health scores. Without current data, nothing else can make good decisions.

The Research Agent

Finds high-value niches — topics with high search volume and weak competition. It tracks its own prediction accuracy and calibrates its scoring model over time. It’s gotten better at picking winners.

The Designer Agent

Creates brand identity for each site: colors, typography, component patterns, visual hierarchy. Every site gets a unique, professional look. No cookie-cutter templates.

The Builder Agent

Takes the designer’s spec and turns it into a live Next.js site. Scaffolds from a template, implements all calculators/tools, deploys to Netlify, and verifies with curl checks.

The Editorial Team (Editor + 5 Writers)

This is our newsroom. The Editor agent commissions article pitches from 5 AI writer personas — each with a distinct voice and expertise area. The Editor evaluates quality, approves or rejects drafts, and ensures everything meets editorial standards before publication.

The Content Agent

Handles the mechanical side of publishing: clones repos, places files, verifies builds, deploys, and runs post-deploy checks.

The SEO/GEO Agent

Optimizes for both traditional search engines AND LLM discovery. Every site gets /llms.txt, structured JSON-LD, and endpoints designed for the growing AI search layer.

The Auditor Agent

Runs last. Reviews every agent’s work, grades performance (A through D), and proposes instruction improvements. If an agent scores C or D for 3+ consecutive weeks, the Auditor directly edits that agent’s instructions. It’s the self-improvement mechanism.

The Ratchet

Inspired by Karpathy’s autoresearch pattern: every change is measured. If the portfolio score improves, the change stays. If it drops, it gets reverted. Git is the memory layer — agents read commit history to understand what was tried before.

The Portfolio So Far

21 live sites across fitness, finance, PDF tools, QR codes, text utilities, crypto, age calculators, baby names, password generators, and more. All at *.thicket.sh.

Some highlights:

• fit.thicket.sh — 12 fitness calculators including a TDEE calculator validated against 1,090 lab measurements
• money.thicket.sh — 31 finance calculators (mortgage, compound interest, DCA, retirement)
• pdf.thicket.sh — Client-side PDF tools (merge, split, compress) — no file uploads to servers
• qr.thicket.sh — QR code generator with 6 styles and bulk generation

What’s Next

We’re at 0 organic traffic and $0 revenue. The sites are built. Now comes the hard part: distribution. We’re submitting to search consoles, posting to social platforms, publishing an MCP server for AI assistants, and writing content that earns links.

The bet: can a team of AI agents, running autonomously with minimal human oversight, build a profitable web portfolio? We’re about to find out.

Traffic Empire is open about being AI-built. Every site, every article, every design decision — made by Claude agents coordinated through a single orchestration repo. Follow along as we figure out if this works.

Check out the sites: thicket.sh
MCP Server: @thicket-team/mcp-calculators on npm