P-18
Techpoint CRM
CRM and website for a computer repair shop: customers, service orders, price tags and storefront, running at the edge with RLS as the final word.
clientComputer store and repair shop in Brasília, Brazil's Federal District
Full-stack developer (sole author of the CRM's 48 commits and the website's 25)
Back office for a computer store and repair shop, built with React Router v7 (SSR) on Cloudflare Workers and Supabase Postgres 17. It imports the customer spreadsheet with tested, duplicate-free normalization, runs service orders with printed bench labels and intake receipts, renders price tags at true millimetre size with text that fits the space, receives website leads and feeds the public storefront. Login is an e-mailed one-time code behind Turnstile with no public sign-up; data always flows through the user's session with RLS on every table; the JWT is verified at the edge with a JWKS embedded at build time so each click costs one database round trip. The static Astro website records the request in the CRM before opening WhatsApp.
- cloudflare
- react
- supabase
- postgres
- rls
- astro
- anti-bot
- lgpd
01Overview
Techpoint is an independent computer store and repair shop in Brasília, Brazil: it fixes laptops and desktops, sells new and refurbished hardware and buys used gear. Day-to-day work lived in WhatsApp and in a spreadsheet exported from the old system, with a little over a thousand customer records, phone numbers in a dozen formats and not a single birthday filled in.
The project delivered two pieces that talk to each other. The CRM is the shop's back office: customers with a profile, timeline and member card; service orders with a bench label and an intake receipt; inventory with a public storefront; price tags printed at true millimetre size; leads coming from the website; birthdays; and a dashboard with a map of the Federal District showing where the customer base actually is. The website is a static Astro landing page with service pages, structured data and a form that records the request in the CRM before handing the visitor over to WhatsApp.
Everything runs on Cloudflare Workers, with Supabase (Postgres 17) for data and authentication. The CRM was built and shipped between 16 and 18 September 2026 in 48 commits by a single author; the website shipped in the same window in 25 commits.
02The problem
- Shapeless data. The customer spreadsheet had phones in ten formats, names in ALL CAPS, duplicates by phone and by name, and key fields empty. Any off-the-shelf CRM would have demanded a manual clean-up before import.
- Bench workflow on paper. Written quote, approval, repair, pickup: each step was agreed over chat, with no order number, no history and no standard receipt.
- Small shop, big latency. A team of two or three people has no patience for slow screens. The first version ran with the database in the United States, and every click chained several database round trips.
- No passwords to forget, no sign-up to abuse. The shop did not want to manage passwords, but it could not expose an open registration form to the internet either.
- Website and CRM apart. Website forms opened WhatsApp and nothing was recorded; the storefront was a hand-edited JSON file.
03The solution
Customers. Spreadsheet import runs in the browser, with tested normalization (phones to digits with country code, names to Title Case while keeping the original, postal codes, dates in Brasília time, misspelled e-mails flagged with a tag) and an idempotent RPC: re-uploading the same file duplicates nothing. Table or card-grid view, inline cell editing, accent-insensitive search across name, phone, e-mail, city and member-card code, filters by neighbourhood, administrative region and city block, bulk tag actions, and a duplicates queue whose merge moves timeline, service orders and leads.
Service orders. Eight statuses (received → diagnosis → quote → approval → repair → ready → delivered, plus cancelled), sequential number, itemized quote, delivery estimate. Every status change becomes a timeline event through a trigger. Printables: a bench label (74×105 or 50×80 mm, with a QR code that opens the order) and an A5 intake receipt in two copies with the consumer-law notice. Ready-made WhatsApp messages per stage, editable in Settings.
Products, storefront and price tags. Inventory with category, condition, specs and instalments. Products flagged "show in storefront" are served by GET /api/vitrine for the website. Price tags render at millimetre size (A7, A6, A5, a 50×30 label or a custom size), in three themes, with a QR code that opens the shop's WhatsApp with the product already in the message; text fits the available space by measuring with canvas after fonts load, and the print sheet lays out several tags on A4/A3/Letter with crop marks.
Website leads. POST /api/leads receives the quote and sell-your-used-gear forms, verified with Turnstile, and feeds the leads screen with a counter in the menu. From there a salesperson replies on WhatsApp, creates the customer or links the lead to an existing one by phone.
Dashboard. Base KPIs, a monthly individual/business series, today's birthdays, a service-order summary and two maps: the Federal District in MapLibre (one pin per neighbourhood or per administrative region, proportional area, click opens the filtered list) and a schematic of the city blocks around the shop.
Team and access. Primary login is an 8-digit one-time code sent by e-mail, with the shop's branding. There is no public sign-up: the admin creates accounts in Settings and the person receives a welcome e-mail. Roles are admin and vendedor (sales).
Website. Static Astro, ten service pages generated from JSON, an FAQ mirrored 1:1 into JSON-LD, a sitemap whose lastmod comes from git, an llms.txt generated from the same data, a robots.txt with Content Signals (search and AI assistants allowed, model training disallowed) and a verifier that runs at the end of the build and fails if the schema, the NAP data or the sitemap break.
- One database round trip per click: JWT verified in the isolate with a build-time JWKS, session bootstrap in a single RPC cached for 60 s, and loaders that start without waiting for the profile.
- RLS on all 13 tables with helpers in a schema outside the API; the anonymous role can only insert a new lead and read the storefront through a security_invoker view with column-level grants.
- Passwordless login with the shop's branding: Supabase's Send Email hook reaches the Worker signed (Standard Webhooks), which builds the e-mail and sends it through Resend.
- Price tags at true millimetre size with canvas-measured text fitting, three themes and a print sheet with crop marks.
- Map of the Federal District that geocodes no addresses: neighbourhoods and regions in a static table, MapLibre loaded browser-only, SVG as fallback.
- Static website that records the lead in the CRM before opening WhatsApp, with server-side Turnstile and an SEO/GEO verifier that fails the build.
04Architecture
Read the diagram as a list (19 components, 20 connections)
Components
- Shop staff: Admin<br>staff · import · shop, Salesperson<br>customers · orders · tags
- Public website · Cloudflare Workers (assets): Static Astro<br>11 service pages · JSON-LD · llms.txt, Turnstile widget<br>on every form
- CRM · Cloudflare Worker (smart placement): React Router v7 SSR<br>36 routes · loaders and actions, Local JWT verification<br>JWKS embedded at build · 6 h cache, bootstrap_sessao()<br>profile + settings + counters · 1 DB round trip, POST /api/leads<br>CORS allowlist · honeypot · Turnstile server-side, GET /api/vitrine<br>5 min edge cache, POST /api/auth/email<br>Standard Webhooks HMAC · 5 min window, admin.server.ts<br>service role only to create/delete access
- Supabase · Postgres 17 (São Paulo): Auth<br>e-mail OTP · Turnstile · no public sign-up, RLS on 13 tables<br>40 policies · helpers in a private schema, RPCs and views<br>security invoker · EXECUTE for authenticated only, Triggers<br>profile on user creation · order timeline · catalogue
Connections
- Admin<br>staff · import · shop → React Router v7 SSR<br>36 routes · loaders and actions
- Salesperson<br>customers · orders · tags → React Router v7 SSR<br>36 routes · loaders and actions
- Website visitor<br>quote · selling a used device → Static Astro<br>11 service pages · JSON-LD · llms.txt
- Static Astro<br>11 service pages · JSON-LD · llms.txt → POST /api/leads<br>CORS allowlist · honeypot · Turnstile server-side (sendBeacon / fetch keepalive)
- Static Astro<br>11 service pages · JSON-LD · llms.txt → GET /api/vitrine<br>5 min edge cache (fetch at build/client)
- Turnstile widget<br>on every form → POST /api/leads<br>CORS allowlist · honeypot · Turnstile server-side (token)
- React Router v7 SSR<br>36 routes · loaders and actions → Local JWT verification<br>JWKS embedded at build · 6 h cache
- Local JWT verification<br>JWKS embedded at build · 6 h cache → bootstrap_sessao()<br>profile + settings + counters · 1 DB round trip
- bootstrap_sessao()<br>profile + settings + counters · 1 DB round trip → RPCs and views<br>security invoker · EXECUTE for authenticated only
- React Router v7 SSR<br>36 routes · loaders and actions → RLS on 13 tables<br>40 policies · helpers in a private schema (user session + RLS)
- POST /api/leads<br>CORS allowlist · honeypot · Turnstile server-side → RLS on 13 tables<br>40 policies · helpers in a private schema (publishable key · INSERT only)
- POST /api/leads<br>CORS allowlist · honeypot · Turnstile server-side → Cloudflare Turnstile<br>siteverify
- GET /api/vitrine<br>5 min edge cache → RLS on 13 tables<br>40 policies · helpers in a private schema (security_invoker view)
- Auth<br>e-mail OTP · Turnstile · no public sign-up → POST /api/auth/email<br>Standard Webhooks HMAC · 5 min window (Send Email hook)
- POST /api/auth/email<br>Standard Webhooks HMAC · 5 min window → Resend<br>branded e-mails
- React Router v7 SSR<br>36 routes · loaders and actions → Auth<br>e-mail OTP · Turnstile · no public sign-up (signInWithOtp / verifyOtp)
- admin.server.ts<br>service role only to create/delete access → Auth<br>e-mail OTP · Turnstile · no public sign-up (auth.admin.createUser)
- Auth<br>e-mail OTP · Turnstile · no public sign-up → Triggers<br>profile on user creation · order timeline · catalogue
- RLS on 13 tables<br>40 policies · helpers in a private schema → Triggers<br>profile on user creation · order timeline · catalogue
- React Router v7 SSR<br>36 routes · loaders and actions → OpenFreeMap<br>map tiles · no key (browser only)
The Worker is the single entry point: it renders screens on the server (React Router v7 in framework mode), runs the actions and exposes four JSON resource routes. CRM data is never touched with elevated privileges: each request uses the user's own session, and Row Level Security decides what they can see. The service role lives in one module and is used only to create and delete accounts.
05Under the hood
- Postgres 17 on Supabase, 20 versioned migrations, 13 tables, 2 views, 26 SQL/PL/pgSQL functions and 12 triggers. Extensions
pg_trgm,unaccentandcitext. - Accent-insensitive search through a generated
tsvectorcolumn (sem_acento, an IMMUTABLE wrapper aroundunaccent) and a trigram index on the normalized name. Generated columns also carry the member-card code (a prefix of the UUID) and the city block parsed from the address by regex. - One database round trip per screen.
bootstrap_sessao()returns profile, settings and menu counters in a single JSON;painel_resumo,painel_osandpainel_clientesaggregate the dashboard in three RPCs fired in parallel;filtros_clientes()returns cities, neighbourhoods, tags and the pending-data chips at once. - Business logic in the database where it must be atomic:
importar_clientes(idempotent batch withon conflict do nothingover a natural key),mesclar_clientes(moves timeline, orders and leads, then deactivates the duplicate), bulkclientes_alterar_tag,catalogo_aprender(a trigger that feeds the brand/model dictionary from orders and products),os_registrar_evento(every status change becomes a timeline interaction). - E-mail without SMTP: Supabase's Send Email hook reaches the Worker signed, the Worker builds the branded HTML (
layoutEmail, a pure, tested module) and sends through Resend. Links point to the CRM's own/auth/callbackwith atoken_hash, so they work when opened on another device. - No Edge Functions, no queues, no cron: everything that needed a server fit in loaders, actions and SQL functions.
- React Router v7 (framework mode, SSR) + React 19 + TypeScript, Tailwind CSS v4 with the brand tokens (amber on near-black, Barlow / Barlow Condensed / B612 Mono), Radix UI for dialogs and menus,
cmdkfor the Ctrl K palette, Zod shared between client and server. - Layered caching with no library:
clientLoaderwith acacheadohelper (10–60 s per URL in the browser, invalidated by any form submission), a layout that only revalidates after a mutation or every 2 minutes,prefetch="intent"on menu links. - Zero hydration errors by design: dates always formatted in Brasília time, relative time only after mount (
<Relativo />), the table/grid preference read fromlocalStorageinside auseEffect. - Print as a first-class citizen: tags, labels and receipts are HTML sized in millimetres with a zero-margin
@page; the editor measures content and warns when it does not fit, compacting through three levels before clipping. - A map that geocodes nobody: MapLibre GL is imported dynamically inside
useEffect(a ~1 MB chunk only for whoever opens the dashboard), with a custom style in brand colours over OpenFreeMap vector tiles and the polygons of the 34 administrative regions pre-projected by a script from Overpass. A static SVG takes over if WebGL fails. - Visual preview without a session:
npm run previamounts the real components in Playwright and screenshots them, so the member card and Settings can be checked without a database.
- Cloudflare Workers with
@cloudflare/vite-plugin: local dev runs on the realworkerd.placement: smartmoves the Worker closer to the database. The custom domain is declared inwrangler.json;npm run deployalways rebuilds before publishing, because thewrangler.jsonthat counts is the one generated at build time. Observability and source maps are on. - Database in São Paulo: the original Supabase project (us-east-1) was replaced on day one because of latency.
- A build that downloads the Auth public keys (
scripts/baixar-jwks.mjs,prebuild) and embeds them in the bundle: a cold isolate verifies JWTs without touching the network. - Website published as an assets-only Worker (
wrangler.jsoncwithoutmain), deployed automatically by Workers Builds on every push; security and cache headers inpublic/_headers. - Minimum verification before shipping:
npm run typecheck(wrangler types+react-router typegen+tsc -b),npm test,npm run build,npx wrangler deploy --dry-run.
06Security
8 attacks considered, 8 defenses in production.
Scripts that flood forms, inflate numbers or sweep the site for openings.
A bot flooding the public endpoint with fake leads
Origin allowlist, a honeypot that answers ok without writing, Zod with per-field limits, Turnstile token verified at siteverify with the client IP, and an INSERT policy that only accepts a new, unlinked status.
Skipping the interface to talk straight to the database or API with the public key in hand.
Read customers, orders or leads straight from PostgREST with the publishable key
RLS on all 13 tables; anon lost every privilege on products, leads and catalogue, and default privileges revoke EXECUTE on every new function. No valid JWT, no rows.
Brute force, rogue account creation, password reset and account takeover.
Self-register an account and walk into the CRM
/cadastro only redirects; signInWithOtp runs with shouldCreateUser: false; the profile trigger leaves inactive any account not born from an admin or a recorded invitation.
Brute-forcing the one-time code or the fallback password
Turnstile required on every form, validated by Supabase itself; single-use 8-digit code; one send per e-mail every 60 s with a countdown on screen.
Someone with some access trying to get more: becoming admin, reading what they shouldn't, keeping revoked access.
A salesperson trying to import the spreadsheet, delete a customer or create accounts
Role read from the profiles table by sou_admin() in a schema outside the API; exigirAdmin on the route and the same check inside the importar_clientes RPC; DELETE policies admin-only; service role only in admin.server.ts.
CSRF, fake webhooks, reused tokens, signed links and open redirects.
Forge the e-mail hook to send messages in the shop's name
Standard Webhooks signature (HMAC-SHA256 over id.timestamp.body) checked in constant time, 5-minute window, rotatable secrets separated by |. No valid signature, 401.
Open redirect through ?proximo= after login
destinoSeguro only accepts a path starting with /; caminhoInternoDoApp refuses any target outside /app.
Enumerating who is in the base, scraping personal data, tying questions to people, extracting secrets.
Leak SKU, internal notes or cost through the public storefront
vitrine_publica view with security_invoker, column-level SELECT grant for anon and a policy that only exposes in-stock rows flagged for the storefront.
Authentication. Primary login is an 8-digit one-time code sent by e-mail (signInWithOtp with shouldCreateUser: false, then verifyOtp); a password exists only as a fallback. Every login and recovery form carries its own Turnstile widget, and the token is validated by Supabase itself (Attack Protection), so an auth call without a captcha is refused at the source. Supabase limits resends to one per e-mail every 60 s and the screen shows a countdown instead of letting the user hit the limit.
No public sign-up. /cadastro only redirects. Accounts are born in Settings → Team through auth.admin.createUser with metadata; the criar_perfil_para_novo_usuario trigger creates the profile and leaves the account inactive unless it came from an admin or a recorded invitation. That is defence in depth: even if sign-up were re-enabled in the dashboard, the account would have no access.
Session and JWT. Cookies are httpOnly, secure, sameSite=lax, written by @supabase/ssr. The JWT is verified locally in the Worker against the public keys (JWKS) embedded at build time and cached for 6 h; an unknown kid forces a refetch. exigirSessaoRapida authenticates read loaders without waiting for the database while RLS remains the data barrier; exigirSessao/exigirAdmin guard actions and admin screens. Redirect targets (?proximo=, ?de=) are only accepted when they are internal relative paths.
Authorization in the database. RLS enabled on all 13 tables, 40 policies. The helpers sou_admin(), estou_ativo() and meu_papel() live in a privado schema, outside the PostgREST API, as SECURITY DEFINER with search_path = ''. Default privileges on the public schema revoke EXECUTE from anon and public for every new function; each RPC grants authenticated explicitly. Functions that read auth.users (equipe_acessos, minha_senha_definida, sistema_resumo) carry the gate inside the body (auth.uid() or privado.sou_admin()), not just in the grant. The import requires admin both in the route and inside the RPC.
What the anonymous role can do, and nothing else. anon lost every privilege on produtos, leads, marcas, modelos and cliente_pares_ignorados and got exactly two back: INSERT on leads, with a policy requiring status = 'novo', no cliente_id or atendido_por, an origin from a closed list and length limits; and column-level SELECT on produtos only for in-stock rows flagged for the storefront, through a security_invoker view (the first version of the view ran as its owner and was fixed in migration 12). SKU, internal notes and cost never leave.
Public leads endpoint. Origin allowlist from an environment variable, a honeypot that answers success without writing, a Zod schema with a maximum length per field, the Turnstile token checked against siteverify with the client IP, and an insert without .select(). The website posts as form-urlencoded to stay a simple request (no preflight) and falls back to sendBeacon if the network fails.
E-mail hook. /api/auth/email only accepts payloads signed in the Standard Webhooks format: HMAC-SHA256 over id.timestamp.body, constant-time comparison, a 5-minute window, and several secrets separated by | for zero-downtime rotation. Invalid signature → 401; no secret configured → explicit 500.
Secrets. Service role, Resend key, hook secret and Turnstile secret are Worker secrets (wrangler secret put), never in the generated Env type, never printed. The service role is instantiated only in admin.server.ts, without session persistence, to create and delete accounts. The build fails if a *.server.ts module is referenced by a client component.
Personal data (LGPD). The original spreadsheet with customer records was kept out of git from the start and the history was rewritten to guarantee it (commit on day two). The dashboard map does not geocode addresses: coordinates belong to neighbourhoods in a static table, and only the visible area goes to the tile server. CSV export and bulk actions respect the same filters and the same RLS as the list. The website's robots.txt states that content may be indexed and cited but not used to train models.
Validation. Zod in every action (customer, product, order, interaction, lead, login), phones normalized to digits with country code before writing, birthdays stored as YYYY-MM-DD with no timezone, place names canonicalized on save.
07Technical challenges
Making an edge Worker talk to a Postgres thousands of kilometres away without the screen noticing
The first version ran with the database in the United States and each navigation chained authentication, profile, settings and the screen's query. The fix came in layers: move the project to São Paulo; embed the JWKS at build time and verify the JWT inside the isolate; fold profile, settings and counters into one RPC (bootstrap_sessao) cached for 60 s per token and invalidated on any non-GET request; let read loaders start without waiting for the bootstrap (exigirSessaoRapida); Promise.all on every parallel query; and a 10–60 s cache in the browser. The rule became "one database round trip per click", and an admin-only /api/diag measures the real cost of each call from the Worker.
Passwordless login with the shop's branding that still works under automation
Supabase sends e-mail over SMTP with its own template; here the Send Email hook reaches the Worker signed, the template is built by a pure, tested module and the message goes out through Resend. Links use token_hash instead of PKCE, so a code opened on a phone works even if the login started on a desktop. Since Turnstile blocks any form login in an automated browser, the end-to-end tests sign in through a magic link generated with the service role, outside the user flow.
Price tags that always fit
Printing in millimetres is easy; a long title on an A7 tag is not. Instead of fixing the size by character count, every field has a base and a minimum in units relative to the width, the editor measures text with canvas after document.fonts is ready, estimates the height across three compaction levels and only then warns that it does not fit (offering the next size up). On the server, with no canvas, it uses the base sizes. Landscape is its own two-column layout; labels whose short side is ≤ 40 mm switch to a three-field layout.
A customer map that sends nobody's address anywhere
Postal codes are useless for the Federal District: the lookup APIs return the centre of Brasília for all of them. The alternative was a static table of 69 neighbourhoods with a canonical label, administrative region and coordinate, polygons of the 34 regions downloaded from Overpass and pre-projected by a script (a generated file, never edited by hand), and grouping by region because the same place arrived under nine different spellings. MapLibre is loaded via import() inside useEffect, browser only, with a custom style over OpenFreeMap tiles; if WebGL fails, an SVG takes over.
Importing a messy spreadsheet without losing anything
Normalization runs in the browser in batches, with 154 test cases covering phone formats, names, postal codes and dates; the RPC inserts with on conflict do nothing over a natural key (original name + phone + registration date), so re-uploading the file is safe. Duplicates by phone or name land in a view, "different people" is persisted, and mesclar_clientes moves everything that points at the secondary record.
08Results
- CRM in production on its own domain, with the website integrated: leads recorded before WhatsApp opens and a storefront fed by the inventory.
- 13 tables, 40 RLS policies, 26 SQL functions, 12 triggers, 20 migrations, 36 routes, 4 resource endpoints, 0 Edge Functions.
- 154 unit tests in 13 files (Vitest, executed: all pass) and 4 Playwright scripts (full flow, mobile, session, production latency).
- ~21k non-blank lines in the CRM (TSX 12,675; TS 4,950 excluding generated types; SQL 2,422; scripts 722; CSS 365) and ~2.7k on the website (Astro 1,161; CSS 783; TS 431; scripts 343).
- 48 commits on the CRM and 25 on the website between 16 and 18 September 2026, single author.
- 13
- tables with RLS
- 40
- RLS policies
- 26
- SQL functions
- 20
- migrations
- 36
- routes
- 154
- unit tests
- 48 + 25
- commits
- ~21k
- lines of code
how we measured
create table / enable row level security in the migrations under supabase/migrations
how we measured
grep 'create policy' in the migrations
how we measured
distinct create or replace function statements in the migrations (public + private schema)
how we measured
ls supabase/migrations
how we measured
route()/index() entries in app/routes.ts
how we measured
npx vitest run executed locally: 13 files, 154 tests, all passing
how we measured
git rev-list --count HEAD in the CRM and in the website
how we measured
non-empty lines of versioned .ts/.tsx/.sql/.mjs/.css in the CRM, excluding generated types and geo-ras.ts
09Timeline
- Sep 2026
Spreadsheet and Supabase diagnosis; full back office (customers, birthdays, products, price tags) in the first commit
- Sep 2026
Service orders with bench label and A5 receipt; website leads and public storefront; OTP login and the end of public sign-up
- Sep 2026
Performance: one round trip per click, project moved to São Paulo, branded e-mails via Supabase hook + Resend, Turnstile on login and website forms
- Sep 2026
Tag editor with text fitting, 50×30 label and amber theme; self-learning brand/model catalogue; customer spreadsheet purged from git history
- Sep 2026
Dashboard with a MapLibre map of the Federal District coloured by administrative region, charts and neighbourhood/region/block filters
- Sep 2026
Customer grid with member card and inline editing; sectioned menu, Ctrl K palette and rebuilt Settings; the website starts recording leads in the CRM
10Stack
- React 19
- React Router 7 (framework mode, SSR)
- TypeScript 5.9
- Vite 7
- Tailwind CSS 4
- Radix UI
- cmdk
- MapLibre GL 6
- Astro 7 (site)
- Cloudflare Workers
- @cloudflare/vite-plugin
- Loaders e actions do React Router
- @supabase/ssr
- Zod 4
- Resend (API HTTP)
- Supabase Postgres 17
- Row Level Security
- PostgREST
- Views security_invoker
- PL/pgSQL
- pg_trgm + unaccent + citext
- Colunas geradas e tsvector
- Workers com smart placement
- Custom domain
- Workers Builds (site)
- Workers Static Assets
- OpenFreeMap
- Vitest + Playwright
- OTP por e-mail (8 dígitos)
- Cloudflare Turnstile
- JWT verificado localmente (JWKS embutido)
- Cookies httpOnly/secure
- Standard Webhooks HMAC
- Schema privado para helpers de RLS
- Default privileges restritivos
- CORS allowlist + honeypot
11Tech sheet
- type
- CRM + website · computer repair shop
- stack
- React Router v7 SSR · React 19 · Tailwind v4 · Astro 7
- db
- Supabase Postgres 17 · 13 tables · RLS on all
- auth
- e-mail OTP · Turnstile · JWT verified at the edge
- deploy
- Cloudflare Workers (smart placement) · Workers Builds
- modules
- customers · service orders · price tags · storefront · leads · dashboard
- tests
- 154 unit · 4 Playwright scripts
- status
- in production since Sep 2026
The platform that brought content creators into the campaign to end online betting in Brazil: nationwide sign-ups, an inflation-proof public counter and a brute-force-hardened admin panel.
Volunteer mobilization under a legal deadline and a hostile audience: every rule lives in the database.
An AI assistant that only answers with a source, with spend capped at four layers.
Want a system like this for your operation?
Node designs, builds and protects tailor-made platforms for campaigns, elected officials and movements.

TECHNOLOGY AND POLITICAL INTELLIGENCE
© 2026 NODE. All rights reserved.