DEV Community: Pooya Golchian

The 200-result ceiling that forced a tiled crawler

Pooya Golchian — Sat, 12 Sep 2026 19:59:31 +0000

One Google Maps query stops at roughly 200 results. Every other decision in this pipeline falls out of that single number.

I live in Dubai. Google Maps knows every plumber, nursery and blood-test lab in the city. No tool lets me browse that, filter it, or ask a structural question of it.

So I built one. Business Directory Toolkit is MIT-licensed and turns a city into a browsable business directory. directory.pooyagolchian.com is a live Dubai deployment standing on 1,400 requests to SearchApi's Google Maps engine. I am writing it up as part of their developer ambassador programme. That programme backs developers who ship something real on their APIs and leaves the work in your name.

1,400 SearchApi requests returned 15,246 unique businesses. That is 10.9 new businesses per request.

Most articles about scraping Google Maps stop at one API call and a console.log. That part already works. Everything expensive happens after it.

The ceiling that shapes everything

A single Google Maps query cannot enumerate a city. Page 11 does not come back as an empty list. It comes back with no local_results key at all, so the results are absent rather than empty. I committed that probe to the repository as a test fixture so nobody has to spend a credit rediscovering it.

If you were expecting 60, that is the ceiling on the Places API Text Search, which returns 20 results across three pages and stops. The Maps engine goes considerably deeper before it gives out. It still gives out, and that ceiling decides how you build.

Tiling forces a budget model

Tiling is mandatory, not an optimisation. Dubai is 44 geographic squares crossed with 40 categories, which makes 1,760 tile-and-category pairs. Pagination depth is the only dial that moves the bill.

SearchApi fits that shape for structural reasons rather than promotional ones. It takes Google's own location format straight through, as ll=@lat,lng,zoom. Tiling a city means expressing a coordinate and a zoom level, so no geocoding service sits in the middle.

One SearchApi request costs one credit. Because the unit of billing matches the unit of work, the whole cost model collapses into a 3x3 lookup table. Budget guards only work because the arithmetic stays that simple.

The response also carries fields that replace other services. Roughly 99.8% of results arrive with country_code and city, which drives the in-city filter with no geocoder. Every single result carries gps_coordinates.

The pipeline reassigns each business to the tile it actually sits in rather than the one whose query found it. About half of them sat somewhere other than where I looked, because Google answers from a radius.

place_id arrives on 100% of results and stays stable. It is the dedup key, the database partition key, and the only value the takedown suppression list may hold.

Failure is predictable enough that the retry policy fits in one predicate.

/**
 * Rate limits and server errors are worth retrying; a 400 or a 401 will fail
 * identically forever and retrying only burns time and credits.
 */
export function isRetryable(status: number): boolean {
  return status === 429 || status >= 500;
}

A 400 throws immediately, which is correct, because a malformed query does not improve on the fourth attempt.

Price it before you buy

Five commands are the required spine, and only one of them spends money on the corpus.

Plan the crawl. It costs nothing, issues nothing and writes nothing.

pnpm plan --city dubai

It prints 1,250 first-page jobs against a 3,170 worst case and a 2,000 default budget. It also warns that full depth overruns by 1,170. The planner drops 510 of the 1,760 pairs before committing a single credit. Crawling law firms in the desert spends money to find nothing.

The only irreversible spend

Crawl. This is the only irreversible spend in the project, so it refuses to run without --yes.

pnpm crawl --dry-run
pnpm crawl --city dubai --yes --budget 200

Four guards stack here. The mandatory flag, the free dry run, a hard budget stop, and the plan-time drops. A fifth brake sits inside the crawl loop, and it is four lines of arithmetic.

export function shouldFetchNextPage(
  outcome: PageOutcome,
  minNewUniqueRatio = DEFAULT_MIN_NEW_RATIO, // 0.3
): boolean {
  if (outcome.page >= outcome.maxPages) return false;
  if (outcome.resultCount === 0) return false;
  if (outcome.resultCount < FULL_PAGE) return false;   // FULL_PAGE = 20
  return outcome.newUnique / outcome.resultCount >= minNewUniqueRatio;
}

The crawler buys a page only when the previous page came back full and at least 30% of it was new. Every constant in there came from a measurement rather than a guess.

The crawler also writes every raw response to disk before anything parses it. That habit is the single best decision in the project, and I will come back to why.

Classify the vocabulary, not businesses

The taxonomy pass turns a scrape into a directory, and it costs almost nothing. This is the step that makes the unit economics work.

Seed the taxonomy. No model call, no network, no credits.

pnpm seed-taxonomy

132 ordered keyword rules classify the head of the category vocabulary.

Classify the tail. This spends Anthropic tokens and never SearchApi credits.

pnpm classify --yes

The idea worth stealing comes next. The obvious approach sends every business to a model, which scales with your dataset forever. Category vocabulary saturates while business count does not.

My 15,246 businesses contained only 1,787 distinct category strings, which is 8.5 times fewer items. The keyword rules handle the head, so the model only ever sees a tail of 537 strings. It sees them once, across every crawl this project will ever run. A re-crawl that introduces no new strings prints a marginal cost of zero and exits.

Handle the head deterministically and the model never sees 99.5% of your corpus. The committed map wins over both the rules and the model, so the taxonomy is permanent. The next crawl re-applies it for free, and so does the next city.

Thin pages stay out of it. A category needs at least three businesses in a neighbourhood before that page exists at all.

Four gates measure, one does not

Load. Dedupe, drop suppressed listings, assign each business to its nearest tile by coordinates, then normalise.

pnpm load --dry-run
pnpm load --yes

Five acceptance gates print on every run.

at least 10,000 unique businesses
90% phone coverage
99% taxonomy coverage
unique slugs
zero rows outside the country

My crawl passes at 92.2% phone coverage and 99.5% taxonomy coverage. Four of those five gates measure something. The fifth prints a pass because normalise already rejects out-of-country rows, so it restates an invariant rather than testing one.

Two of those thresholds started higher and came down on evidence. I wanted 95% phone coverage. A probe of the detail endpoint across 15 businesses recovered exactly one extra number. The parser rejected it correctly as an Indian number. So 92.2% is a ceiling, not a shortfall, and the gate now says so.

One crawl produced 14,981 business pages, 782 neighbourhood-by-category landing pages, 81 category pages and 40 neighbourhood hubs. That is 15,887 URLs in the sitemap, all from a single dataset.

Optional passes sit after the spine. pnpm demand asks google_autocomplete what people actually search, at one credit per category, ordered by real query popularity. That turns "which pages should I build" from a guess into a measurement. pnpm leads scores prospects. pnpm export writes CSV, JSON or NDJSON for a CRM.

20,226 review snippets nearly shipped

Because the crawler stores every response untouched before parsing, everything downstream is free to re-run.

pnpm load --from-archive

No network, no credits, full rebuild. I changed the taxonomy, the ranking constants and the normalisation repeatedly over weeks, all against one paid crawl. The test suite runs against committed fixtures and spends nothing.

That archive also produced the ugliest moment in the project. A single unresolvable path in the data loader made Next's file tracer give up and wildcard the directory. That put 1,400 raw crawl files inside the deployment bundle, carrying 20,226 verbatim Google review snippets. Some of them named individual employees. Nothing read them and all of them would have shipped.

The related bug is worse and more interesting. Review theme extraction rewards terms frequent for one business and rare everywhere else, which is precisely the shape of a staff member's name. The first live run produced a Sofitel listing tagged with three employees' first names. A blocklist would have been endless. The fix is a property instead, since a real theme recurs across many businesses while a person's name belongs to one.

Theme extraction reruns against the archive, so the fix never needed a fresh crawl.

My tests sat green throughout. Every headline defect in this repository turned up the same way, by reading real output rather than by failing an assertion. That is the argument for building against a city you already know. Business Directory Toolkit had a real target from day one. When the crawler came back with a couple of hundred nurseries, I could tell whether that smelled right.

What the live demo does

directory.pooyagolchian.com runs on CloudFront as prerendered pages.

A query for dentist returns 512 matches. Typing a +971 number returns the business that owns it. Typeahead answers from a JSON endpoint in one round trip. Business pages carry LocalBusiness structured data, a canonical, and both phone formats. An honest label says the rating came from Google rather than from me.

Some things genuinely do not exist yet. The site has no pagination, so large categories cap at 120 rendered rows and disclose it in plain text. Sorting filters what is already on the page rather than querying the server. I wrote the DynamoDB path and nothing reads it. I would rather say that than let you find out by clicking.

The lead score ranked ATMs

One crawl produces two products. The 1,400 requests that built a public website also built four prospect lists, offline, at zero marginal cost. That is one acquisition cost against two outputs, and it is the only version of the growth-engine claim I will defend.

The second product nearly shipped broken, and the failure was mine. The scoring took two attempts.

The directory carries a chart I did not expect to build. Median review count climbs with rating exactly as you would hope. The bands run 12, 18, 48, 93 and 139. Then it collapses to 11 at exactly 5.0. 2,283 Dubai businesses hold a perfect score, and the typical one has eleven reviews behind it. A perfect score is the bottom of the evidence, not the top of the scale. Listings therefore rank on a credibility-weighted mean instead of a raw average.

My first lead score reused that same credibility-weighted rating, which sounds sensible and inverts itself in practice. Across 641 real leads the score correlated with review count at negative 0.28. The more trade a business had, the further down my call sheet it went. Bank ATMs topped the list. A 3.6-rated hospital with 5,562 reviews sat at number 522 of 641.

The fix generalises into one rule worth stealing. The health term must never be a function of the quantity the signal measures. Score on establishment instead, and the correlation flips to positive 0.08.

pnpm leads scores against four signals, which are no-website, no-hours, weak-reputation and low-visibility. Each signal maps to a different sales conversation, so the tool enforces one signal per run. On my Dubai corpus, 3,820 reachable prospects have no website and 892 have never published hours. Compose the filters and you get 321 restaurants with 20 or more reviews and no website, which is a web agency's afternoon.

Two caveats I will not bury. Reachable means the business has a phone number, so those counts run smaller than the raw count of businesses with the gap. And a lead list is research, not permission to contact anyone. The CLI prints that on every run.

Porting the crawl to Lisbon

The crawl is genuinely city-agnostic. Tiles, categories, bounding boxes, country code and phone region all live in one JSON file. Adding a city requires no code change.

pnpm cities generate --name "Lisbon"

That reads OpenStreetMap and writes the config at zero SearchApi cost. It refuses to fabricate, so a city with too few candidate centres throws rather than falling back to an even grid. Every generated config carries an unverified stamp until somebody actually crawls it. Verification stores evidence rather than a boolean, because a bare verified: true invites a flip, and producing a false one costs a real crawl.

The web layer still says Dubai in a few places, and so do a couple of CLI report labels. Porting the crawl is a data file. Porting the site is still a small patch, and I would rather write that down than imply otherwise.

What I am not claiming

I have proven the toolkit on exactly one city, and that run stopped after 18 of the 44 configured tiles. Even Dubai is not finished. I have taken no latency, Core Web Vitals, ranking or traffic numbers, so I am quoting none.

The repository ships the pipeline and never the corpus. Git ignores both the raw archive and the built dataset, and CI fails the build if either one lands in a commit. Running this requires your own key and your own crawl.

That last constraint is deliberate, and it is the part I find most interesting commercially. A toolkit that does nothing without a SearchApi key means every serious user opens an account. Shipping a hosted API or a paid dataset would have inverted that, because then I would hold the only key that mattered.

What to copy

Probe the ceiling first, then commit the probe. Page 11 of a Google Maps search returns no local_results key, and that fixture now costs nobody a credit.
Make the unit of billing the unit of work. One request equals one credit, so a 3x3 lookup table prints the invoice before you spend it.
Classify the vocabulary, not the rows. My 15,246 businesses held 1,787 distinct category strings, so the model saw a tail of 537 once.
Never let a health term depend on the quantity its signal measures. That one rule moved the lead score from negative 0.28 to positive 0.08.
Write every raw response to disk before you parse it. You pay for the call once, and every rebuild after that costs nothing. Then check what your bundler copies.

The code is on GitHub. Take the ranking, the phone parsing or the taxonomy pass on its own, since packages/core is pure and has no idea what a city is.

I originally published this at pooyagolchian.com.

dirham v1.3.0 — A Universal Web Component for the UAE Dirham Symbol

Pooya Golchian — Wed, 25 Mar 2026 19:01:43 +0000

The UAE Dirham now has an official Unicode codepoint — U+20C3 — accepted for Unicode 18.0. But operating systems won't ship native font support until September 2026.

dirham bridges that gap. It maps the official glyph to U+20C3 via a custom web font, so your content is semantically correct today and future-proof for when native support arrives.

What's new in v1.3.0

The headline feature is <dirham-price> — a Web Component that formats and displays Dirham amounts in any framework, no wrappers needed.

<script type="module" src="https://cdn.jsdelivr.net/npm/dirham/dist/web-component/index.js"></script>

<dirham-price amount="1250"></dirham-price>
<dirham-price amount="5000000" notation="compact"></dirham-price>
<dirham-price amount="500" use-code></dirham-price>

It supports 8 attributes: amount, locale, decimals, notation, use-code, symbol-size, weight, and currency.

Works everywhere

Vue:

<script setup>
import "dirham/web-component";
</script>

<template>
  <dirham-price amount="1250" />
  <dirham-price amount="5000000" notation="compact" />
</template>

Angular:

import { CUSTOM_ELEMENTS_SCHEMA, Component } from "@angular/core";
import "dirham/web-component";

@Component({
  schemas: [CUSTOM_ELEMENTS_SCHEMA],
  template: `<dirham-price amount="1250"></dirham-price>`
})
export class AppComponent {}

Svelte:

<script>
  import "dirham/web-component";
</script>

<dirham-price amount="1250"></dirham-price>

React still has dedicated components with full TypeScript support:

import { DirhamPrice } from "dirham/react";

<DirhamPrice amount={1250} />
<DirhamPrice amount={750} className="text-emerald-400 text-2xl" />

Full feature set

Feature	How
React SVG component	`<DirhamSymbol size={24} weight="bold" />`
React price component	`<DirhamPrice amount={1250} notation="compact" />`
Web Component (any framework)	`<dirham-price amount="1250">`
CSS web font	`<i class="dirham-symbol"></i>`
JS formatting	`formatDirham(1234.5)` → `℃ 1,234.50`
Parsing	`parseDirham("℃ 1,234.50")` → `1234.5`
Clipboard	`await copyDirhamSymbol()`
CLI	`npx dirham copy`
CDN	jsDelivr, zero install
9 weight variants	thin → black
5 font variants	sans, serif, mono, arabic, default
RTL support	Arabic locale with correct symbol placement

Why U+20C3?

Other approaches use Private Use Area hacks or plain text substitution. This package uses the officially assigned codepoint, which means:

Your content is semantically correct — search engines, screen readers, and parsers understand it
When Unicode 18.0 ships natively (Sep 2026), the web font gracefully becomes unnecessary — zero migration
The symbol behaves like $, €, and £ — it's a real currency character

Links

npm: npmjs.com/package/dirham
Live demo: pooya.blog/dirham
GitHub: github.com/pooyagolchian/dirham

npm install dirham

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

Pooya Golchian — Tue, 17 Mar 2026 17:57:42 +0000

Notion MCP Challenge Submission 🧠

Pooya Golchian

Mar 16

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

#ai #nextjs #typescript #notionchallenge

6 min read

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP 💥

Pooya Golchian — Mon, 16 Mar 2026 15:09:54 +0000

Notion MCP Challenge Submission 🧠

Pooya Golchian

Mar 16

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

#ai #nextjs #typescript #notionchallenge

6 min read

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

Pooya Golchian — Mon, 16 Mar 2026 15:09:38 +0000

Notion MCP Challenge Submission 🧠

Pooya Golchian

Mar 16

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

#ai #nextjs #typescript #notionchallenge

6 min read

RevOps AI. I Turned Notion into an AI-Powered CRM with Gemini and MCP

Pooya Golchian — Mon, 16 Mar 2026 12:49:07 +0000

A revenue operations platform where Gemini 2.5 Flash autonomously manages pipeline, scores leads, and drafts sales emails through Notion MCP. No CRM vendor lock-in. No proprietary databases. Just Notion.

What I Built

RevOps AI turns Notion into a full revenue operations platform. No Salesforce. No HubSpot. No proprietary database sitting between your team and their data.

Four Notion databases hold every contact, deal, activity, and company record. Google Gemini 2.5 Flash sits on top as an autonomous sales team member. It queries your pipeline, scores leads, drafts emails, generates pre-call briefings, and creates follow-up activities. All through natural language. All written back to Notion in real time.

The critical difference from other MCP integrations? Gemini doesn't follow hardcoded scripts. Through mcpToTool() from Google's GenAI SDK, the model receives all 22 Notion MCP tools and decides at runtime which ones to call. It reasons through multi-step operations the same way a senior sales ops analyst would, chaining searches, queries, and updates in a single response.

The Problem That Started This

Every sales team I've worked with runs into the same wall. Their CRM lives in one system. Their docs, meeting notes, and project management live in Notion. Two systems. Two sources of truth. Data drifts apart within weeks.

Salesforce runs $150/user/month. HubSpot locks you into their ecosystem. Meanwhile, the team already collaborates in Notion every day.

So I asked a simple question. What if Notion was the CRM? And what if an AI agent could operate it autonomously?

Key Features

AI Sales Team Manager. Ask "What's my pipeline health?" in plain English. Gemini queries your Notion databases, calculates win rates, and surfaces the insights that matter. Say "Create a follow-up for the Acme deal" and it creates the activity, linked to the right deal, without you touching a form. Think of it as a senior sales ops analyst available around the clock.

Revenue Dashboard. Total pipeline value, win rate, deal breakdown by stage, top deals, and recent team activity. Every metric pulls from Notion through MCP in real time. No stale data. No manual report building.

Visual Deal Pipeline. Drag-and-drop Kanban board with six stages, from Lead through Closed Won and Closed Lost. Every move syncs to Notion instantly via MCP. What your team sees in the app matches what they see in Notion. Always.

AI Lead Scoring. One click triggers Gemini to evaluate a contact's role seniority, company size, and engagement history, then assign a 0-100 score with written reasoning. That score persists back to the Notion Contacts database so your entire team sees it everywhere Notion surfaces.

Pre-Call Briefing Generator. Before any sales call, the AI pulls deal context, activity history, and contact data from Notion to build a structured brief. Talking points, likely objections, relationship timeline, and recommended next steps. All generated autonomously from your existing data.

Email Ghostwriter. Gemini drafts personalized sales emails based on the deal's stage, contact history, and recent activity. No generic templates. Each email reflects the actual context of the relationship.

Contact Management. Full CRUD with search, filtering by lead source, sortable columns, and inline AI scoring. Add new contacts directly from the UI. Everything writes to Notion through MCP.

Demo

Screenshots

Revenue Dashboard

Deal Pipeline (Kanban)

Deal Detail + AI Email Draft

Leads & AI Scoring

Companies

AI Sales Team Manager

Responsive across desktop, tablet, and mobile

Show Us the Code

GitHub Repository: https://github.com/pooyagolchian/ai-sales-crm

Application Flow

The Core Innovation, `mcpToTool()`

Most MCP integrations manually wire each API endpoint into the AI layer. RevOps AI eliminates that entire step with a single function call.

// src/lib/gemini.ts
import { GoogleGenAI, mcpToTool } from "@google/genai";
import { getMcpClient } from "./mcp-client";

export async function generateWithTools(
  prompt: string,
  systemPrompt?: string
): Promise<string> {
  const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
  const mcpClient = await getMcpClient();

  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: prompt,
    config: {
      tools: [mcpToTool(mcpClient)],         // All 22 Notion tools, auto-mapped
      systemInstruction: getCrmSystemPrompt(), // DB IDs + property names injected
    },
  });

  return response.text ?? "";
}

mcpToTool(mcpClient) auto-maps all 22 Notion MCP tools into Gemini function declarations. The system prompt injects actual database IDs and property names so Gemini skips the discovery phase entirely.

The result? Gemini autonomously decides which Notion operations to perform. Ask "What's my pipeline value?" and it calls API-query-data-source on Deals. Say "Log a meeting for Acme" and it calls API-post-page to create an Activity, then API-patch-page to update the deal. Zero hardcoded logic.

MCP Client, Singleton with Auto-Reconnect

// src/lib/mcp-client.ts
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

async function createClient(): Promise<Client> {
  const mcpClient = new Client({ name: "revops-ai", version: "1.0.0" });

  const transport = new StreamableHTTPClientTransport(
    new URL(process.env.MCP_SERVER_URL || "http://localhost:3001/mcp"),
    { requestInit: { headers: { Authorization: `Bearer ${authToken}` } } }
  );

  await mcpClient.connect(transport);
  return mcpClient;
}

Tech Stack

Layer	Technology
Framework	Next.js 15 (App Router), TypeScript (strict)
UI	Tailwind CSS v4, shadcn/ui, Lucide icons
AI	Google Gemini 2.5 Flash via `@google/genai` SDK
Data	Notion (4 databases) via MCP protocol
MCP	`@notionhq/notion-mcp-server` v2 (HTTP) + `@modelcontextprotocol/sdk`
DnD	`@dnd-kit/core` + `@dnd-kit/sortable`
Linting	Biome

How I Used Notion MCP

Notion isn't a supporting tool here. It is the entire database layer. No Postgres. No SQLite. No local storage. Every record lives in a Notion database, and every read and write goes through MCP.

Four Notion Databases

Database	Purpose	Key Properties
Contacts	Lead & customer profiles	Name, Email, Company, Role, Lead Score, Lead Score Notes, Source
Deals	Revenue pipeline items	Name, Contact (relation), Stage (6 values), Value, Close Date, Priority, Next Action
Activities	Sales touchpoints	Type (call/email/meeting/note), Date, Deal (relation), Summary, Raw Notes
Companies	Organization profiles	Name, Industry, Size, Website

MCP Operations Used

Every data operation routes through MCP.

API-query-data-source for querying databases with filters and sorts
API-post-page for creating new contacts, deals, and activities
API-patch-page for updating deal stages via Kanban drag-and-drop, persisting AI lead scores, and modifying Next Action fields
API-search for free-text search across the entire Notion workspace
API-retrieve-a-page for fetching full details used in deal briefings and AI assistant context

What Makes This Approach Different

Most MCP integrations hardcode which tools to call. RevOps AI hands the entire toolset to Gemini and lets it choose.

mcpToTool(mcpClient) auto-maps all 22 Notion MCP tools into Gemini function declarations with a single call. No manual schema writing. No tool definitions to maintain.

Autonomous multi-step reasoning means Gemini chains multiple MCP calls in one response. Ask "Brief me on the TechCorp deal" and it searches for the deal, queries related activities, retrieves the contact profile, and synthesizes a briefing. Four operations. One prompt. Zero hardcoded logic.

System prompt injection feeds the AI actual database IDs and exact property names from notion-schema.ts, so the model never wastes tool calls discovering database structure.

Notion stays the single source of truth. The team's data lives where they already collaborate. RevOps AI adds an intelligent layer on top without creating another data silo.

Why Notion MCP Specifically

This solves a real problem that traditional CRM architectures cannot.

Your data stays where your team already works. A marketing director opens Notion and sees every deal, contact, and activity in familiar views. Tables, kanban boards, calendars, galleries. They edit inline, add comments, share with stakeholders. No separate CRM login required.

The AI gets full context through a standard protocol. MCP gives structured access to query, create, update, and search, with proper schemas and typed inputs. This is a designed protocol, not screen scraping or brittle API hacks.

Zero vendor lock-in. Switch from Gemini to Claude or GPT? The MCP layer stays the same. Switch from Notion to another MCP-compatible tool? The AI integration pattern stays the same. MCP decouples the AI from the data source.

The cost is essentially zero. Notion's free plan supports databases. Gemini 2.5 Flash has a generous free tier via Google AI Studio. The MCP server is open source. A startup's first RevOps stack can run at $0.

Built with Notion MCP, Google Gemini 2.5 Flash, and Next.js 15. Because revenue operations shouldn't require a $150/seat CRM when your team already lives in Notion.

RevOps AI. I Turned Notion into an AI-Powered CRM with Gemini and MCP

Pooya Golchian — Mon, 16 Mar 2026 12:43:06 +0000

What I Built

RevOps AI turns Notion into a full revenue operations platform. No Salesforce. No HubSpot. No proprietary database sitting between your team and their data.

The Problem That Started This

Salesforce runs $150/user/month. HubSpot locks you into their ecosystem. Meanwhile, the team already collaborates in Notion every day.

So I asked a simple question. What if Notion was the CRM? And what if an AI agent could operate it autonomously?

Key Features

Contact Management. Full CRUD with search, filtering by lead source, sortable columns, and inline AI scoring. Add new contacts directly from the UI. Everything writes to Notion through MCP.

Demo

Screenshots

Revenue Dashboard

Deal Pipeline (Kanban)

Deal Detail + AI Email Draft

Leads & AI Scoring

Companies

AI Sales Team Manager

Responsive across desktop, tablet, and mobile

Show Us the Code

GitHub Repository: https://github.com/pooyagolchian/ai-sales-crm

Application Flow

The Core Innovation, `mcpToTool()`

Most MCP integrations manually wire each API endpoint into the AI layer. RevOps AI eliminates that entire step with a single function call.

// src/lib/gemini.ts
import { GoogleGenAI, mcpToTool } from "@google/genai";
import { getMcpClient } from "./mcp-client";

export async function generateWithTools(
  prompt: string,
  systemPrompt?: string
): Promise<string> {
  const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
  const mcpClient = await getMcpClient();

  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: prompt,
    config: {
      tools: [mcpToTool(mcpClient)],         // All 22 Notion tools, auto-mapped
      systemInstruction: getCrmSystemPrompt(), // DB IDs + property names injected
    },
  });

  return response.text ?? "";
}

MCP Client, Singleton with Auto-Reconnect

// src/lib/mcp-client.ts
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

async function createClient(): Promise<Client> {
  const mcpClient = new Client({ name: "revops-ai", version: "1.0.0" });

  const transport = new StreamableHTTPClientTransport(
    new URL(process.env.MCP_SERVER_URL || "http://localhost:3001/mcp"),
    { requestInit: { headers: { Authorization: `Bearer ${authToken}` } } }
  );

  await mcpClient.connect(transport);
  return mcpClient;
}

Tech Stack

Layer	Technology
Framework	Next.js 15 (App Router), TypeScript (strict)
UI	Tailwind CSS v4, shadcn/ui, Lucide icons
AI	Google Gemini 2.5 Flash via `@google/genai` SDK
Data	Notion (4 databases) via MCP protocol
MCP	`@notionhq/notion-mcp-server` v2 (HTTP) + `@modelcontextprotocol/sdk`
DnD	`@dnd-kit/core` + `@dnd-kit/sortable`
Linting	Biome

How I Used Notion MCP

Notion isn't a supporting tool here. It is the entire database layer. No Postgres. No SQLite. No local storage. Every record lives in a Notion database, and every read and write goes through MCP.

Four Notion Databases

Database	Purpose	Key Properties
Contacts	Lead & customer profiles	Name, Email, Company, Role, Lead Score, Lead Score Notes, Source
Deals	Revenue pipeline items	Name, Contact (relation), Stage (6 values), Value, Close Date, Priority, Next Action
Activities	Sales touchpoints	Type (call/email/meeting/note), Date, Deal (relation), Summary, Raw Notes
Companies	Organization profiles	Name, Industry, Size, Website

MCP Operations Used

Every data operation routes through MCP.

API-query-data-source for querying databases with filters and sorts
API-post-page for creating new contacts, deals, and activities
API-patch-page for updating deal stages via Kanban drag-and-drop, persisting AI lead scores, and modifying Next Action fields
API-search for free-text search across the entire Notion workspace
API-retrieve-a-page for fetching full details used in deal briefings and AI assistant context

What Makes This Approach Different

Most MCP integrations hardcode which tools to call. RevOps AI hands the entire toolset to Gemini and lets it choose.

mcpToTool(mcpClient) auto-maps all 22 Notion MCP tools into Gemini function declarations with a single call. No manual schema writing. No tool definitions to maintain.

System prompt injection feeds the AI actual database IDs and exact property names from notion-schema.ts, so the model never wastes tool calls discovering database structure.

Notion stays the single source of truth. The team's data lives where they already collaborate. RevOps AI adds an intelligent layer on top without creating another data silo.

Why Notion MCP Specifically

This solves a real problem that traditional CRM architectures cannot.

Built with Notion MCP, Google Gemini 2.5 Flash, and Next.js 15. Because revenue operations shouldn't require a $150/seat CRM when your team already lives in Notion.

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

Pooya Golchian — Mon, 16 Mar 2026 12:16:21 +0000

What I Built

I built RevOps AI — a revenue operations platform that lets marketing directors and company managers build, deploy, and manage an AI-powered sales team, with Notion as the single source of truth.

This isn't just a CRM. It's a RevOps command center where Google Gemini 2.5 Flash acts as an autonomous sales team member that can:

Analyze your pipeline and tell you where revenue is leaking
Score leads using AI reasoning and write the scores back to Notion
Generate pre-call briefings before your team picks up the phone
Draft personalized sales emails based on deal context
Create contacts, log activities, and update deal stages — all through natural language

The AI doesn't follow hardcoded scripts. Using mcpToTool() from Google's GenAI SDK, Gemini receives all 22 Notion MCP tools and decides at runtime which to call. It reasons, chains multi-step operations, and executes — like a real sales ops analyst would.

Why RevOps on Notion?

Every sales team I've worked with faces the same problem: their CRM is a data silo. Salesforce costs $150/user/month. HubSpot locks you into their ecosystem. Meanwhile, the team already lives in Notion for docs, meeting notes, and project management.

What if Notion was the CRM? And what if an AI agent could operate it autonomously?

That's RevOps AI. Your pipeline data stays in Notion where your whole team can see it. The AI layer adds intelligence on top — scoring, briefing, drafting, analyzing — without moving data into yet another proprietary database.

Key Features

AI Sales Team Manager — Chat with your revenue data in natural language. Ask "What's my pipeline health?" and the AI queries Notion, calculates win rates, and surfaces insights. Say "Create a follow-up for the Acme deal" and it creates the activity linked to the right deal. It's like having a senior sales ops analyst available 24/7.

Revenue Dashboard — Pipeline metrics at a glance: total value, win rate, deal breakdown by stage, top deals, and recent activity. All data flows from Notion through MCP in real-time.

Visual Deal Pipeline (Kanban) — Drag-and-drop deals between 6 stages (Lead → Qualified → Proposal → Negotiation → Closed Won → Closed Lost). Every move syncs to Notion instantly via MCP.

AI Lead Scoring — One-click AI analysis evaluates each contact (role seniority, company size, engagement history) and assigns a 0-100 score with written reasoning. Scores persist back to the Notion Contacts database so your team sees them everywhere Notion surfaces.

Pre-Call Briefing Generator — Before any sales call, the AI generates a structured brief: talking points, objections to expect, relationship history, and recommended next steps. All sourced autonomously from deal and activity data in Notion.

Email Ghostwriter — AI drafts personalized sales emails based on the deal's context, stage, and contact history. No generic templates — each email is contextually unique.

Contact Management — Full contact CRUD with search, filtering by lead source, sortable columns, and inline AI scoring. Add new contacts directly from the UI.

Demo

Screenshots

Revenue Dashboard — KPIs, pipeline by stage, top deals, recent activity:

Deal Pipeline (Kanban) — Drag & drop deals between stages:

Deal Detail + AI Email Draft — Edit deals, generate briefings, draft emails:

Leads & AI Scoring — Contact table with AI-powered lead scores:

Companies — Organization profiles linked to contacts and deals:

AI Sales Team Manager — Natural language chat with your CRM data:

Responsive Design — Works on desktop, tablet, and mobile:

Show Us the Code

GitHub Repository: https://github.com/pooyagolchian/ai-sales-crm

Application Flow

The Core Innovation — `mcpToTool()`

Instead of manually wiring each Notion API endpoint into the AI, one function call changes everything:

// src/lib/gemini.ts — The entire AI-to-Notion bridge
import { GoogleGenAI, mcpToTool } from "@google/genai";
import { getMcpClient } from "./mcp-client";

export async function generateWithTools(
  prompt: string,
  systemPrompt?: string
): Promise<string> {
  const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
  const mcpClient = await getMcpClient();

  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: prompt,
    config: {
      tools: [mcpToTool(mcpClient)],         // ← All 22 Notion tools, auto-mapped
      systemInstruction: getCrmSystemPrompt(), // ← DB IDs + property names injected
    },
  });

  return response.text ?? "";
}

mcpToTool(mcpClient) auto-maps all 22 Notion MCP tools into Gemini function declarations. The system prompt injects the actual database IDs and property names so Gemini doesn't waste tool calls discovering them.

The result: Gemini autonomously decides which Notion operations to perform. Ask "What's my pipeline value?" → it calls API-query-data-source on Deals. Say "Log a meeting for Acme" → it calls API-post-page to create an Activity and API-patch-page to update the deal. No hardcoded logic.

MCP Client — Singleton with Auto-Reconnect

// src/lib/mcp-client.ts — Singleton pattern
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

async function createClient(): Promise<Client> {
  const mcpClient = new Client({ name: "revops-ai", version: "1.0.0" });

  const transport = new StreamableHTTPClientTransport(
    new URL(process.env.MCP_SERVER_URL || "http://localhost:3001/mcp"),
    { requestInit: { headers: { Authorization: `Bearer ${authToken}` } } }
  );

  await mcpClient.connect(transport);
  return mcpClient;
}

Tech Stack

Layer	Technology
Framework	Next.js 15 (App Router), TypeScript (strict)
UI	Tailwind CSS v4, shadcn/ui, Lucide icons
AI	Google Gemini 2.5 Flash via `@google/genai` SDK
Data	Notion (4 databases) via MCP protocol
MCP	`@notionhq/notion-mcp-server` v2 (HTTP) + `@modelcontextprotocol/sdk`
DnD	`@dnd-kit/core` + `@dnd-kit/sortable`
Linting	Biome

How I Used Notion MCP

Notion is not a supporting tool here — it is the entire database layer. There is no Postgres, no SQLite, no local storage. Every record (contacts, deals, activities, companies) lives in a Notion database, and every read/write goes through MCP.

Four Notion Databases

Database	Purpose	Key Properties
Contacts	Lead & customer profiles	Name, Email, Company, Role, Lead Score, Lead Score Notes, Source
Deals	Revenue pipeline items	Name, Contact (relation), Stage (6 values), Value, Close Date, Priority, Next Action
Activities	Sales touchpoints	Type (call/email/meeting/note), Date, Deal (relation), Summary, Raw Notes
Companies	Organization profiles	Name, Industry, Size, Website

MCP Operations Used

Every data operation goes through MCP:

API-query-data-source — Querying databases with filters and sorts ("all deals where Stage = Proposal, sorted by Value desc")
API-post-page — Creating new contacts, deals, activities
API-patch-page — Updating deal stages (Kanban DnD), persisting AI lead scores, updating Next Action fields
API-search — Free-text search across the entire Notion workspace
API-retrieve-a-page — Fetching full details for deal briefings and AI assistant context

What Makes This Approach Fundamentally Different

Most MCP integrations hardcode which tools to call. RevOps AI lets the AI choose:

mcpToTool(mcpClient) — One function call auto-maps all 22 Notion MCP tools into Gemini function declarations. No manual schema writing. No maintaining tool definitions.
Autonomous multi-step reasoning — Gemini chains multiple MCP calls in a single response. Ask "Brief me on the TechCorp deal" and it autonomously: (1) searches for the deal → (2) queries related activities → (3) retrieves the contact profile → (4) synthesizes a briefing.
System prompt injection — The AI system prompt includes actual database IDs and exact property names from notion-schema.ts, so the AI doesn't waste tool calls discovering database structure.
Notion as single source of truth — The team's data stays in Notion where they already collaborate. RevOps AI is an intelligent layer on top, not another data silo.

The Practical Benefit of Notion MCP

Why Notion MCP specifically? Because it solves a real problem that traditional CRM architectures can't:

Your data stays where your team already works. A marketing director can open Notion and see every deal, contact, and activity in familiar views — tables, kanban, calendars, galleries. They can edit inline, add comments, share with stakeholders. No CRM login required.

The AI gets full context through a standard protocol. MCP gives the AI structured access to query, create, update, and search — with proper schemas and typed inputs. This isn't screen scraping or brittle API hacks. It's a designed protocol.

Zero vendor lock-in. Switch from Gemini to Claude or GPT? The MCP layer stays the same. Switch from Notion to another MCP-compatible tool? The AI integration pattern stays the same. MCP decouples the AI from the data source.

Cost: essentially free. Notion's free plan supports databases. Gemini 2.5 Flash has a generous free tier via Google AI Studio. The MCP server is open source. For a startup's first RevOps stack, total cost can be $0.

Built with Notion MCP, Google Gemini 2.5 Flash, Next.js 15, and the belief that revenue operations shouldn't require a $150/seat CRM when your team's already in Notion.

https://www.npmjs.com/package/use-local-llm

Pooya Golchian — Fri, 13 Mar 2026 06:59:35 +0000

Pooya Golchian

Mar 11

use-local-llm: React Hooks for AI That Actually Work Locally

#react #typescript #opensource #ai

5 min read

npmjs.com

Detailed Comparison of Next.js, Astro, and Remix

Pooya Golchian — Fri, 02 Aug 2024 22:37:35 +0000

Introduction

Creating a robust and fast website is essential in today's digital landscape. This post compares three popular frontend frameworks—Next.js, Astro, and Remix—highlighting why developers choose them, and introduces the expert website development and consultancy services available at Pooya Blog.

Detailed Comparison of Next.js, Astro, and Remix

Overview of Frameworks

Feature	Astro	Next.js	Remix
Main Use Case	Static site generation	Server-rendered React apps	Full-stack JavaScript framework
Performance	Minimal JavaScript, fast load times	Efficient with static and server-side rendering	Fast data retrieval and loading
Flexibility	UI-agnostic, supports various frameworks	Built-in CSS/Sass support, configurable	Unifies client-server, web standards-focused
Key Features	Zero-config, supports multiple UI libraries	Async components, file-based routing	File-based routing, nested components
Hydration	Partial hydration	No partial hydration, supports static pages	No partial hydration, potential with React 18

Performance Benchmarks

Metric	Astro	Next.js	Remix
Load Time	Fastest	Fast	Fast
JavaScript Payload	Minimal	Moderate	Moderate
SEO	High	High	High

Use Cases

Use Case	Astro	Next.js	Remix
Content-heavy Static Sites	Excellent	Good	Good
Dynamic Applications	Limited	Excellent	Excellent
Client-server Integration	Moderate	Good	Excellent

Adoption and Community Support

Metric	Astro	Next.js	Remix
GitHub Stars	25,000+	100,000+	15,000+
npm Downloads	500,000/month	3 million/month	200,000/month
Documentation	Comprehensive	Comprehensive	Comprehensive
Community Support	Active	Very Active	Active

Why Developers Choose These Frameworks

Next.js

Performance and Flexibility: SSR, SSG, built-in CSS/Sass support, file-based routing.
Robust Ecosystem: Extensive documentation, large community, and seamless integration with Vercel.

Astro

Performance-First Approach: Minimal JavaScript, partial hydration.
Flexibility and Simplicity: UI-agnostic, zero-config setup, supports various frameworks.

Remix

Full-Stack Capabilities: Client-server unification, fast data loading.
Modern Development Features: Nested routes, web standards focus.

Expert Website Development and Consultancy

At Pooya Golchian Website, we specialize in creating robust and fast websites tailored to your needs. Our consultancy services provide insights into the latest trends, best practices, and essential tools for building and maintaining high-performance websites. Whether starting from scratch or enhancing your existing site, our expertise will guide you to success.

Conclusion

Choosing the right framework depends on your project needs. Astro excels in static site generation, Next.js is versatile for dynamic and static content, and Remix offers a seamless full-stack experience. For professional website development and consultancy services, visit Pooya Golchian Blog.

Improving Next.js website performance and get a 100% rate of optimization from Lighthouse on desktop and mobile

Pooya Golchian — Tue, 14 Feb 2023 14:09:57 +0000

I want to write about the website's performance that lighthouse provides us. After I developed the website of the Cashew company, the performance of the website was so terrible. The percentage was about 20%. I improved it with some tips and tricks about the image format and also upgraded the Next.js version 12 to 13.

Image format! (the important part)

Don't forget to use the best image resolution also the next-generation format like Webp format.

Firstly, we should convert all high-resolution images of our website to the WebP format. I found one of the best command line tools that name is CWebP.

Secondly, we can convert it in all bulk! For this action, we need to install the parallel package in our OS.

For example, I convert all jpeg files:

parallel -eta cwebp -q 20 -lossless {} -o {.}.webp ::: *.jpg

Upgrade Next.js version 12 to version 13

In this part, we should change some parts of the code that were deprecated in the old version. Next.js has provided very well documentation for upgrading the old version to the new one. Every single native component in Next.js should refactor after upgrading.
I mentioned some the important ones:

Image
Scripts (third-party scripts)
Link

How to get the report in Lighthouse with the command line

Firstly you should install the lighthouse NPM package on your local machine.

npm install -g lighthouse

Secondly, you can separate desktop and mobile report

Command for desktop

lighthouse [WEBSITE] --form-factor "desktop" --preset=desktop

Command for mobile

lighthouse [WEBSITE] --form-factor "desktop" --preset=mobile

How to pull the AWS ECR docker image and extract all things in the docker image?

Pooya Golchian — Wed, 21 Apr 2021 17:34:37 +0000

Intro

Maybe you faced the problem that you have been needed the old docker file in the ECR repository.
I solved this problem with the docker command to pull and extract the docker image and access all I need.

Pulling Docker image file

You can use the below command to pull the docker image that you push in the ECR repository:

docker pull YOUR_DOCKER_IMAGE_URL

Run your desire command in docker image

You can run and execute a command in your docker image:

docker run --rm -it --entrypoint=/bin/bash YOUR_DOCKER_IMAGE_URL

For example:

docker run --rm -it --entrypoint=/bin/bash YOUR_DOCKER_IMAGE_URL ls -la

Extract Docker image and searching in the files

 docker image save YOUR_DOCKER_IMAGE_URL > img.tar

After that, you extract the docker image and find your target files:

 tar -xvf img.tar

DEV Community: Pooya Golchian

The 200-result ceiling that forced a tiled crawler

The ceiling that shapes everything

Tiling forces a budget model

Price it before you buy

The only irreversible spend

Classify the vocabulary, not businesses

Four gates measure, one does not

20,226 review snippets nearly shipped

What the live demo does

The lead score ranked ATMs

Porting the crawl to Lisbon

What I am not claiming

What to copy

dirham v1.3.0 — A Universal Web Component for the UAE Dirham Symbol

What's new in v1.3.0

Works everywhere

Full feature set

Why U+20C3?

Links

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP 💥

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

RevOps AI. I Turned Notion into an AI-Powered CRM with Gemini and MCP

What I Built

The Problem That Started This

Key Features

Demo

Screenshots

Show Us the Code

Application Flow

The Core Innovation, mcpToTool()

MCP Client, Singleton with Auto-Reconnect

Tech Stack

How I Used Notion MCP

Four Notion Databases

MCP Operations Used

What Makes This Approach Different

Why Notion MCP Specifically

RevOps AI. I Turned Notion into an AI-Powered CRM with Gemini and MCP

What I Built

The Problem That Started This

Key Features

Demo

Screenshots

Show Us the Code

Application Flow

The Core Innovation, mcpToTool()

MCP Client, Singleton with Auto-Reconnect

Tech Stack

How I Used Notion MCP

Four Notion Databases

MCP Operations Used

What Makes This Approach Different

Why Notion MCP Specifically

RevOps AI - Build Your AI Sales Team on Notion with Gemini + MCP

What I Built

Why RevOps on Notion?

Key Features

Demo

Screenshots

Show Us the Code

Application Flow

The Core Innovation — mcpToTool()

MCP Client — Singleton with Auto-Reconnect

Tech Stack

How I Used Notion MCP

Four Notion Databases

MCP Operations Used

What Makes This Approach Fundamentally Different

The Practical Benefit of Notion MCP

https://www.npmjs.com/package/use-local-llm

use-local-llm: React Hooks for AI That Actually Work Locally

Detailed Comparison of Next.js, Astro, and Remix

Introduction

Detailed Comparison of Next.js, Astro, and Remix

Why Developers Choose These Frameworks

The Core Innovation, `mcpToTool()`

The Core Innovation, `mcpToTool()`

The Core Innovation — `mcpToTool()`