> ## Documentation Index > Fetch the complete documentation index at: https://docs.speckle.systems/llms.txt > Use this file to discover all available pages before exploring further. # Compare Open Source, Hosted, and Enterprise Speckle > Shared core platform versus managed layer, why UIs differ, licensing and operations at a glance, and responsibility boundaries—not a feature checklist. This page explains **where responsibility boundaries sit** among **self-hosted open source**, **Speckle-hosted** (Team and Enterprise), and **Enterprise on your own infrastructure**. It is not a complete inventory of every capability. It complements [Hosting Your Own Speckle Server](/developers/server/introduction). ## How To Read This Comparison The meaningful distinction is not “features missing vs present” on the same checklist. It is: * **Core Platform vs. Managed Platform** — the stable open-source server versus the full product experience Speckle operates or licenses. * **Distributed Code vs. Operated Services** — code you run and integrate yourself versus services Speckle runs at scale (often on Speckle infrastructure). * **Extensibility vs. Responsibility** — both paths are API-first; who owns ingestion, integration glue, execution environments, uptime, and support differs. **Feature parity is not the goal.** Hosted offerings lead on product surface area and operated services. Open source provides the **stable, distributable foundation** the ecosystem and hosted product build on. ## Shared Core Across Deployments All Speckle deployments build on the same **core platform**: * **Projects, models, and versioning** * **GraphQL and REST APIs** and the **data transport** connectors use * The **web application** and **3D viewer** The difference is **how that core is extended and who operates** what sits on top of it—not a different “kind” of geometry or version graph. ## Managed Layer and Why the UI Differs **Speckle-hosted** (Team and Enterprise on Speckle Cloud) is the fully realized product: the core plus a **workspace** model and **managed services**—for example ingestion pipelines, integrations with external platforms (such as CDEs), and execution environments such as [Automate](/developers/automate/introduction) (where included in your plan). The **open-source server** is the **distributed form of the core**. It provides that foundation **without** the managed service layer that sits above it in the cloud. In practice, **differences you see in the UI and feature surface** reflect that managed layer and workspace experience, not a separate “lightweight viewer-only” product. You are comparing **core-only self-host** against **core plus operated platform**. ## Beyond OSS Is Not the Same as Cloud-Only Capabilities that are **not part of the public open-source distribution** (often because they rely on proprietary code or Speckle-operated infrastructure) are still delivered in more than one commercial shape: * **Speckle-hosted** Team or Enterprise — Speckle runs the stack and the managed services. * **Enterprise licensed and self-hosted** — many organization, compliance, and integration features are available **on your infrastructure** under a commercial license. See [Enterprise License](/developers/server/deployment/enterprise-license). Some managed capabilities **always** run on Speckle-operated infrastructure. For example, **[Automate](/developers/automate/introduction) does not run on a customer’s own servers**; self-hosted servers can still integrate using **webhooks and external compute**. See the [Automate FAQ](/developers/automate/faq). **Speckle Cloud is extensible** through [GraphQL](/developers/api/graphql), [REST](/developers/api/rest), and [webhooks](/developers/api/webhooks). Many teams use hosted Speckle as a **system of record** and build custom applications, dashboards, and integrations on top. **Open source self-hosting** gives you the same API building blocks, but **you** implement and operate execution, orchestration, and integration pipelines (or bridge to external automation). **Equivalent workflows are possible**; what changes is what Speckle provides and runs for you versus what your team builds and runs. Typical patterns: * **APIs and SDKs** for ETL and data transformation * **Webhooks** for event-driven workflows * **Embedding or driving the viewer** in downstream applications ## Licensing and Cost (Overview) **Open-source self-hosting** has **no Speckle licensing fee** for the public server. Your costs are infrastructure and your own operational time. **Speckle-hosted** plans are **subscriptions at the workspace level**. Limits and commercial terms depend on plan—for example capacity for users, projects, and stored model versions on Team, and usage-aligned models on Enterprise. For how plans treat usage and limits, see [Billing](/workspaces/billing). **Pricing** and quotes are published on [speckle.systems/pricing](https://speckle.systems/pricing/). In practice, **cost and capacity** on hosted plans scale most with **model versions, data churn, and how often you sync and automate** (together with model size and concurrency)—not primarily “per API call” for building custom apps. **Bottlenecks:** * **Hosted:** governed by workspace plan limits and fair-use expectations described with your plan. * **Self-hosted:** governed entirely by **your** infrastructure—especially database performance, object storage, and throughput for background processing. **Enterprise self-host** adds **commercial licensing** for Enterprise software and registry access; it is not the same economics as public OSS alone. See [Enterprise License](/developers/server/deployment/enterprise-license). ## Support and Operations (Overview) The **Speckle-hosted** product is **continuously deployed and operated** by Speckle: scaling, monitoring, and incident response for the cloud service. **Support and uptime commitments** depend on **plan and contract** (for example Speckle-hosted Enterprise). With **open-source self-host**, **deployment, scaling, upgrades, backup, and recovery are yours**. Updates ship in the open-source release process; **operational support** is documentation and the community unless you have a separate agreement. For Enterprise **on your infrastructure**, operations split: **you** run the clusters and data plane; **commercial terms** cover the Enterprise software and how Speckle supports you. Details belong in your license and deployment guide—not generalized here. ## Open Source Foundation and Enterprise Scale Speckle started as an open source project because the AEC industry needs open, interoperable infrastructure that no single vendor can lock down. The core platform is and remains open source. You keep control over your data and how you deploy and extend Speckle. Commercial offerings add operated or licensed layers; they do not redefine the core as “the incomplete version.” ## Growing Needs Beyond the Core Larger or more regulated deployments often need managed CDE integrations, organization-scoped administration, compliance evidence, analytics, and workflow automation at a level that requires **ongoing operational investment**, not only code. Paid Team and Enterprise offerings fund that investment—reliability, security posture, support, and product development—while the open-source core stays available to self-host and build on. ## Our Approach The core stays open so you keep flexibility, including self-hosting. Speckle-hosted and Enterprise offerings add **managed or licensed platform** pieces on top: operated services, integration paths, and contractual support where that matches how your organization works. That model lets Speckle: * Keep investing in the open-source core that benefits everyone * Ship enterprise and hosted capabilities where organizations need them * Offer support and SLAs where projects are mission-critical on Speckle-hosted deployments * Fund development without giving up the openness of the platform You can: * **Stay on open source** and self-host if that matches your responsibility model. * **Use a Speckle-hosted Team plan** when you want Speckle to operate the platform and deliver analytics-oriented product surface area. * **Use Speckle-hosted Enterprise** when you need advanced capabilities, automation, support, and governance aligned with an organization-wide strategy. * **License Enterprise and self-host** when data and control must stay in your environment but you still want Enterprise scope—knowing some capabilities (such as Automate execution) still use Speckle-operated infrastructure. ## Comparison by Boundary The table groups differences by **where the boundary runs**, not by ticking individual features. Rows summarize **what each side is responsible for**. | Boundary Area | Open Source (Self-Hosted) | Speckle Cloud / Enterprise (Hosted or Enterprise-Licensed) | | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Core Platform** | You deploy the core: projects, models, versions, **GraphQL and REST APIs**, and the **3D viewer**. This is the stable, open-source foundation. | Built on the same core, delivered as (or paired with) Speckle’s **managed product**: operated stack, product cadence, and services that extend beyond what the OSS distribution alone provides. | | **Managed Services** | **You** operate or substitute your own: workflow automation, analytics and validation stacks, and ingestion and scaling patterns. Integrate via APIs and your toolchain. | **Speckle-operated** layers where offered—for example **Intelligence**, **hosted ingestion and processing**, and **Automate** (hosted-only execution)—evolve on product roadmaps separately from an OSS-only deployment. | | **Integrations** | **Connectors** work with your server. Managed CDE and cloud integrations that Speckle operates for hosted customers are not bundled into the OSS distribution; you can still build comparable flows with APIs and your stack. | **Managed integrations** and first-party CDE paths where Speckle ships and operates them, plus the connector ecosystem, for teams that want Speckle to own that integration and operations path. | | **Operations** | **You** own hosting, scaling, monitoring, backups, upgrades, and uptime. Support from **community** channels. Compliance and org admin models are yours to implement. | **Speckle** operates infrastructure and reliability for **Speckle-hosted** customers; **dedicated support** and SLAs per **Speckle-hosted Enterprise** agreements. **Enterprise self-host:** you operate infra; commercial license and support terms apply per contract. | **Enterprise licensing (self-host):** Capabilities that are not part of the **public open-source** server may still be available **on your infrastructure** under a **Speckle Enterprise Server** license. What you are entitled to deploy is set out in your commercial agreement. In this docs section, start with [Hosting Your Own Speckle Server](/developers/server/introduction), [Deployment Options](/developers/server/deployment-options), and [Enterprise License](/developers/server/deployment/enterprise-license). ## Operating Your Own Open Source Server Self-hosting means you carry the operational responsibility summarized in the **Operations** row. For concrete deployment paths, see [Overview](/developers/server/introduction) and [Deployment Options](/developers/server/deployment-options). ## Related * [Hosting Your Own Speckle Server](/developers/server/introduction) * [Deployment Options](/developers/server/deployment-options) * [Enterprise License](/developers/server/deployment/enterprise-license) * [Billing](/workspaces/billing) * [Automate FAQ](/developers/automate/faq)