Open Source HubSpot Alternatives

Most CRMs are configured through a settings screen and drift away from the rest of your engineering practice. Twenty treats the CRM as software you build, ship and version like anything else in the stack, handing technical teams primitives instead of checkboxes.

Work starts by scaffolding an app with the Twenty CLI and declaring objects, fields and views in TypeScript. A deal object with its name, amount and close date is a few lines of definition, and one publish command pushes it into your workspace, privately if you choose.

The building blocks cover the shape of a modern CRM.

• Objects and fields: typed definitions describe your data model rather than a fixed schema.
• Views and layouts: how records display is customizable and travels with the app itself.
• Workflows: automation sits alongside the data it acts on, inside the same workspace.
• AI agents and chat: agents work over CRM records, documented for developers and users alike.
• Version control: apps are published and tracked the way the rest of your code is.

The backend is NestJS with BullMQ, PostgreSQL and Redis, and the frontend is React with Jotai, Linaria and Lingui. Self-hosting uses Docker Compose, a local setup guide covers contributors, and a hosted workspace spins up in under a minute.

Built on Laravel and Vue.js, Krayin CRM is a free and open source framework for small and medium businesses and for enterprises that want complete customer lifecycle management running on their own servers.

The framework is hand tailored on Laravel, a PHP framework, with Vue.js driving the interface, so a team that already writes PHP can extend it without learning a second stack. Its codebase follows a modular approach, which keeps custom work separate from the core.

The admin side is deliberately plain, and the pieces around it are what a sales team touches daily.

• Admin panel: descriptive and simple, with a dashboard as the landing view.
• Custom attributes: extend records with the fields your pipeline actually uses.
• Email parsing: incoming mail is parsed through Sendgrid.
• WhatsApp extension: an add-on lets the administrator generate leads from a WhatsApp number.
• VoIP extension: another add-on places trunk calls over broadband and handles inbound routes.
• Multi tenant SaaS: an extension serves several businesses from one instance with isolated data.

Running it needs Apache 2 or NGINX, 3 GB of RAM or more, PHP 8.3, Composer 2.5 and MySQL 8.0.32 or newer. You install with Composer, set the app URL, mail and database values in the environment file, then run the install command. Managed cloud hosting is sold separately for teams that would rather not touch infrastructure at all.

Most CRMs are a database with a form in front, and the AI ones bolt a chat box onto the form, leaving the real work of finding out what is true and writing it down to a person. Comp AI CRM inverts that. The agent is not a feature of the CRM; the CRM is where the agent keeps its notes.

The agent is its own deployment, built on eve, a filesystem-first framework for durable agents where a tool is a file and a skill is a markdown file. It works from a queue rather than a request, leasing due rows so two dispatchers take disjoint work and a dead run frees its row when the lease expires. Close the browser and it carries on.

A few decisions shape what it will and will not do.

• Nothing is guessed: no tool accepts a confidence score, tools report what they observed and a ledger prices the evidence.
• Weak evidence waits: strong evidence writes to the record, weak evidence becomes a suggestion a human settles.
• Sandbox without exits: the shell has deny-all egress and never receives the database credentials.
• Optional sources: it reads your own threads, meetings and signature blocks before any vendor.
• Visible work: every contact, company and deal has an Agent tab showing steps taken and leads discarded.

It runs on Bun with Postgres under an MIT license. Every outside data source is optional, so an install with no API keys still works from the evidence already in your own mailbox.

Mautic is the largest open source marketing automation project, and it exists so an organization can run integrated campaigns without renting a platform to do it. Contacts, segments and campaign history live in a database you administer, on a server you control.

The project frames its aim as being the most privacy-focused, accessible and extendable marketing automation product on the market. It was verified as a Digital Public Good in 2024, and both the frontend and the backend are meant to be customized rather than merely configured.

What that self-hosted position actually buys is worth being specific about.

• No third-party dependency: campaigns run on infrastructure you own instead of a vendor SaaS.
• Data ownership: contact records and campaign history sit in your own database.
• No vendor lock-in: the software can be modified, extended or left behind at will.
• Unlimited segmentation: segments and automation are not capped by a pricing tier.
• Multi-channel reach: additional channels arrive without additional cost.
• Custom integrations: anything the project does not ship can be built against it.

Installing with Composer is the recommended route, and a prepackaged production download exists for anyone who would rather stay away from the command line. A DDEV configuration ships in the repository, so a single start command runs the first-run process and configures the application automatically.

One caution from the maintainers deserves repeating. Source outside a tagged release should be treated as alpha and kept out of production, where a schema drifting from the release line can break the updater and require manual repair.

Most CRMs are either too complicated, too generic, or priced steeply enough per seat that half the team never gets an account. Frappe CRM aims at that gap, covering core sales activity with an interface designed to stay clean and organized, and no cap on users.

It runs on the Frappe Framework, a full-stack web application framework, with the interface built on Frappe UI, a Vue-based component library. Extensibility is the point of that foundation, so the tool is meant to be shaped around a team's own process rather than dictating one.

Day-to-day selling happens across a small number of screens.

• All-in-one lead and deal page: activities, comments, notes and tasks gathered in one place instead of scattered across tabs.
• Kanban view: drag leads and deals between stages to see where the pipeline actually stands.
• Custom views: personal filters, sorting and column choices saved for quick access.
• Telephony: built-in Twilio and Exotel integrations for making, receiving and recording calls, with Exotel routing through an agent's mobile phone.
• WhatsApp and ERPNext: message customers through the Frappe WhatsApp app, and connect to ERPNext for invoicing and accounting.

The stable branch tracks Frappe and ERPNext versions 15 and 16. Self-hosting runs from an easy install script that produces a production-ready instance in about five minutes, with Docker Compose files and a local bench setup for development work, and managed hosting on Frappe Cloud for teams that would rather not touch a server.

erxes describes itself as an experience operating system, one self-hosted place to run marketing, sales, operations and support instead of paying separate subscriptions for each. The project positions itself against HubSpot, Zendesk, Linear and Wix.

The codebase is an Nx monorepo. Backend services speak GraphQL Federation and tRPC over Node.js, TypeScript, MongoDB, Redis and BullMQ, while the interface is assembled from React micro-frontends built with Rspack and Tailwind CSS through Module Federation.

A core carries inbox, contacts, products, segments, automation and documents, and a marketplace of plugins layers business capability on top.

• Frontline: omnichannel conversations, tickets and tasks for customer-facing teams.
• Operation: projects, team resources and cycle management in a single workspace.
• Sales: landing pages, forms, pop-ups and embeds that capture visitors as qualified leads.
• Content: headless websites, e-commerce, scheduling, knowledge base and help center publishing.
• Vertical plugins: accounting, finance, tourism, property and team modules for specific industries.

Generating a new plugin scaffolds both the backend schema and the Module Federation frontend remote, so extending the platform follows one path rather than several. Running it needs Node.js 18 or newer, pnpm 8 or above, MongoDB and Redis, with an API gateway fronting the core and every plugin API. Docker Compose gets an instance up quickly for anyone evaluating it.

EspoCRM gathers what a business knows about its customers into one interface: leads, contacts, sales opportunities, marketing campaigns and support cases, held together in a single record of the relationship. Being open source, the code handling that data can be read by the people trusting it.

Architecturally it is a single-page frontend talking to a REST API backend written in PHP. The backend follows SOLID principles with interfaces, static typing and generics, and is checked at PHPStan level 8. Metadata sits at the center of the application, described with JSON Schema so an IDE can autocomplete every parameter.

A few qualities tend to decide people on it.

• Customization: custom entities, fields, relationships and buttons make it a platform for business applications, not only a CRM.
• Interface: the UI is uncluttered and quick to learn, which matters when a whole sales team has to use it.
• REST API: integrating with other applications is straightforward.
• Developer reach: extensions and custom integrations are a first-class use, with separate documentation for developers.
• Transparency: nothing about how records are stored or processed is hidden from the operator.

Running it takes PHP 8.3 through 8.5 and either MySQL 8.0 or later, MariaDB 10.3 or later, or PostgreSQL 15 or later. Installation can be manual, scripted or containerized, with a Traefik guide for the last case. EspoCRM is licensed under GNU AGPLv3.

Most CRMs hand you a settings page and hope it covers what you need. Atomic CRM hands you the source instead. It is a full-featured CRM you fork, run locally, and change wherever the defaults do not fit, from custom fields and themes down to replacing individual components.

The front end is React with shadcn-admin-kit, and the backend is Supabase, which brings Postgres, a REST API, attachment storage, and authentication in one local stack. One make install command sets up both halves including a local Supabase instance, and make start runs the Vite dev server, the API, and Postgres in Docker. Unit tests use Jest and end-to-end tests use Playwright.

The feature set covers what a small sales team tracks.

• Contacts and notes: contact records with notes capturing details as they surface.
• Deals: a Kanban board for visualizing and tracking the sales pipeline.
• Tasks and reminders: follow-ups and deadlines attached to the work they belong to.
• Email capture: CC the CRM on a message and it is saved as a note automatically.
• Activity history: interactions aggregated into a single log.
• Access control: sign-in through Google, Azure, Keycloak, and Auth0.

Because customization means forking, staying current becomes its own problem, and the project answers it with a shadcn registry: one command pulls upstream component changes into your fork, so commit first and review the diff against your own edits. Local development needs Make, Node 22 LTS, and Docker, and a hosted demo is online if you want to look before cloning.

At the center of Relaticle, a self-hosted CRM, sits a production-grade MCP server. Connecting an agent to customer data normally means writing an integration against someone else's API and hoping the vendor keeps it working; here the tools ship with the CRM and the records never leave your server.

The application is built on Laravel and Filament, so operators get a Livewire interface and an ecosystem many PHP teams already know. Requirements are PHP 8.5 or later, PostgreSQL 17 or later, Composer 2, and Node.js 22 or later, with Redis for queues and optional during development. Installation is a git clone followed by a single composer command.

The project names its strengths in five areas.

• Agent-native infrastructure: an MCP server with 37 tools, plus a REST API with full CRUD, schema access, activity history, and pipeline analysis.
• Customizable data model: 22 field types covering entity relationships, conditional visibility, and per-field encryption, with no migrations needed.
• Multi-team isolation: five layers of authorization with team-scoped data and separate workspaces.
• Modern tech stack: Laravel 13, Filament 5, PHP 8.5, and more than 2,000 automated tests.
• Privacy first: self-hosted under AGPL-3.0, with your data staying on your own server.

A self-hosting guide covers Docker and manual deployment. The repository ships English only, but the codebase is ready for internationalization, so a fork can drop a language directory into place and translate the whole app. It fits developer-led teams, AI-forward startups, and smaller businesses that want agent integration without vendor lock-in.

Warpdrive reimplements the business development workflow of Pipedrive as software you run yourself. It is single-tenant by design: your own box, your own Postgres and object storage, your own Google Workspace for sign-in. Customer data never leaves your infrastructure and there is no per-seat bill.

It is built with Next.js and React on TypeScript, Drizzle ORM over Postgres, and tRPC with TanStack Query. Realtime updates ride a self-hosted WebSocket server backed by Postgres LISTEN and NOTIFY, files go to MinIO or any S3-compatible store, and email runs through the Gmail API.

The scope stops at the core loop and says so plainly.

• Pipeline: a kanban board with custom stages, multiple pipelines, weighted totals, rotting-deal indicators and saved filters.
• Deal workspace: one timeline holding activities, notes, files, email and the full change history.
• Contacts: people and organizations with JSONB custom fields, firmographics, a leads inbox and CSV import with an undo step.
• Two-way Gmail: send and receive with thread linking, templates, signatures, merge fields, scheduled send, and open and click tracking.
• Team platform: role-based permissions, user management, notifications and basic funnel statistics.

Self-hosting is a single-box Docker topology of app, WebSocket server, worker, Postgres, MinIO and Caddy, which provisions TLS automatically. Products, invoicing, multi-currency, web forms and native mobile apps are deliberately out of scope, and integration tests run against a real Postgres rather than a mock.