Project snapshot
Client / context: North Coast Medical internal tooling
Role: Full-stack design engineer
Focus: AI-assisted product workflows, internal operations UX, account review tooling, auth/access, Retool and Convex integration
Stack: Next.js, React, TypeScript, Convex, Microsoft Entra ID, OpenAI Responses API, Retool webhooks, Tailwind CSS, shadcn-style UI, Cloudflare Worker branded links
One-line version
I designed and built North Coast Pontifex, an internal power-tools platform that uses AI, product APIs, Convex, Microsoft auth, and Retool workflows to turn messy sales and account inputs into polished operational outputs.
The challenge
North Coast teams had high-value work trapped in manual, fragmented processes: pasted mNotes, product meta IDs, distributor context, sample requests, account activity reviews, and follow-up workflows.
The challenge was not simply adding AI to a form. It was designing a controlled internal platform that could:
- parse messy sales/account notes
- connect to product metadata and account data
- generate polished product-introduction documents
- support human review, editing, and product/image selection
- create branded public share links
- manage samples, requests, collaborators, and document state
- protect access through Microsoft Entra and per-user tool permissions
- integrate with existing Retool workflows instead of replacing them overnight
My role
I built the platform end to end across product design, frontend, backend, auth, data modeling, and workflow integration.
My work included:
- designing the internal “power tools” app shell and navigation
- building the Product Intro Generator workflow
- integrating OpenAI for product copy and company profile summaries
- caching generated product/company content for consistency and cost control
- migrating state from PocketBase into Convex
- implementing Microsoft Entra sign-in and Convex whitelist access
- adding per-user tool access controls
- wiring Retool webhooks for account search, account mNotes, and review flows
- creating branded public document links through a Cloudflare Worker
- building account activity review tooling
- writing tests around access, document behavior, mNote parsing, sample requests, Retool integration, and tool manifests
Selected work
1. Product Intro Generator
The Product Intro Generator turns pasted mNotes and selected product metas into distributor-ready product previews.
I built a workflow where users can:
- paste raw mNotes containing category headings and product meta IDs
- import and review parsed categories/products
- fetch North Coast product metadata from the product API
- optionally analyze a distributor/company homepage
- generate structured intro copy with OpenAI
- manually add products by search
- choose product images and cover images
- reorder, remove, and refine product sections
- save drafts and generated documents
- share read-only public links
The tool converted a manual, expert-heavy sales-support workflow into a repeatable guided product experience.
2. AI generation with guardrails
The platform uses AI where it creates leverage, but not without controls.
Generation behavior was shaped around:
- supplied product selection and product API data
- optional company profile context
- cached product summaries
- neutral copy when company context is thin
- no invented claims, partnerships, pricing, or availability
- no mention of internal mNotes or prompt/process mechanics
- structured fields that preserve category and product relationships
Server code also sanitizes common internal-language leaks before returning generated documents.
3. Cached knowledge and stable output
AI output needed to be efficient and stable enough for business use.
I added caching for:
- product summaries by
metaItemId - company profiles by normalized website URL
- generated document state and drafts
This reduced repeat AI work, made product copy more consistent, and helped users resume work without losing context.
4. Public sharing and branded links
Generated documents needed to be shared externally without exposing internal editing screens.
I built:
- public read-only document routes at
/plg-document/[id] - signed-in document management
- copyable share links
- branded link support through a Cloudflare Worker
- public asset allowlisting and edge-level route restrictions
- sample request routes that could work from shared public documents
This turned internal generation into a customer/distributor-facing output pipeline.
5. Auth and access controls
Because the tools touched internal workflows and customer/account context, access needed to be explicit.
I implemented:
- Microsoft Entra sign-in
- Convex custom OIDC auth
- user whitelist seeding
- per-user power-tool access gates
- admin tool-access management
- hard auth recovery and redirect handling
- collaborator visibility and document sharing controls
The result was a platform foundation, not a one-off internal page.
6. Retool and account workflow integration
Pontifex needed to connect to existing operational systems rather than forcing all work into one app immediately.
I added Retool webhook plumbing for:
- account search
- retrieving user accounts
- retrieving account mNotes
- Retool debug/testing flows
- normalized account summary inputs
- account activity review workflows
This let the app become a better UX layer over existing internal operations.
7. Account Activity Review
Beyond product intros, I started building a second power tool for account activity review.
This included:
- account status filters
- sample order flags
- sample request timelines
- search term timelines
- tightened review layout
- account summary normalization
That proved the platform could support multiple internal tools under one access and navigation model.
Design engineering approach
Make AI reviewable, not magical
The tool does not ask users to blindly trust generated output. It gives them structured imports, previews, manual product selection, editable documents, image controls, and draft recovery.
Turn messy inputs into guided workflows
mNotes, account activity, product metadata, and sample requests were all operationally meaningful but inconsistent. The design work was turning those inputs into clear steps with review and correction points.
Build a platform, not a single tool
The power-tools shell, registry, auth guard, tool access model, Convex data layer, and Retool webhook layer were designed so future tools could share the same foundation.
Impact
North Coast Pontifex created a new internal-tooling platform for high-leverage operational workflows.
It provided:
- AI-assisted distributor product-introduction generation
- structured mNote import and product-meta parsing
- product API integration and manual product search
- document drafts, autosave, public links, and collaborator workflows
- cached product/company generation for consistency and efficiency
- branded public document sharing
- sample request capture and timeline support
- Microsoft Entra auth and per-user tool access
- Retool webhook integration for account and mNote workflows
- account activity review tooling
- tests around critical workflow and access behavior
What made this hard
The hard part was balancing speed, AI usefulness, and operational trust.
The system had to deal with:
- messy pasted notes and partial account data
- product metadata quirks
- generated copy that needed guardrails
- public sharing without exposing internal state
- auth complexity across Microsoft, Convex, and app routes
- legacy/internal workflow dependencies through Retool
- multiple tools sharing one platform shell
Why it matters
This project shows full-stack design engineering applied to internal operations: identify a repetitive expert workflow, design a guided tool around it, integrate the backend systems, add AI where it helps, and build enough platform foundation that the next workflow is easier to ship.
It is a strong example of building AI into real business work without treating AI as the whole product.