How to build a CRM with AI

A simple CRM is easier to get right if you avoid trying to model every sales process at once. Start with the minimum that lets a team track relationships and next steps.

For a first version, define:

• Users: just you, or a small internal team
• Core records: contacts, companies, deals
• Actions: create, edit, search, filter, add notes
• Views: dashboard, contacts, companies, deals, contact detail

Write down what each screen should do.

A practical first set of screens looks like this:

• Dashboard: totals for contacts, open deals, deals closing this month
• Contacts: table with name, company, email, phone, status, next follow-up date
• Companies: list of companies with industry and owner
• Deals: pipeline-style list or simple table with stage and value
• Record detail: notes, recent activity, related company or deal

Also decide what does not need to be in version one. Common examples are email sync, calendar sync, role permissions, import tools, and reporting beyond a few summary cards.

AI can write a decent first pass of the interface, but the app becomes easier to improve if the data structure is clear from the start.

For a lightweight CRM, keep the schema simple:

• contacts: id, first_name, last_name, email, phone, company_id, status, next_follow_up, notes
• companies: id, name, industry, website, owner, notes
• deals: id, name, company_id, contact_id, stage, value, expected_close_date, notes

If more than one person will use the CRM, add sign-in and think about ownership fields such as created_by or assigned_to.

If the CRM is only for internal use and does not charge customers, you probably do not need payments. Stripe matters only if your CRM itself needs paid access, invoices, or a checkout flow.

This is also the point to choose web or mobile first. Most CRM work is easier to review on desktop, so a website is the sensible starting point. In Moremade, websites are generated as real React + Tailwind code.

The first prompt should describe the product, the main screens, the style, and the behaviour. Be specific enough that the generated app has structure, but not so detailed that you spend longer writing the prompt than testing the result.

A good first prompt names:

• the app type
• who uses it
• the main entities
• the screens
• the fields to show
• the visual style
• whether to use mock data first or connect real data now

Example first prompt:

Build a simple internal CRM web app for a small sales team. Use a clean, professional layout with a left sidebar and top search bar. Create screens for Dashboard, Contacts, Companies, Deals, and a Contact Detail view. Use mock data first. Contacts should include name, company, email, phone, status, and next follow-up date. Companies should include name, industry, website, and owner. Deals should include name, company, contact, stage, value, and expected close date. Add forms to create and edit records, plus search and filter controls. Use React and Tailwind with a practical business UI.

In Moremade, you describe the app in plain language, the AI agent writes the source code, and you can review a live preview straight away.

The first version is usually a draft, not the final shape. The useful habit is to change one area at a time: layout, table columns, forms, navigation, or record detail.

Moremade gives you a live preview, a visual inspector for pointing at elements and changing them, and a code view. That makes it easier to tighten the UI without rewriting the whole brief.

Use short, specific follow-up prompts. For example:

• "Change the Contacts screen to a denser table layout with sortable columns for name, company, status, and next follow-up date. Keep row actions for edit and view."
• "Add a detail drawer when clicking a contact row. Show notes, related company, related deals, and a timeline of recent activity using mock entries."
• "Make the Deals page a kanban board with columns for Lead, Qualified, Proposal, Negotiation, and Won. Keep a table toggle for users who prefer list view."

A few practical checks during this stage:

• Are labels consistent across screens?
• Are create and edit forms using the same field names?
• Can you search by person and company?
• Is important information visible without opening every record?
• Does the app look like an internal tool rather than a marketing site?

If something is wrong in one component, ask for that specific correction instead of requesting a full rebuild.

Once the mock-data version feels right, connect real data. Moremade has a built-in connector for Supabase, which covers database, sign-in, and file storage.

For most CRMs, Supabase is the next logical step because you need persistent records and usually some form of authentication.

At this stage, ask for:

• Supabase tables for contacts, companies, and deals
• forms wired to create and update records
• list pages wired to fetch data
• basic sign-in if more than one person will use it
• record relationships, such as a contact belonging to a company

Keep the first auth setup simple. Email/password is often enough for an internal CRM.

Only add Stripe if your app actually needs payments. An internal CRM usually does not. If you are building a client-facing CRM or a paid portal, Moremade can connect Stripe checkout with prices you set, but it should not be part of the default build unless there is a clear requirement.

Even if the main experience is desktop, people will still open a CRM on a phone to check a number, update a deal, or add a note after a meeting.

Run a few realistic tasks in the preview:

• add a new contact
• search for a company
• update a deal stage
• edit a next follow-up date
• open a record detail page and add notes

On mobile, focus on the basics:

• navigation is reachable
• tables do not become unreadable
• key actions are visible without horizontal scrolling where possible
• forms are usable with touch inputs
• date fields and dropdowns are easy to tap

If mobile matters heavily, ask the AI to adapt the layout for small screens. If you need a dedicated mobile app later, Moremade can generate React Native (Expo) apps, but many teams should validate the CRM as a web app first.

When the app is usable, publish it. Moremade can publish in one click to a free yourname.moremade.ai subdomain. On paid plans, you can connect a custom domain, and domains can also be bought inside Moremade.

Before publishing, check:

• page titles and navigation labels
• empty states when there are no contacts or deals
• error states on forms
• whether test data is still visible
• whether sign-in is required for private data

Common mistakes to avoid:

• Starting too big: teams often ask for pipelines, reports, permissions, imports, and automation in the first pass. Build a clean core first.
• Skipping the data model: if contacts and companies are not defined clearly, the UI becomes inconsistent fast.
• Using vague prompts: phrases like "make it better" produce weaker results than naming the exact screen and change.
• Adding payments without a reason: Stripe is useful when needed, but many CRMs do not need it.
• Publishing mock data by accident: switch to real Supabase data before sharing the app internally.

You can export the full source code as a ZIP at any time or push it to GitHub, so you are not tied to hosting the app only inside Moremade.