Does self-hosting Twenty cost less than Attio for your team?
For most teams, self-hosting Twenty costs less than a per-seat plan only when seat count is high enough to outweigh the servers and administration time. The open source core can be self-hosted for free, so the recurring bill is the infrastructure and people needed to run it. Twenty's Docker Compose guide runs a server, a worker, PostgreSQL and Redis, and asks for at least 2 GB of RAM because insufficient memory can crash processes. Those costs are compute, storage and backups, plus staff hours for patching, upgrades, monitoring and restores. The outcome depends on three inputs: how many people use the CRM, how much data it holds, and whether your team already runs PostgreSQL and Redis well.
Compare seats with Twenty's hosted plans before assuming self-hosting wins. Twenty's pricing page lists Pro at 9 US dollars per user per month and Organization at 19 US dollars per user per month, with Organization adding row-level permissions, SAML or OIDC SSO and audit logs. Enterprise starts from 50,000 dollars a year and adds single-tenant isolation, IP allow-listing, SCIM provisioning and an SLA. As an illustrative case, a 20-seat team on Organization would pay 380 dollars a month, or 4,560 dollars a year, before any hosting. Re-cost your Attio renewal the same way: ask Attio for the per-seat price of the plan that lifts your object and record limits, then compare that total with your self-hosted running cost. All Twenty plans include unlimited custom objects, fields, views and records, so data volume alone does not force a tier change.
Treat the self-hosted figure as a set of components, not a single number. One-time costs include deployment, data migration, configuration of custom objects and workflows, and security hardening. Recurring costs include compute and storage, off-site backups with tested restores, monitoring, dependency updates, and the hours needed to review each Twenty release. Ask any implementation partner, including DeployOpen, for a written, fixed-scope quote that names each component, who performs it, and what ongoing support covers after go-live. Confirm server sizing with your own cloud or data center team, because the 2 GB figure is a minimum from the Docker Compose guide, and production load needs testing in your environment.
Which cost components move on each side
This table compares the cost components of staying on Attio with those of self-hosting Twenty, marking each as one-time or recurring. Read it as a checklist of who gets paid for what, then price each row with your own seat count, data volume and staff. Twenty's free self-hosted core removes the per-seat line, but servers, upgrades, backups and administration move to your budget.
| Cost component | Attio (SaaS) | Self-hosted Twenty |
|---|---|---|
| Seat licenses | Recurring per-seat subscription, paid to Attio for every user who needs access | None for the open source core, per Twenty's pricing page |
| Plan upgrades from object and record limits | Recurring, if growth pushes you into a higher plan with larger object and record allowances; confirm current limits with Attio | None for limits, since all Twenty plans include unlimited custom objects, fields and records |
| Paid Twenty cloud or Enterprise tiers | Not applicable | Recurring if chosen; a separate option to price, including Enterprise terms such as SLA and SCIM, confirmed in writing |
| Servers and hosting | Included in the subscription | Recurring infrastructure for the server, worker, PostgreSQL and Redis, sized against Twenty's stated 2 GB minimum RAM and your load |
| Backups and disaster recovery | Largely handled by the vendor; confirm export and retention terms | Recurring storage and tooling, plus one-time design of backup and restore testing |
| Upgrades and maintenance | Handled by Attio | Recurring staff time or retainer for frequent Twenty releases, including testing before each upgrade |
| Administration and security | Vendor-managed platform | Recurring internal or partner effort for access control, patching and monitoring |
| Migration labor | Not applicable | One-time effort to export, map objects and relations, import records and rebuild automations |
What moves the comparison most
The cost gap between Attio and self-hosted Twenty depends on a few variables that change with the business. Seat count, data growth, the plan tier needed for security features, uptime expectations and the team's skills all push the total in one direction or the other. Check each one against your own numbers before comparing invoices with server bills.
Seat count and growth
Attio is priced per seat, so every added salesperson, analyst or read-only stakeholder adds a recurring line item. Self-hosted Twenty has no per-seat licence fee in its free core, so the server and administration cost stays roughly flat as headcount grows. The cost gap widens with headcount, so model the seat count for the next renewal period, not just today. Ask Attio for the per-seat price for each plan you would need, and confirm whether guest or view-only users are billed.
Object and record volume
Attio limits objects and records by plan, and crossing a limit can force an upgrade to a higher tier. Twenty's pricing page says all plans include unlimited custom objects, fields, views and records, and the self-hosted core carries the same model. Growth in contacts, companies and custom objects therefore raises your Attio tier cost, while on Twenty it mainly raises database storage and backup size. Measure record growth per quarter and ask Attio which limit you will hit first.
Plan tier for SSO and audit logs
Security requirements can decide the plan more than seat count does. Twenty's pricing page places SAML or OIDC SSO, audit logs and row-level permissions in its Organization tier, and SCIM provisioning and single-tenant isolation in Enterprise. Your Attio plan may gate similar controls at different tiers, so list every control your security team requires and find the lowest Attio plan that includes all of them. Confirm the exact feature mapping with each vendor in writing.
Availability requirements
A hosted SaaS CRM carries the vendor's uptime commitment, while a self-hosted Twenty instance puts uptime on your team. A highly available setup needs redundant application servers, managed or replicated PostgreSQL and Redis, and tested failover, all of which add infrastructure and labour cost. If the business can tolerate a few hours of downtime during a business day, a single well-backed-up server may be enough. Define the recovery time and recovery point you need before pricing the self-hosted option.
Hosting and database skills
Twenty runs on NestJS, React, PostgreSQL, Redis and a worker process, so the team needs TypeScript and PostgreSQL operations skills. SuiteCRM and EspoCRM, by contrast, run on PHP with MySQL or MariaDB, so the stack choice can shift the cost of hiring or training. If nobody on the team can operate PostgreSQL, Redis and a job queue, budget for an implementation partner or ongoing support. Count the hours the current team already spends on similar services before assuming the self-hosted option is cheaper.
Data export and migration effort
The one-time cost of moving is set by how cleanly the data leaves Attio. Records, lists and relations need to be exported view by view, and enriched fields may not export, so they may need to be rebuilt manually. Automations and integrations also need recreating in Twenty. Estimate this effort by listing every object, list view and automation in use, then ask for a fixed-scope migration quote that covers each one.
How plan limits turn into upgrade costs
The Attio bill is driven less by the list price of one seat than by what happens when the team grows and the data grows with it. Per-seat pricing scales linearly with headcount, but object and record limits tied to each plan can force a move to a higher tier even when the number of users has not changed. A sales team that adds a custom object for partners, another for implementation projects, and a steady stream of imported records can reach a plan ceiling without adding anyone to the account. Before comparing totals, confirm with Attio which limits apply to the exact plan you need, how records are counted, and whether archived or deleted records still count against the cap.
Each plan step carries a cost that is easy to miss in a first estimate. Moving up a tier usually changes the per-seat rate for every user, not only the ones who need the extra capacity, so a limit hit by a single workspace can multiply across the whole seat count. Ask for a written quote that shows the price at your current seat count, at the seat count you expect in twelve months, and at the tier you would need once your record volume crosses each limit. Also ask which features, such as SSO, audit logs or advanced permissions, sit only in higher tiers, because a security requirement can force an upgrade just as surely as a record count does.
Twenty's pricing page states that all plans include unlimited custom objects, fields, views and records, along with REST and GraphQL APIs and webhooks, and that the open source core can be self-hosted for free. That removes the object and record ceiling from the comparison, but the self-hosted total still includes the servers, PostgreSQL and Redis, backups, upgrades and the staff time to run them. The fair test is to put your Attio plan and seat count beside the Twenty options you would actually buy, then add the infrastructure and administration effort on the Twenty side. Treat any Twenty cloud or Enterprise figure as something to confirm against the current Twenty pricing page at the time of purchase.
How to build the comparison with your own numbers
This sequence turns the cost components into a side-by-side model built from your own Attio seat counts, record volumes and plan features. The result is a fixed-period total for staying on Attio and a total for running Twenty, so the decision rests on your data rather than on list prices alone.
Count seats by role and tier
Ask your Attio workspace admin for the full list of active users, grouped by the seat type or plan tier each one occupies today. Include sales, customer success, and any read-only or guest users, because they can still drive plan requirements. Pull the same headcount from your finance records to confirm that no licenses are paid for and left unused. The step is complete when you have one number per tier and a matching count from finance that you can reconcile.
Export current object and record volumes
Inventory every object, including custom objects, and the record count for each one, using the workspace settings and the exports described in the Attio export guide. Record how many records sit in each object and how many relations link them, because object and record limits are the usual reason a plan upgrade appears. Keep the counts dated so you can project growth later. The step is complete when you hold a table of objects, record counts and growth assumptions that your admin has checked.
List the Attio plan features you rely on
Work with the people who run workflows and integrations to list every Attio feature your team uses day to day, such as automations, data enrichment, SSO, audit or permission controls, and API access. For each feature, note which plan includes it according to Attio's current pricing page, and record any feature that would force a move to a higher tier. Confirm these details against your own contract, since plan terms change. The step is complete when each feature is tied to a plan and an owner.
Price Twenty's paid tiers per user
Decide whether you need only the free self-hosted core or one of Twenty's paid cloud plans, based on the features listed in the previous step. If you consider a paid plan, multiply the per-user prices published on Twenty's pricing page by your seat count from the first step, and note which plan includes SSO, audit logs or row-level permissions. Ask Twenty for written terms if the list does not match your needs. The step is complete when you have a monthly figure for each Twenty option you are considering.
Size servers and database from the minimum
Start from Twenty's documented minimum for the Docker Compose self-hosting setup, which asks for at least 2 GB of RAM, and note that memory shortfalls can crash processes. Add capacity for PostgreSQL storage based on your record counts, plus Redis, a separate worker process, backups and a staging copy if you want one. Ask your infrastructure team or DeployOpen for a sizing review based on your volumes, and price the hosting you already run or plan to buy. The step is complete when you have a server and storage line with a recurring cost and a named owner.
Estimate migration and administration hours
Estimate one-time migration work for exporting objects and list views, rebuilding relations and automations, and importing records, along with the recurring hours for upgrades, backups, monitoring and user support. Use your own team's rates or a written quote from an implementation partner, and do not rely on a generic figure. Note which tasks would need to be repeated for each upgrade of Twenty, since the project ships frequent releases. The step is complete when each activity has an hour estimate, a rate source and a split between one-time and recurring costs.
Compare totals over a fixed period
Choose one fixed period, such as 36 months, and add the Attio seat and plan costs for that period against the Twenty cloud or self-hosted costs, including server, administration, migration and any paid plan. Show one-time costs in the first period and recurring costs every month, and run a second scenario with higher seat counts and record volumes to see where each option breaks even. Have finance review the spreadsheet before anyone treats it as a decision basis. The step is complete when both options show the same period, the same assumptions and a sensitivity check.
Questions buyers ask before comparing costs
Is the self-hosted Twenty core free to run?
The open source core can be self-hosted at no license fee, according to Twenty's pricing page, and that page states that all plans include unlimited custom objects, fields, views and records plus REST and GraphQL APIs and webhooks. The costs that remain are the ones you pay to others: servers or cloud instances, storage and backups, the time your engineers spend installing and patching, and any outside help you buy. Twenty's Docker Compose guide runs a server, a worker, PostgreSQL and Redis and asks for at least 2 GB of RAM, so budget for that stack plus headroom for growth. Confirm the current license terms in the repository before you deploy, because some files carry an Enterprise license header and fall under a commercial license.
What does the work need from our team?
Your team needs people who can run a TypeScript application backed by PostgreSQL and Redis, plus someone who owns the business side of the data model. Expect these roles to be involved:
- Platform or DevOps engineers for hosting, TLS, backups, monitoring and upgrades
- An administrator who maps your Attio objects, lists and permissions to Twenty's objects, views and roles
- A developer or integration owner for the REST and GraphQL APIs, webhooks and any workflows you rebuild
- A business owner who signs off on data cleanup and the cutover date
If none of these skills sit in-house today, the gap usually decides the cost more than the license does.
How long does a migration from Attio take, and what drives it?
The duration depends on how many objects, list views, relations and automations you run, how clean your data is, and how many integrations write to Attio. No duration figure is supplied for this migration, so ask any implementation partner to base its estimate on a written inventory of your workspace. The main drivers are the number of custom objects and their relations, the volume of records, fields that do not export cleanly such as enriched data, rebuilding automations, and the testing window your sales operations team needs before cutover. Ask for the timeline as a fixed-scope plan with milestones, not a single number.
Can our team migrate and run Twenty without outside help?
A capable platform team can install and run Twenty alone, especially if it already operates PostgreSQL and Redis. The harder parts are the data model rebuild, the cutover and the operating routine after go-live. Check these points honestly before deciding:
- Can someone own backups and tested restores for both PostgreSQL and the workspace data?
- Does someone have time to follow the Twenty release cadence and apply upgrades? Releases are frequent, for example v2.48.0 followed v2.47.0 by one day.
- Is there a named owner for security patches and access reviews?
If the answer to any of these is no, a retainer for upgrades and support may be a better fit than a one-off project.
What should a quote for this migration include?
A useful quote states scope, deliverables and timeline in writing before work starts, which is how DeployOpen works on most engagements. Ask that the quote cover:
- Environment: where Twenty runs, sizing for the server, PostgreSQL and Redis, and the backup approach
- Data: an inventory of objects, lists and relations, and a plan for records that export blank
- Migration: import method, test loads, cutover steps and a rollback plan
- Integrations: which workflows, webhooks and API connections are rebuilt and tested
- Handover: documentation, training and whether support or upgrades continue as a retainer
Any quote without these items leaves the cost comparison incomplete.
When do Twenty's paid cloud or Enterprise plans make more sense?
Paid plans make sense when you want Twenty to host and operate the service and the work of running infrastructure costs more than the subscription. Twenty's pricing page lists Pro at 9 US dollars per user per month, Organization at 19 dollars per user per month with row-level permissions, SAML or OIDC SSO and audit logs, and Enterprise from 50,000 dollars a year with single-tenant isolation, IP allow-listing, SCIM provisioning and an SLA. Compare those per-user figures with your own seat count and with the cost of your hosting and admin time. Confirm current prices on the pricing page, since they can change. If you require SCIM or a contractual SLA, the Enterprise tier is the only one that lists them.
Which costs recur every year, and which are one-time?
One-time costs include the migration project, the data mapping, the integration rebuild and initial testing. Recurring costs include servers and storage, backups, monitoring, staff time for upgrades and security patches, and any retainer or subscription you choose. Attio costs recur per seat and rise when object and record limits force a plan upgrade, so the comparison should project both sides across several years rather than one budget cycle. Ask your finance team to model seat growth and record growth alongside the hosting estimate.
How do we check the self-hosted costs in our own environment?
Start with a pilot in your own cloud account or data center using a copy of representative data, then measure memory, storage, backup duration and restore time. Twenty's self-hosting documentation sets 2 GB of RAM as the minimum for the Docker Compose setup, but production load, record volume and integrations will change the sizing. Record the hours your engineers spend on installation, upgrades and incidents during the pilot. Those measurements replace assumptions in the cost model and give you a basis for comparing a quote.
What the migration adds to the first-year cost
The migration is a one-time project that moves Attio objects, lists and records into a self-hosted Twenty instance and proves the data is complete before anyone relies on it. Each step below produces a check that tells you whether the cost has been paid down or still needs budget. The sequence also surfaces the data that will need separate handling, such as enriched fields.
Inventory objects, lists and automations in Attio
Someone who administers the Attio workspace lists every standard and custom object, every list and saved view, each relation between objects, and every workflow or automation that reads or writes records. Record the record counts per object and note which users depend on each view. The step is complete when the inventory is a written document that a second administrator has reviewed and that maps each item to a planned Twenty object, view or workflow. This inventory is also the baseline for estimating the rebuild effort in your quote.
Identify enriched fields that may not export
Attio enrichment data, such as values pulled from third-party providers, may not appear in standard CSV exports. Confirm with Attio exactly which fields are exported and which are not, and record each one as a separate task with its owner. Decide whether each value will be re-enriched in Twenty through a provider you license, kept as static text, or retired. The step is complete when every enriched field has a documented decision, because those costs recur if a provider subscription is needed after the move.
Export each object and list view
Export each object and list view from Attio as CSV or Excel, following the view-by-view checklist in your export procedure, and keep the files in a versioned location with restricted access. Confirm that the users performing exports have the permission Attio requires. The step is complete when the export file count matches the inventory and each file's row count matches the record count recorded in step one. Store a copy of the exports as a rollback reference.
Rebuild objects, fields and relations in Twenty
An administrator recreates each object, field type and relation from the inventory in your self-hosted Twenty workspace, using the custom objects and fields that Twenty supports. Map each Attio attribute to a Twenty field and note any type that does not translate directly. The step is complete when a test workspace contains every object and relation from the inventory, and a reviewer has signed off on the field mapping. Rebuilding is usually the largest share of internal or partner labor, so track hours against this step.
Import records and resolve relations
Import the exported files into the matching Twenty objects in dependency order, so parent records such as companies exist before the people or deals that reference them. Resolve relation identifiers that do not match between systems and log every row that fails. The step is complete when each import reports its success and error counts, and every error is either fixed or accepted by the data owner in writing. Keep the import scripts or mappings so the process can be repeated for a final cutover.
Rebuild workflows and automations
Recreate each Attio automation that matters to the business as a Twenty workflow, using the workflow automation and webhook features that Twenty provides, and replace any integration that relied on an Attio-specific connector. Document which automations were retired on purpose. The step is complete when each automation in the inventory has been rebuilt or formally retired, and a test record has triggered each rebuilt workflow as expected. Confirm any third-party connectors still needed by your team and their own licensing terms.
Test imported records with the business owners
Sales, marketing and customer success owners compare a sample of records and views in Twenty against Attio, checking field values, relations, permissions and the reports they rely on. Test role-based permissions with real user accounts, not administrator accounts. The step is complete when each owner signs off on their objects, and any gaps are logged with an owner and a fix. Only after sign-off should the team plan a final delta export and cutover.
