Open Source Salesforce Alternatives

Rather than one monolithic system, Odoo is a suite of web-based open source business applications. Each covers a part of running a company, and because they are stand-alone applications, a team can adopt the single app it needs today instead of committing to everything at once.

The apps also integrate with one another, so installing several of them adds up to a full-featured open source ERP rather than a set of tools that happen to share a login. That is the path most deployments take over time.

The main apps span the usual departments.

• Sales and customers: CRM and Point of Sale for pipelines and in-person transactions.
• Finance: billing and accounting.
• Operations: warehouse management, manufacturing and project management.
• Web presence: a website builder and eCommerce.
• People and marketing: human resources and social marketing applications.

A standard installation follows the setup instructions in the official documentation. Learning the software is covered by Odoo eLearning and a business game for the operational side, while developers start from the developer tutorials. Nightly builds and a public runbot show the state of the master branch at any moment, and security issues have their own responsible disclosure process rather than the issue tracker.

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.

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.

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.

Open Mercato starts from an observation about AI code assistants. They generate code, but they do not decide where it goes, how it should be layered, or whether it stays consistent across a team of fifty engineers. This framework supplies the missing structure, together with business modules that have already been written.

It is a Next.js App Router codebase in TypeScript, using zod for validation, Awilix for dependency injection, MikroORM for per-module entities and migrations, and JWT sessions for authentication. Each feature lives in its own module directory with auto-discovered pages, APIs, CLI commands, translations and database entities.

The framework is opinionated about the AI workflow and the domain layer alike.

• Architecture-aware harness: agents receive skills for adding a data table, building design-system forms, or shipping a whole feature with tests.
• Spec-first development: specifications ship inside the repository, which is what makes agent output reproducible.
• Domain modules: CRM, sales, order management and encryption arrive ready, leaving the remaining fifth of the work to you.
• Multi-tenancy: tenant and organization scoping on every entity and API, with organization trees and visibility controls.
• Feature-based RBAC: per-role and per-user feature flags combined with organization scoping, gating any page or API.
• Events and indexing: domain events with persistent local or Redis subscribers, and hybrid JSONB indexing across base and custom fields.

Running it needs Node.js 24, PostgreSQL and Redis, most easily through the supplied Docker Compose file, after which one command installs, builds, seeds and starts everything. A live demo helps anyone weighing it against a commercial platform.

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.