The MCP Practitioner Course · Lesson 5 of 7

Real-World Integration Patterns for SMBs

> ~3 hours · helpdesk, CRM, finance — three patterns you can take to clients next week

By the end of this module you'll have the shape of three production-ready MCP server patterns that fit 90% of SMB engagements. The patterns repeat; the specifics matter. Pick the one that fits your first real engagement and use it as the template.

---

Pattern 1 — Helpdesk integration

Helpdesk is the highest-impact first MCP pattern for most SMBs. Tickets are the busiest place in the business and the most repeatable shape of work. An agent that can read tickets, classify them, draft replies, escalate, and close routine ones saves hours every week and converts into client gratitude faster than any other category.

Integration target: ConnectWise PSA, Autotask, Freshdesk, or Zendesk. Same code with a different SDK underneath.

The five tools:

  • `list_tickets` — filterable by status, priority, requester, age. Scope: `helpdesk:read`.
  • `get_ticket` — full ticket detail including conversation history. Scope: `helpdesk:read`.
  • `add_ticket_note` — append an internal note. Scope: `helpdesk:write`.
  • `reply_to_ticket` — send a customer-facing reply. Scope: `helpdesk:reply`. Annotated `destructiveHint: true`.
  • `close_ticket` — mark resolved. Scope: `helpdesk:close`. Annotated `destructiveHint: true`.

Resist the urge to add more. Five tools is the right surface area.

Two prompts:

  • `/triage-queue` (argument: `limit`, default 20) — classifies the N oldest open tickets and drafts a triage memo. Saves the dispatcher 30–60 minutes/day.
  • `/draft-reply` (argument: `ticket_id`) — drafts a context-appropriate reply in the company's voice. Not sent automatically; the human edits and uses `reply_to_ticket`.

Auth boundaries: `helpdesk:read` + `helpdesk:write` for triagers (most users). `helpdesk:reply` + `helpdesk:close` only for senior support and supervisors. Map IdP roles to scope bundles. The model honors the user's scopes — a triager calling `reply_to_ticket` gets a 403 even if it tries.

Server-level usage hint (surfaces in the model's system prompt): > *"This server connects to the company's helpdesk. Use it to triage tickets, look up specific tickets, draft replies, or close tickets. Do not reply to customers without explicit user confirmation. Replies represent the company's voice — match the tone of past replies in the same ticket."*

Operational notes specific to helpdesk:

  • Cache `get_ticket` aggressively (60-second TTL). SMB helpdesks have tight per-account API rate limits.
  • Subscribe to ticket-updated webhooks; invalidate cache on update.
  • Audit logging on every `reply_to_ticket` and `close_ticket` is non-negotiable.
  • Rollout order: start with read-only tools and the two prompts. Hold back `reply_to_ticket` and `close_ticket` until you've watched the agent in production for a week. Earn trust before granting destructive scopes.

---

Pattern 2 — CRM integration

The shape is similar to helpdesk but the destructive surface is larger. CRM data drives revenue forecasts, commission calculations, and external touchpoints with customers. The auth boundary needs to be tighter and the tool descriptions need to be more disciplined.

Integration target: HubSpot (most common at 10–150 employees), Salesforce (100+), or Pipedrive (sales-led under 50).

The seven tools:

  • `find_contact` — search by email, name, company. Scope: `crm:read`.
  • `get_contact` — full record with activity history. Scope: `crm:read`.
  • `list_deals` — open deals filterable by stage, owner, value. Scope: `crm:read`.
  • `get_deal` — full detail. Scope: `crm:read`.
  • `log_activity` — record a call, meeting, or email. Scope: `crm:write`.
  • `update_deal_stage` — move a deal in/out of a pipeline stage. Scope: `crm:write_pipeline`. `destructiveHint: true`.
  • `create_followup_task` — schedule a follow-up for the deal owner. Scope: `crm:write`.

Conspicuously absent: `create_contact` (manual to avoid duplicate explosions), `delete_*` (manual only), `send_email` (use the email server, not the CRM, for separation of concerns).

The flagship prompt: `/score-leads` — argument `days` (lookback). Pulls all new leads, scores them against the firm's ideal customer profile (maintained as a resource on the server), returns a ranked list with reasoning. Sales managers use this every Monday morning.

The IP lives in the prompt template. The methodology — what counts as a strong lead, what disqualifies, how to weight industry vs company size vs source — gets encoded once and applied across the whole sales team. This turns an individual sales lead's judgment into a reproducible firm capability. Often the wedge that justifies the entire engagement.

Operational notes specific to CRM:

  • Custom fields. SMB CRMs are heavily customized. Read the customer's field schema dynamically. Hard-coding will break the moment they rename a property.
  • Pipeline stage names vary per customer. Don't hard-code "Discovery → Demo → Proposal." Pull the customer's actual stages and present them as enum values.
  • Sync vs sync-of-record. Don't write fields the customer's CRM is already syncing from another system (marketing automation, accounting). Write conflicts.
  • Rate limits. HubSpot's per-account API limit is 250k calls/day on Pro. The server's `find_contact` can burn 1k calls per agent conversation. Cache aggressively.

---

Pattern 3 — Finance integration

Finance integrations are the most commercially valuable and the most operationally dangerous of the three. Every tool that writes to finance can produce a real loss — duplicate payment, misposted invoice, incorrectly classified expense — that the client will absolutely notice. The discipline gradient between this pattern and the others is steep.

Integration target: QuickBooks Online (most SMBs under 50), Xero (international and service-business SMBs), or NetSuite (100+ with finance maturity).

The eight tools — read-heavy by design:

  • `list_invoices` — filterable. Scope: `finance:read`.
  • `get_invoice` — full detail. Scope: `finance:read`.
  • `get_aging_report` — AR aging summary. Scope: `finance:read`.
  • `list_customers` — search and filter. Scope: `finance:read`.
  • `list_transactions` — filterable, with category and account breakdown. Scope: `finance:read`.
  • `create_invoice_draft` — creates a DRAFT (not sent). Scope: `finance:write_drafts`. `destructiveHint: true`.
  • `send_invoice` — sends an existing draft. Scope: `finance:write_send`. `destructiveHint: true`. Always requires explicit user confirmation.
  • `add_expense_categorization` — categorizes an existing expense. Scope: `finance:write_categorize`.

Conspicuously missing: no `void_*`, no `delete_*`, no `refund_*`, no `create_payment`, no `edit_invoice` after send. These are not agent operations. They live in the finance team's manual workflow. The MCP server's job is to surface, summarize, draft, and categorize — never to alter live financial state.

Three scopes, layered carefully:

  • `finance:read` — for everyone in the engagement.
  • `finance:write_drafts` — for AR clerks and bookkeepers. Drafts only; nothing sent.
  • `finance:write_send` + `finance:write_categorize` — for the controller and senior bookkeeper only. These move money or affect ledgers.

The flagship prompt: `/ar-followup-draft` — argument `days_overdue`. Pulls overdue invoices, drafts a personalized follow-up email per invoice using customer history, returns drafts for human review. The bookkeeper reviews, edits, and sends. AR cycle compresses meaningfully.

Operational concerns specific to finance:

  • Audit logging is regulatory. Finance audit logs need 7-year retention in most jurisdictions. Tamper-evident log with cryptographic signing. This is one of the few places where the security checklist shifts from "best practice" to "compliance requirement."
  • Currency and locale. Validate currency on every `create_invoice_draft`; reject if it doesn't match the customer's default.
  • Multi-entity. A 30-person SMB might have 3 legal entities. Make entity an explicit parameter on every write tool. Never cross entity boundaries silently.
  • Period locking. When the bookkeeper closes a month, the model should not be able to write to that period. Honor the system's period-locking flags.

Why finance MCP is the highest-margin engagement: Finance integrations are harder to scope and ship than helpdesk or CRM. They take longer. They have more compliance friction. They demand more discipline. That is precisely why the engagements price higher. A typical SMB finance MCP engagement runs $35K-$55K vs $15K-$25K for helpdesk. The barrier to entry is the moat.

---

A pattern that repeats across all three

The methodology is identical. The seven fields per workflow are identical. The agent-fit rubric is identical. What changes is which fields produce the highest-leverage findings in each industry — but the shape of the engagement (audit → top-3 selection → 4–12 week implementation → managed-service retainer) holds across all three patterns.

This is good news for productizing. You're not selling a different service in each industry. You're selling the same service applied to a different SaaS surface.

---

Pre-work for Module 6
  • Pick which of the three patterns you'll lead with as your first paid engagement
  • Identify one client (real or fictional) where that pattern fits
  • Sketch the audit deliverable for that client — the workflows the agent would touch, the time-saved-per-week claim, and the price you'd quote

Module 6 is where this becomes a business — pricing, SOWs, runbooks, the renewal motion.

Previous: Security, Governance, and the Things That Will Get You Sued · Next: Productizing MCP as a Service