> For the complete documentation index, see [llms.txt](https://docs.buzzy.buzz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.buzzy.buzz/the-building-blocks/mcp/buzzy-builder-mcp/customize-crm-template.md).

# Customize the CRM template

Start from Buzzy's CRM Template and use Buzzy Builder MCP to create a separate, tailored CRM without editing the source template.

Use Buzzy's public [**CRM Template**](https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238) when you need a practical starting point for accounts, contacts, opportunities, pipeline stages, tasks, notes, dashboards, and agent-assisted sales workflows.

The template is a source app, not the app you should edit. Buzzy Builder MCP helps your AI coding agent inspect that source, create a separate target app, and adapt the target through reviewable stages.

{% hint style="info" %}
CRM Template is a public managed template. Ask your agent to search for the exact title **CRM Template**. If template search is temporarily unavailable, give it the [public CRM Template URL](https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238) or app ID shown in that URL. The source is read-only through Builder MCP mutation tools.
{% endhint %}

## Quick start: from no account to your own CRM

This is the shortest path if you have never used Buzzy before. You can build and review your CRM before paying for a Deployment. Purchase a Deployment when you are ready to run the app for your team.

### 1. Sign in to Buzzy

Open the [Buzzy workspace](https://app.buzzy.buzz) and sign in or create an account. Keep this browser window open.

### 2. Preview the CRM Template

Open the [live CRM Template](https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238). Use it to decide which pipeline stages, fields, dashboards, roles, and approvals you want to keep or change.

Do not edit the template itself. Your AI coding agent will create a separate app for your business.

### 3. Connect your AI coding agent to Builder MCP

Follow [Getting Started with Builder MCP](/the-building-blocks/mcp/buzzy-builder-mcp/getting-started.md). The recommended setup uses the Buzzy MCP URL and OAuth, so you do not need to paste an access token into a prompt.

Builder MCP is Buzzy's recommended AI-assisted creation path for this workflow. This is an **Adapt** workflow: the agent copies the CRM Template into a separate target app and edits the target artifacts directly inside Codex, Claude Code, Cursor, Antigravity, or another compatible agentic tool. You do not need Buzzy AI generation credits for those direct adaptation edits; the connected tool's own subscription, usage allowance, billing, and terms apply.

If you instead start from scratch, or explicitly ask Buzzy to generate new artifacts, sample data, or screens during adaptation, you need separately purchased Buzzy AI credits or a supported bring-your-own OpenAI API key for those generation steps. See [Builder MCP: Create vs Adapt](/working-with-buzzy/buzzy-ai/ai-tokens-and-pricing.md#builder-mcp-create-vs-adapt).

AI results and costs vary with the CRM you are building, the instructions you provide, the selected model, and current model performance. AI can make mistakes, so review and test each major stage before publishing.

When your client shows the Buzzy tools, ask it to bootstrap your project before it changes the app.

### 4. Give the agent one starter prompt

Paste this prompt into Codex, Claude Code, or another MCP-capable coding agent:

```
Use Buzzy Builder MCP to create a separate CRM for my business by adapting the
public CRM Template at
https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238.

Do not edit the source template. Ask me one question at a time about my sales
process, roles, pipeline stages, fields, dashboards, and approval rules. Show me
an adaptation plan before making changes. Stop for my approval at each major
stage, and give me a preview link when the first useful version is ready.
```

Answer the agent's questions in plain language. You do not need to design the database or screens yourself.

### 5. Review the app before paying for production

Use the preview link from the agent to test the main path:

1. create or open an account and contact
2. create an opportunity and move it through the pipeline
3. add a task or note
4. confirm the right people can see and change the right information
5. approve or reject an AI-proposed change when approval is required

Ask the agent to fix anything that is confusing or incorrect before you publish.

### 6. Purchase a Deployment

When the CRM is ready for your team, review the [Medium Deployment price and purchase options](https://www.buzzy.buzz/pricing/#medium), then follow [Create and manage Deployments](/working-with-buzzy/buzzy-deployment-and-app-stores/create-and-manage-deployments.md).

In the Buzzy workspace:

1. open **Deployments**
2. choose **Create Deployment**
3. name the Deployment and select its region and domain option
4. choose a plan and complete the subscription checkout
5. wait until the status changes from **Provisioning** to **Active**

A single Deployment can host this CRM and additional Buzzy apps. Review the current [Deployment plans and pricing](https://www.buzzy.buzz/pricing/#medium) before purchase.

### 7. Publish the CRM to your Deployment

Follow [Publish your app to your Deployment](/working-with-buzzy/buzzy-deployment-and-app-stores/publish-to-deployment.md): open your adapted CRM, choose **Publish**, select the Active Deployment, and confirm.

After publishing, open the Deployment URL and repeat the five checks from step 5 before inviting the rest of your team.

{% hint style="warning" %}
If you cannot see **MCP Access**, open your profile menu and go to **Account Settings → Developer → MCP Access**. If your Deployment is not available when publishing, confirm that its status is **Active**. Do not paste tokens, client secrets, or payment details into an AI prompt.
{% endhint %}

## Builder MCP and Custom MCP do different jobs

* **Buzzy Builder MCP** lets an AI coding agent build, inspect, and change the CRM application definition.
* **Buzzy Custom MCP** lets an approved AI client work with the finished CRM's permitted data and actions.

Customize the application with Builder MCP first. Configure Custom MCP only after the target CRM, permissions, and approval boundaries are ready. See [Buzzy Custom MCP implementation](/the-building-blocks/mcp/buzzy-custom-mcp/implementation.md) for that runtime connection.

## Before you begin

You need:

* a Buzzy workspace with Builder MCP access
* an MCP-capable coding agent such as Codex or Claude Code
* a git repository for the local Buzzy mirror and review history
* access to the public **CRM Template** through managed-template search or its public app URL
* a short description of your sales process, users, required fields, and approval boundaries

If your agent is not connected and bootstrapped, complete [Getting Started with Builder MCP](/the-building-blocks/mcp/buzzy-builder-mcp/getting-started.md) first.

## 1. Find the CRM Template

Ask the agent to search the managed templates before creating an app:

```
Use Buzzy Builder MCP and search the available app templates for "CRM".
Prefer the template named "CRM Template" when it is available.
Summarize the matching templates and stop if more than one is a plausible source.
Do not edit any source template.
```

If managed-template search does not return the template, provide its public app URL:

```
Use this Buzzy app as the read-only CRM source:
https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238
Confirm that you can inspect it, but do not modify it.
```

## 2. Describe the CRM you actually need

Tell the agent what to retain, remove, change, and add. At minimum, define:

* the users and roles
* account and contact ownership
* opportunity stages and required fields
* tasks, notes, activities, and follow-up rules
* dashboards and pipeline views
* sensitive fields and who may view or update them
* actions that require human approval
* source-template words, sample data, or features that must be removed

Example:

```
Create a separate CRM for a software-services sales team by adapting CRM Template.

Keep accounts, contacts, opportunities, tasks, notes, and the pipeline Kanban.
Replace all template company names, sample records, images, and widget-specific copy.
Add opportunity type, decision criteria, blockers, next action, renewal date,
relationship health, and an approval queue for AI-proposed updates.

Account managers may edit their opportunities. Sales leaders may review the full
pipeline and approve consequential AI-proposed changes. The CRM must remain the
system of record. Do not let an AI agent send customer messages or change commercial
commitments without explicit human approval.
```

## 3. Ask for an adaptation plan before changes

For template work, the agent should use Buzzy's template-adaptation workflow rather than asking Buzzy to regenerate the target from scratch.

Ask it to:

1. create a new, separate target app
2. keep the CRM Template source mirror read-only
3. inspect the source brief, flows, data model, theme, blueprint, screens, functions, and widgets
4. write a source-to-target concept map and adaptation plan
5. identify what will be kept, removed, replaced, and added
6. call out privacy, permission, migration, and source-contamination risks
7. stop for review before adapting the first major artifact

Useful prompt:

```
Create a new target app for this CRM adaptation. Treat CRM Template as read-only
reference material. Before changing the target, inspect the source and prepare a
template-adaptation plan that maps source concepts to the target, lists keep/remove/
replace/add decisions, and defines the review gates. Show me the plan and stop.
```

## 4. Adapt the target in review gates

The agent should work in this order:

| Stage       | What to review                                                                                                                        |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Brief       | The target users, CRM scope, authentication, permissions, business outcomes, and agent boundaries are explicit.                       |
| Flows       | Sign-in, account work, opportunity progression, follow-up, review, approval, rejection, and exception paths match the target process. |
| Data model  | Tables, fields, relationships, ownership, lifecycle state, and audit information support the accepted flows.                          |
| Sample data | Realistic target-domain records cover normal, empty, overdue, at-risk, approval, and exception states.                                |
| Theme       | The CRM is readable and credible for its audience; status does not depend on colour alone.                                            |
| Blueprint   | The screen inventory, navigation, overlays, authentication surfaces, and public/private posture are complete.                         |
| Screens     | Real target IDs and bindings are used; source wording, data, imagery, widget assumptions, and navigation are gone.                    |

At each major gate, the agent should update the target artifact locally, push it to Buzzy, re-read the persisted result, verify it, and then stop for approval.

Do not approve a stage that still reads like the source template with a few renamed labels.

## 5. Build the target screens against real target data

After the target blueprint is accepted, the agent should:

1. ensure the blueprint's screen set exists as real target screens
2. wire home, sign-in, onboarding, reset-password, and public-screen settings using the persisted target screen IDs
3. adapt one coherent screen family at a time
4. use Buzzy toolkit layouts and native components as the default structure
5. update code widgets only after confirming their target tables, fields, shared state, and actions
6. verify the live target app with realistic sample data

For a CRM, start with a small, useful operating path such as:

```
CRM dashboard -> opportunity pipeline -> opportunity detail -> add note or task
-> review proposed update -> approve or reject -> refreshed system-of-record view
```

## 6. Verify the adapted CRM

Ask the agent to check the real runtime, not only the stored artifacts.

Minimum checks:

* sign-in and onboarding work for the intended users
* account, contact, and opportunity list/detail/create/edit paths work
* pipeline actions open the correct target records
* tasks, notes, and follow-ups preserve account and opportunity context
* role and sensitive-field permissions are enforced
* AI recommendations are distinguishable from authoritative CRM facts
* approval-required actions cannot bypass the human decision
* empty, loading, denied, validation-error, and failure states are understandable
* screens reflow at 320 CSS pixels and remain keyboard operable
* no source-template wording, images, sample records, IDs, or widget assumptions remain

For an accessibility-targeted release, follow [Accessibility at Buzzy](/accessibility.md#buzzy-builder-mcp) and record automated and manual evidence for the exact release scope. Automated checks alone are not a WCAG conformance claim.

## 7. Connect the CRM to an AI client when it is ready

Once the target CRM is tested and its permission model is accepted, use Buzzy Custom MCP to expose only the tools the AI client needs.

Start with bounded read operations, then add write operations deliberately. Separate low-risk actions such as summarising an opportunity from consequential actions such as changing a stage, creating a customer commitment, or sending a message.

Read [Buzzy Custom MCP implementation](/the-building-blocks/mcp/buzzy-custom-mcp/implementation.md) before enabling runtime agent access.

## Complete starter prompt

```
Use Buzzy Builder MCP to customize Buzzy's CRM Template into a CRM for [company].

First connect and bootstrap this repo. Search the available managed templates for
"CRM Template"; if template search is unavailable, use this public source URL:
https://app.buzzy.buzz/app/f0b74bcf298df925fe75d238. Never edit the source template.

Create a separate target app. Inspect the source artifacts and prepare a detailed
template-adaptation plan. Map source concepts to our CRM, list what to keep, remove,
replace, and add, identify privacy and permission risks, and define the review gates.

Our users are [roles]. Our required pipeline stages are [stages]. We need [entities,
fields, dashboards, and workflows]. These actions require human approval: [actions].
Remove all source-specific wording, data, images, widgets, and bindings that do not
belong in the target.

Work in the required artifact order and stop for approval after the brief, flows,
data model, theme, and blueprint. Generate realistic target sample data after the
data model is accepted. Ensure and wire real target screens before adapting them.
Verify the final runtime with screenshots and functional tests before reporting it
complete.
```

For the commercial rationale behind this workflow, read [We Stopped Paying for CRM Seats—and Built an Agent-Ready CRM](https://www.buzzy.buzz/post/replace-per-seat-crm-with-agent-ready-buzzy-app/).

## Agency-specific example

Use the [agency CRM example](/the-building-blocks/mcp/buzzy-builder-mcp/crm-agency-example.md) for a focused adaptation brief covering proposals, retainers, next actions and acceptance checks. Follow this guide for setup and artifact order.