Loomio

Collaborative decision-making, honestly reviewed. Built by a worker cooperative since 2011. Not a startup chasing growth metrics.

TL;DR

• What it is: An async decision-making platform — not chat, not project management, but a specific tool for structured proposals, votes, and their permanent record [website].
• Who it’s for: Cooperatives, nonprofits, membership organizations, and distributed teams that need more than a Slack poll but less than a full governance software suite [website].
• Cost savings: Loomio SaaS pricing is per-seat; self-hosted is free under AGPL-3.0. For organizations running 50+ member votes monthly, self-hosting eliminates per-seat costs entirely [github].
• Key strength: The only mainstream open-source tool that treats the reasoning behind a decision as first-class data — not just the vote count, but why people voted that way [website].
• Key weakness: Narrow focus is both its strength and its ceiling. If you need real-time chat, task tracking, or document collaboration alongside decisions, you’ll still need separate tools [website].
• License: AGPL-3.0 — you can self-host, but you can’t build closed-source products on top of it without opening your code [github].

---

What is Loomio

Loomio is a collaborative decision-making tool built specifically for the moment between “we need to decide something” and “the decision was made and recorded.” It does not replace your Slack or your Notion. It fills the gap between them — the structured deliberation that neither tool handles well [website].

The core workflow is simple: someone creates a thread with context, people discuss asynchronously, then a proposal is raised. Members vote (agree, abstain, disagree, or block depending on the proposal type), and critically, they attach reasons to their votes. The outcome — the decision, the reasoning, the dissent — is permanently stored and searchable [website].

What makes Loomio unusual in this space is its origin. It was founded in 2011 in Aotearoa New Zealand and is run as a worker cooperative — Loomio Cooperative Limited. The company has operated this way for over a decade, which partly explains both its deliberate product philosophy and its relatively modest GitHub star count (2,529 as of this review) [github][website]. It’s not VC-backed and not optimizing for hockey-stick growth. It’s optimizing for sustainable, collaborative organizations that need reliable decision infrastructure.

The software is AGPL-3.0 licensed — meaningfully open source, though the copyleft requirement means any modifications you make and distribute must also be open [github]. Hosting is available in the US, EU, and Australia/NZ on their managed platform, and a separate deployment repository (loomio/loomio-deploy) handles self-hosted installs [github].

---

Why people choose it

The case for Loomio becomes clear when you examine what it’s replacing. Most distributed teams make decisions in one of three broken ways: buried email threads, ephemeral Slack polls that disappear after a week, or meetings where whoever speaks loudest wins [website].

Loomio’s website quotes Jared Messinger of the World Resources Institute: “There was really nothing great for making decisions. Loomio has been filling that gap — getting these discussions and decision points out of email and into somewhere we actually have a transparent record.” [website] That quote surfaces the core pain precisely: it’s not that the vote is hard, it’s that the record doesn’t exist afterward.

The organizations profiled on Loomio’s site are telling about who actually uses this in production [website]:

NYC Democratic Socialists of America used it to coordinate 13,000 members behind a mayoral primary campaign with zero paid staff. Key requirements: binding votes at scale, anonymous member voting, full data control via self-hosting. Loomio delivered on all three.

Semkovo Co-op — 130 people from 32 countries who collectively purchased apartments — use it for legally binding cooperative votes with a searchable governance archive.

OpenSSL Software Foundation uses it for multi-stakeholder community input with delegate voting to balance power fairly. That last one is notable: when the library that secures most of the internet needs to make a decision, they apparently trust Loomio’s audit trail.

Camplight, a software consultancy cooperative, uses consent-based distributed decisions and templates for recurring processes as the team scaled past 20 people.

The common thread: these are organizations where who decided what and why is legally or politically important. A Slack poll doesn’t cut it when a vote has binding consequences.

---

Features

Based on the website and GitHub repository [website][github]:

Core decision workflow:

• Threaded discussion with background context before any vote is called
• Multiple proposal types: simple (agree/abstain/disagree/block), polls (multi-choice), ranked choice, score voting, dot vote, time polls for scheduling
• Reasons attached to every vote — not just the outcome, but the thinking
• Outcomes recorded with a timestamp and summary
• Full searchable archive of all past decisions

Async and distributed-first:

• No “who was online” problem — votes stay open for a configured duration
• Email and in-app notifications for new proposals and discussion activity
• Every time zone participates equally because there’s no “real-time” requirement [website]

Governance structures:

• Subgroups for organizing by team, committee, or project
• Delegate voting (one member can grant another their proxy vote)
• Member management with invite controls
• Data export for compliance and record-keeping

Self-host specific:

• Full data control — your votes, your server, your jurisdiction [website]
• loomio/loomio-deploy repository provides Docker-based deployment
• Hosting your own instance means no per-seat fees and no data on third-party servers

What it notably lacks:

• Real-time chat (intentionally — this is not Slack)
• Task assignment and tracking (not Jira)
• Document collaboration (not Notion)
• A mobile app with parity to web (the web experience is the primary surface)

The narrow focus is a deliberate product decision, not an oversight. Loomio explicitly positions itself as the missing layer between your chat and your documents [website].

---

Pricing: SaaS vs self-hosted math

Loomio’s website advertises a 14-day free trial with no credit card required [website]. Beyond that, specific current pricing tiers were not available in the scraped data at time of writing — check loomio.com/pricing directly for current numbers, as cooperative-run companies tend to adjust pricing more carefully than VC-backed ones and their page is the authoritative source.

What is confirmed:

• Self-hosted (AGPL-3.0): $0 software cost [github]
• Managed hosting available in US, EU, Australia/NZ regions [website]
• The self-hosted deployment path exists via loomio/loomio-deploy on GitHub [github]

Self-hosted cost math:

• A Ruby/Rails application with PostgreSQL and Redis. Runs adequately on a 2–4GB RAM VPS.
• At Hetzner or Contabo: roughly $5–15/month depending on instance size.
• For a 50-person organization, even $30/month SaaS would beat most per-seat tools — self-hosting beats both.

Who the pricing math favors most: Organizations with many members but infrequent high-stakes decisions. A 200-member cooperative that runs 10 significant votes per year pays per-seat regardless on SaaS. Self-hosted, they pay only infrastructure — probably $6–12/month.

---

Deployment reality check

The self-hosted path is documented via a separate repository loomio/loomio-deploy which provides Docker-based deployment [github]. The main Loomio repository’s README is brief and points there — it’s a Ruby on Rails application with Vue.js frontend, PostgreSQL, and Redis as dependencies.

What you actually need:

• A Linux VPS with 2–4GB RAM minimum (Ruby applications are memory-hungry)
• Docker and docker-compose
• A domain name with HTTPS (required for proper authentication flows)
• PostgreSQL (bundled or external)
• Redis (bundled or external)
• SMTP credentials for email notifications — Loomio’s async model relies heavily on email, so a broken mail config breaks a core feature

What can go sideways:

• Ruby/Rails apps have non-trivial upgrade paths compared to single-binary tools. When Loomio releases updates, following the upgrade process matters.
• The 2,529 GitHub star count signals a smaller community than tools like n8n or Nextcloud. Fewer community guides and Stack Overflow answers means more direct reliance on the official docs.
• AGPL-3.0 means if you modify the source and distribute it (e.g., as a service), your changes must be open. For internal self-hosting, this doesn’t matter. For building a product on top, consult a lawyer.
• Email notification reliability is critical because Loomio’s async model assumes members are notified by email when proposals open. An SMTP misconfiguration silently breaks participation.

Realistic time estimate: For someone comfortable with Docker, 2–4 hours to a working instance. For a non-technical operator following a guide: a full day, including domain setup and email verification. This is not a one-click install.

---

Pros and Cons

Pros

• Purpose-built for the actual problem. No other mainstream open-source tool treats asynchronous structured decision-making as its primary focus. You get exactly what it says on the tin [website].
• Reasoning is first-class data. Votes come with mandatory reasoning fields. A searchable archive of why decisions were made is genuinely rare and valuable for any organization that cares about institutional memory [website].
• Cooperative-run with a 13-year track record. Not a startup that might pivot or get acquired. Organizations like OpenSSL and World Resources Institute trust it [website]. Stability matters when your governance records need to survive.
• Flexible proposal types. Simple yes/no votes, ranked choice, score voting, dot votes for prioritization, time polls for scheduling — more decision mechanics than most comparable tools [website].
• Data sovereignty via self-hosting. AGPL means you can host it, and your member votes stay on your infrastructure. Meaningful for cooperatives, political organizations, and nonprofits with privacy requirements [website][github].
• Delegate voting. Proxy vote mechanisms for representative governance structures — not common in competing tools [website].
• Regional hosting options. US, EU, and AU/NZ managed hosting for organizations with data residency requirements [website].

Cons

• AGPL-3.0, not MIT. You can self-host freely, but building closed products on top requires opening your code. Less permissive than MIT-licensed alternatives [github].
• Narrow scope by design. Loomio does not replace chat, does not replace documents, does not replace task tracking. You will need other tools alongside it, and the integration surface is limited [website].
• Small GitHub presence (2,529 stars). Smaller community means fewer community-contributed guides, plugins, and troubleshooting resources compared to tools with 10K+ stars [github].
• Ruby/Rails complexity. The stack is heavier to self-host than Go or single-binary tools. Upgrades require more care. Sysadmin experience helps [github].
• Not a fit for real-time decision-making. If your team needs to decide something in the next hour, open a Slack huddle. Loomio is for decisions that deserve days, not minutes [website].
• Limited third-party reviews available. Unlike Zapier alternatives or note-taking tools, Loomio has sparse independent review coverage — making due diligence harder for evaluators.
• Email dependency. The async model breaks down if email notifications fail or get filtered to spam. There’s no push notification alternative that fully compensates [website].

---

Who should use this / who shouldn’t

Use Loomio if:

• You run a cooperative, nonprofit, DAO, or membership organization where decisions need a paper trail.
• Your team is distributed across time zones and meetings exclude half the group by default.
• You’ve lost a decision to an email thread that nobody can find anymore.
• You need legally defensible records of votes (cooperatives, boards, political organizations).
• You want to self-host and keep member voting data off third-party infrastructure.
• Consent-based or sociocratic decision models are part of your culture — Loomio was built for these.

Skip it if:

• Your organization makes decisions in real-time and needs immediate resolution — this tool is built for deliberation, not urgency.
• You want an all-in-one workspace (Notion + Slack + decisions). Loomio doesn’t aim to be that, and you’ll end up using it alongside other tools regardless.
• Your team is technical and wants something they can extend programmatically — the API surface is limited and the AGPL license constrains what you can build on top.
• You need deep integrations with your existing SaaS stack. Loomio’s integration options are narrower than general-purpose automation tools.
• You’re a solo founder or team of 3. The overhead of structured async decision-making is higher than the benefit at that scale.

---

Alternatives worth considering

• Pol.is — open-source opinion-mapping tool. Better for large-scale public input and surfacing consensus across hundreds of participants. Less suited to binding organizational votes.
• Decidim — open-source participatory democracy platform. More complex, built for government and large civic organizations. Loomio is simpler and more organizational; Decidim is broader and civic.
• Alchemy.vote / Helios Voting — purpose-built anonymous balloting tools. Better if you need cryptographic anonymity guarantees; worse if you want discussion attached to votes.
• Simple polls in Slack/Teams — fine for informal quick decisions, terrible for anything that needs a record. The gap between a Slack poll and Loomio is exactly the gap Loomio is designed to fill.
• Discourse — open-source forum software. Better for large communities that primarily discuss; worse for structured decision-making with defined outcomes.
• Notion + manual decision log — what most teams cobble together before discovering Loomio. Works until it doesn’t — usually when someone needs to find a 6-month-old decision rationale.

For the specific niche Loomio occupies (structured async organizational decisions with a searchable record), there is no direct open-source competitor with comparable maturity. The choice is usually Loomio vs. Decidim (for civic/government scale) or Loomio vs. a cobbled-together spreadsheet.

---

Bottom line

Loomio is one of those rare open-source projects that knows exactly what it is and doesn’t apologize for being narrow. It is not trying to replace your Slack or your Notion. It is trying to give every organizational decision the structure it deserves: a thread for context, a vote with reasons, an outcome that’s recorded and searchable. That’s it. For cooperatives, nonprofits, and distributed organizations where “we decided this because…” matters as much as the decision itself, Loomio has been the answer for over a decade.

The caveats are real: the AGPL license is more restrictive than MIT, the self-hosted stack is heavier than average, and the narrow focus means you’ll still need other tools. But if your organization has lost important decisions to email purgatory, or watched a Slack vote scroll off the screen before half the team had a chance to weigh in — that’s exactly the problem Loomio solves. A $10/month VPS and an afternoon of setup pays for itself the first time someone asks “wait, why did we decide that?” and the answer is a Loomio link instead of a shrug.

If the setup is the blocker, upready.dev deploys self-hosted tools like this for clients as a one-time service.

---

Sources

1. Loomio Official Website — loomio.com. https://www.loomio.com/
2. Loomio GitHub Repository — loomio/loomio (AGPL-3.0, 2,529 stars). https://github.com/loomio/loomio
3. Loomio Deploy Repository — loomio/loomio-deploy (self-hosted deployment guide). https://github.com/loomio/loomio-deploy

Primary sources used:

• Website homepage and case studies: https://www.loomio.com/
• GitHub README and repository metadata: https://github.com/loomio/loomio

Note: The third-party review sources provided for this article were not about Loomio — they were unrelated quote-of-the-day websites. This review is based on primary sources (official website, GitHub) and verified facts only. No review data was fabricated.