esköre™

InsightsCRM Development16 min readNovember 16, 2026

Build a Custom CRM with Laravel: What Tutorials Skip Before Launch

Most Laravel CRM tutorials stop at the contacts table. This guide covers the data model, quoting, queues, backups and integrations that decide whether your team still uses the system after launch.

CRM Development at Eskore
Photo by Unsplash on Unsplash

If you plan to build a custom CRM with Laravel, most tutorials stop once the contacts table saves and the forms render. What they leave out decides whether your team still uses the system six months after launch: quoting, follow-up discipline, background jobs, backups and the integrations that keep data out of spreadsheets. This guide covers that layer. It is written for the owner who signs off the budget and the technical lead who will maintain the code, whether the business is a services firm in Austin or Raleigh, a trades business near Toronto or a logistics team in New York.

Quick answer: should you build a custom CRM with Laravel?

A custom Laravel CRM makes sense when your sales or operations process does not fit an off-the-shelf tool without workarounds, or when you need quoting, a client portal or workflows tied to your own systems. Laravel is a sound choice for this. It ships with authentication, validation, queues and a large package ecosystem, and it is widely used for business software.

If your sales process is standard, your team is small and your integrations are common, configuring an existing platform is usually less work to start. Our CRM development services cover both routes, and we will tell you which one fits before any build begins.

Where open-source Laravel CRMs such as Krayin fit

Krayin comes up most often in roundups of open-source Laravel CRMs, and it is worth a look before you write any code. Open source means the code is public and you can adapt it. It does not mean there are no running costs. You host it, install it, patch it and own every change you make. The project's code is on Krayin's GitHub page.

Its advantage is a working contact, company, lead and activity model on day one. Its cost is that you adapt someone else's architecture rather than designing the data model around your process.

Requirements change between releases. As of 16 November 2026, recent third-party reviews list a current release around v2.2.5, requiring PHP 8.3 or later with MySQL 8. Older reviews still describe Laravel 10-era versions, so check the release date on anything you read. Krayin is self-hosted, so you run it on your own server or VPS. Do not budget for a managed Krayin plan until the vendor confirms one in writing, because the listings we reviewed disagree on whether one exists.

If the project fits your process, it can save weeks. If your developers end up patching core behaviour every month, that is the signal to build.

Data model: contacts, companies, deals and activities

Get the schema right before you write a single screen. Most painful CRM rebuilds trace back to a data model that treated a deal as a row with a status text field.

A workable core has five tables:

Table Holds Key relationships
companies Business name, address, industry, owner Has many contacts and deals
contacts Person's name, email, phone, source Belongs to a company; has many deals
deals Title, value, currency, expected close date, owner Belongs to a company, a contact and a pipeline stage
pipeline_stages Stage name, position, pipeline Has many deals
activities Type (call, email, note, task, status change), body, user, timestamp Polymorphic: attaches to a contact, company or deal

Three decisions in this schema are expensive to change after launch.

First, store currency on each deal. If you quote in CAD and USD, a deal's value needs its currency, and reports need to convert consistently. Store money as integers in minor units (cents) to avoid floating-point errors.

Second, link deals to a stage by foreign key, not a status string. A stage is a position in a process with its own name and order. A foreign key lets you rename, reorder and report on stages without touching deal records.

Third, make activities polymorphic. A call logged against a contact and a quote sent against a deal should live in one table, so the timeline on any record shows everything that happened to it.

Keep the examples tied to the business. An illustrative plumbing firm in Austin needs site visits and quote revisions. An illustrative property management company in Denver needs unit-level records and renewal dates. An illustrative services firm in New York needs proposal stages and retainer renewals. The same tables serve all three.

Keep pipeline stages as data

It is tempting to hard-code stages as an enum or a constant array. That works until the operations manager wants to split "Quoted" into "Proposal sent" and "Verbal yes", and the request waits for a developer and a deploy.

Store stages in their own table, with a position and a pipeline reference. Operations managers can then add, rename or reorder stages in the admin screen. Record every stage change in a separate history table, with the old stage, new stage, user and timestamp. That history is what lets you report on how long deals sit in each stage, which is the question most owners eventually ask.

This also makes migration from spreadsheets far easier. Each spreadsheet column that represents a stage becomes a row in pipeline_stages, and the import maps old values to the new IDs. Do not import stages as free text.

Activity history and the audit trail

The most common complaint about CRMs is that leads disappear. Usually they did not disappear. They were in someone's inbox, on a phone or in a notebook, and nothing forced them into the system.

Log every call, email, note and status change with a user and a timestamp. Make activities append-only: once written, they cannot be edited or deleted through the normal interface. If someone logged the wrong thing, they add a correction entry. That is less convenient than editing a record, but the history can be trusted when a dispute comes up.

Activities also give managers something to review. A deal with no activity for ten days is a conversation for the Monday meeting.

Adoption is the harder problem. A log only helps if people write to it. Keep the activity types few, make logging a single action from the contact screen, and show managers the gaps rather than punishing individuals for them. If logging still slips, why your sales team won't use the CRM covers the usual causes and what to change first.

Roles, permissions and team access

Laravel gives you two built-in tools: policies, which control access to a model, and gates, which control access to a single action or area. For most CRMs, a policy per model (contacts, deals, invoices) is the right starting point.

Start from what each role must see, then write the rule. A sales rep sees only their own deals. A manager sees the team's deals and can reassign them. Finance sees invoices and payment status but not the full contact list. Filter these in the query itself, using local query scopes, rather than hiding rows in the interface. A row hidden in the UI can still be reached through the API or a direct URL.

Consider Spatie's laravel-permission package when roles are numerous, change often or need to be managed by non-developers. It adds a dependency, so do not reach for it on day one if you have three roles that rarely change. Write the policies first and move to the package when the role table becomes painful to maintain.

Whatever your geography, decide who can export data. Exports are the easiest way for a CRM to leak customer records, so restrict them, log them and rate-limit them. We work from offices in Toronto, Thornhill, London and New York, so we are used to teams split across time zones, and that makes access rules and handover notes more important, not less.

Building a custom Laravel CRM: the steps in order

The sequence below shows the order of work. It does not replace the framework documentation, and each step depends on the one before it.

Set up on a supported Laravel and PHP version

Use the current supported major version of Laravel and the PHP version that release requires. Laravel publishes its support policy in its documentation, so check it on the day you start. Do not copy an older tutorial that targets a previous major version, even if the code looks similar. Policy registration, middleware and configuration details have changed between releases.

Set up version control, environments (local, staging, production) and a deployment process from the first commit. Deployment done by hand on day one becomes deployment nobody dares to do on day 200.

Migrations, models and test data

Write migrations for the core schema described above. Add foreign keys and indexes on the columns you will filter by: owner, stage, email and the activity timestamp.

Build models with explicit relationships, and add casts for money and dates. Seed the database with realistic test data: several hundred contacts with inconsistent phone formats, duplicate emails, deals in every stage and some with no activity. Clean data hides bugs. Messy data exposes them.

Run your import against a copy of the spreadsheet data before you touch production. Most migration failures are predictable: duplicate emails, blank owners, dates in three different formats.

Lead capture: validation and deduplication

Every lead source needs one endpoint that does three things: validates the input, checks for an existing record and writes what it receives.

Validate required fields, email format and phone format. Normalise before you compare: lowercase the email and store phone numbers in one format, such as E.164. Deduplicate on normalised email first, then phone, and decide what happens when the two match different contacts. Send ambiguous cases to a review queue rather than guessing.

Decide now what happens when a submission fails. Do not drop it. Store the raw payload in an inbound table, flag the failure, notify someone and retry where it is safe to do so. A lost lead is the outcome you are designing against.

Protect public endpoints with rate limiting, and protect webhook routes with signature verification. Field mapping from a website form is covered in the integrations section below.

Pipeline board, follow-up tasks and reminders

Follow-up tasks are what stop a lead getting lost. Build them as first-class records: a title, an assignee, a due date and a link to the contact or deal. Show each rep a daily list and each manager an overdue list.

Schedule reminders with Laravel's scheduler and send them through notifications. Check that the scheduler actually runs. A cron job that silently stops means no reminders go out, and nobody notices until a deal goes cold. The monitoring section covers how to catch that.

A useful business rule: a deal cannot move to "Quoted" without a next task dated in the future. It is a small rule, but it builds the follow-up habit into the workflow instead of relying on memory. If the repetitive parts of follow-up should run automatically, AI automation for follow-up workflows is the relevant service.

Quoting and invoice records

Most tutorials stop at a single quote table. Real businesses need versions and approval states.

Model a quote with line items, a version number and a state: draft, sent, accepted, declined or expired. Each revision creates a new version rather than overwriting the old one, so you can show what the client saw. When a quote is accepted, convert it into an invoice record that copies the line items and agreed totals. For a contractor-focused take on this, see CRM for contractors with quoting and invoicing.

Be clear about what the CRM owns. It can hold the invoice record for sales purposes. The general ledger, tax handling and payment reconciliation usually belong in an accounting tool, synced through its API or a connector. Keep that boundary explicit, because accounting rules are where small systems cause expensive problems. If the business needs full finance operations, ERP quoting and invoicing is the better fit.

The production layer tutorials skip

The difference between a demo and a production system is what happens when something goes wrong. The items below are where that difference shows up.

Queues for sync, webhooks and background jobs

Email sync, webhook handling and calls to third-party APIs should not run inside the web request. A slow API or a dropped connection will stall the user's screen or lose the event entirely.

Push these tasks onto Laravel queues. Use a driver you can monitor, such as Redis with Horizon, or the database driver for smaller volumes. Configure retries with backoff, and make sure failed jobs are logged and visible.

Webhooks need two more things. Verify the signature before doing anything else. Make processing idempotent by storing the external event ID, so a duplicate delivery does not create a duplicate deal. Most webhook providers retry on failure, which means the same event can arrive more than once.

Backups, monitoring and error alerts

Back up the database and uploaded files daily, store copies off the server and encrypt them. A backup you have never restored is a hope, not a backup. Test a restore at least monthly, time it and write down the steps.

Add uptime monitoring for the public site and the CRM login. Add error tracking that sends alerts to a channel someone reads. Monitor the scheduler too: a heartbeat check that fires when the reminder job has not run recently catches the silent failure described above.

Hosting choices decide how much of this you can run yourself. Managed VPS hosting covers the operational side for teams that do not want to run servers.

Security basics for a CRM holding customer data

A CRM holds names, contact details, deal values and often payment-related records. Treat it accordingly.

Validate all input on the server, not just in the browser. Give the application's database user only the permissions it needs, so a compromised app cannot drop tables. Keep secrets such as API keys and database passwords out of the repository, in environment or secret storage, and rotate them when people leave. Rate-limit public forms and login pages. Keep an audit log of logins, exports and permission changes. Require two-factor authentication for admin accounts.

Privacy and data-handling obligations depend on what data you hold, where your customers are and who controls the data. Take advice from qualified counsel before you decide what to collect, keep and export. Recording calls raises consent questions of the same kind.

Server hardening is a separate job from application security. If you self-host, VPS setup and hardening covers the server layer.

Integrations that drive adoption

Integrations matter more than most owners expect. If a rep has to re-key a lead from the website into the CRM, the CRM will fall behind within a month. The integrations below are the ones that decide adoption.

Website forms and lead routing

Every form submission should create or update a contact, create a deal in the right pipeline, assign an owner using a rule you can explain and create a follow-up task. Run all of that in the queued job described above, so a slow CRM never blocks a visitor.

Field mapping is where errors hide. Form fields rarely match CRM fields, and a mismatched field can quietly store a company name in the phone column. Test every field with a real submission before launch. How to connect a website form to your CRM automatically covers routes, field mapping and failure cases in detail. If the website itself needs rebuilding to capture better leads, web development for lead capture is the relevant service.

Email, calendar and phone

Email and calendar sync usually works through the provider's API, such as Gmail or Microsoft 365. Run it through queues, log emails against contacts and decide what gets synced: all mail, or only messages to and from known contacts. The second option protects privacy and keeps the database smaller.

For calls and SMS, log inbound and outbound events through Twilio's webhooks, with call duration, direction and any recording link stored against the contact. Twilio CRM integration for call and SMS logging sets out the pattern. Recording calls brings consent questions, so get advice before you switch it on.

Zapier, Make and accounting tools

No-code connectors such as Zapier and Make are enough when volume is low, the mapping is simple and an occasional failed run is an inconvenience rather than a problem. They are quick to set up and easy for operations managers to change.

A custom integration in Laravel is safer when volume is high, when errors have financial or customer consequences, when you need to transform data in ways connectors cannot or when you need full control over where data flows. Accounting sync usually falls into this group, because a duplicated invoice is expensive to unpick. For workflow automation across these tools, see AI automation.

What drives the cost and timeline

We do not publish a headline price in this article. The right number depends on scope, and a headline figure would mislead more than it helps. Two quotes for what looks like the same CRM can differ widely because the scope underneath them differs. The factors that move cost are these:

  • Number of roles. Each distinct role with its own views and permissions adds design and testing work.
  • Integrations. Each external system adds API work, error handling and ongoing maintenance.
  • Quoting complexity. Simple quotes are one thing. Versioned quotes, approvals, tiered pricing and tax rules are another.
  • Data migration. Clean spreadsheets import quickly. Years of inconsistent records take real effort.
  • Portal access. A client-facing portal is a second application with its own security model.
  • Currency and locations. Multi-currency quoting, and teams across several offices or time zones, add rules to design and test. A single-office build in Denver has fewer of these than a build spanning Toronto and New York.
  • Hosting and operations. Monitoring, backups and maintenance are ongoing costs, not one-off ones.

On timeline, avoid a single range. Describe the work in phases and estimate each one: discovery and written scope, core build (data model, pipeline, tasks), integrations, testing with real data and launch with a supported handover period. Published estimates for CRM builds vary widely, so the phase plan is what lets you compare proposals fairly.

At Eskore, we agree a written scope, a fixed price and a launch date before work starts. You own the code and the accounts from the beginning, including the domain, hosting, repository and third-party API accounts. Those terms belong in the proposal you sign, not in a conversation you have later.

Hosting, security and ongoing maintenance

There are three broad hosting routes.

Managed hosting means a platform looks after the servers, updates and most of the operations. It costs more per month and gives you less control, but it removes a category of work from your team.

A VPS is a dedicated virtual server that you or a partner configure and maintain. You get control over the stack and usually lower running costs, in exchange for responsibility for patching, backups and monitoring. This is the route most custom CRMs take at small and mid-sized scale. See VPS hosting and VPS setup and hardening.

Cloud platforms such as AWS, Azure or Google Cloud make sense when you need scaling, several environments or specific compliance controls. They bring more configuration and cost management, so they suit teams with the skills to run them. See cloud setup and migration.

Maintenance budgets vary widely, so agree them in the scope rather than leaving them open. Plan for security patches, Laravel and PHP upgrades, dependency updates, monitoring response and small feature changes. Ask any vendor what the maintenance agreement includes and what counts as a new feature.

Settle ownership now. Make sure the business holds the repository, the domain, the hosting account and every third-party API key in its own name. Handover is far easier when nothing depends on one person's login, and it protects you if you ever change developers or agencies.

When to configure HubSpot, Zoho, Salesforce or Pipedrive instead

Configuring an existing platform is often the right answer. Here is a fair way to decide.

Configure first when:

  • Your sales process is standard: stages, deals, follow-ups and reports that the platform already handles.
  • The team is small and does not need heavy custom workflows.
  • Your integrations are common, such as email, calendar, accounting and the main website forms.
  • The vendor's per-seat pricing and data model suit your business, and you are comfortable with the trade-offs.

Build when:

  • Your process is unusual enough that you keep working around the platform.
  • Data ownership, residency or export control matters, and you want the database under your own control.
  • Quoting depends on your own pricing rules, approvals or product configuration.
  • You need a client portal or reporting layer that the platform cannot provide without expensive add-ons.
  • You must connect to in-house systems the platform does not support well.

Consider a hybrid when most of the process is standard but one or two areas are not. A configured platform can run contacts and the pipeline, while custom Laravel services handle quoting, portals or reporting. The trade-off is two systems to keep in sync, so the integration between them needs the same care as any other.

If you are weighing a build against a configured platform, our CRM development team can review your process before you commit. Whichever route you choose, write the process down first. It is the one part of the decision that does not change.

Next step: scope your custom CRM with Eskore

If you are deciding whether to build a custom CRM with Laravel, our team will review your sales process, recommend whether to configure a platform or build, and walk through the data model, integrations and hosting that would apply to your business. The call is free and lasts 30 minutes, and you receive a written scope, a fixed price and a launch date before any work starts. Book a free 30-minute scoping call.

Questions

Need help with this?

Talk to our crm development team.