Dify vs Langflow: which fits your team's LLM app work
Choose Dify if your team needs RAG, agents and published apps that business users can operate without writing code. Choose Langflow if Python developers will build the flows and serve each one as an API or MCP server for other systems to call. Three factors decide the choice: who builds the application, how it is consumed, and what your license must allow. Who builds matters most. Dify's visual interface, prompt IDE, knowledge base and app publishing suit teams where product owners or analysts iterate on prompts and retrieval themselves. Its Docker Compose stack, which starts PostgreSQL, Redis, Weaviate, Nginx and a code sandbox beside the API and worker services, needs at least 2 CPU cores and 4 GB of RAM according to the Dify self-hosting docs, so plan for an operator who can keep those services patched. Langflow fits when developers want Python-customizable components in version control. It installs as a Python package, a Docker image or a desktop app, and it is a better match for engineers who will treat flows as code.
How the application is consumed decides the second factor. If end users need a chat or web app with access controls, Dify's publishing model is the direct path. If the consumers are other services, internal APIs or agent clients, Langflow's option to deploy each flow as an API or an MCP server is the stronger fit, and you should confirm the exact authentication and endpoint behavior in your target version before designing around it. The license decides the third factor. Dify uses a modified Apache License 2.0 that requires a commercial license from LangGenius to operate a multi-tenant environment from its source or to remove the logo or copyright in the console. If you plan to offer Dify workspaces to separate customers, that condition matters. Langflow is MIT licensed, so it carries fewer restrictions on that use. Before either choice, confirm with your legal team how each license applies to your deployment model, and confirm that Langflow's production database and authentication settings, which are documented separately from defaults, meet your standards.
Which platform fits which team scenario
This table matches four team scenarios to the platform that fits each one better, with the supplied fact behind the choice. Scenarios marked illustrative are hypothetical, so test them against your own team, licensing position and hosting plan before deciding.
| Team scenario | Better fit | Why it matters |
|---|---|---|
| Internal knowledge assistant for non-developers (illustrative) | Dify | Dify provides a visual interface for RAG pipelines and app publishing, so staff who do not write code can build and maintain the assistant. Confirm that the Community edition's single-workspace limit covers your planned use. |
| Python team exposing agent tools over MCP (illustrative) | Langflow | Langflow's README describes deploying flows as an MCP server, and its components can be customized in Python. Python engineers can extend components directly, and the MIT license places few restrictions on that work. |
| Multi-tenant SaaS product built on the platform (illustrative) | Langflow | Dify's license forbids operating a multi-tenant environment from its source without written authorization from LangGenius. Langflow's MIT license has no comparable restriction, but have counsel confirm the terms for your product. |
| Quick local prototype on a laptop (illustrative) | Langflow | Langflow installs as a Python package or Langflow Desktop for Windows and macOS, and it uses SQLite by default. Dify's Docker Compose stack starts PostgreSQL, Redis, Weaviate and several other services, which adds setup before the first test. |
| Team building a production app with many concurrent users (illustrative) | Depends on the database plan | Langflow's docs recommend PostgreSQL over the default SQLite for production, and Dify ships PostgreSQL as its default metadata database. Confirm that either platform's production database setup meets your concurrency and recovery targets. |
How each platform is built and what it means for operations
Dify and Langflow ship in very different shapes. Dify is a multi-service stack you run as a platform, while Langflow can start as a single Python process and grow into a containerized service. The cards below cover the components, install paths, data stores and deployment targets that determine how much operational work each one creates.
Dify's Docker Compose stack
A standard Dify deployment starts the api, worker, web, plugin daemon, PostgreSQL, Redis, Weaviate, Nginx, a code sandbox and an SSRF proxy. Each of these is a service you must monitor, back up and upgrade. The published minimum is at least 2 CPU cores and 4 GB of RAM, but that is a floor for a test install, not a sizing plan. Confirm sizing with Dify's guidance against your expected user count, document volume and model traffic before you commit hardware.
Langflow's three install paths
Langflow installs as a Python package (Python 3.10 to 3.14, with uv recommended), as a Docker image, or as Langflow Desktop for Windows and macOS. A developer can run a flow on a laptop in minutes, which makes it a good prototyping tool. Moving from a laptop to a shared service is where the work begins, so decide early which path your production team will own and who patches the Python environment or image.
SQLite default versus PostgreSQL
Langflow uses SQLite by default, and its docs state that PostgreSQL is better suited for production because of concurrent users, data integrity and scalability. Dify uses PostgreSQL as its metadata database by default and also supports MySQL and OceanBase. For Langflow, plan a custom database configuration before any shared use, and test migration of flows and credentials in a staging environment first.
Vector store and file storage choices
Dify's vector store defaults to Weaviate, with options including Qdrant, Milvus, pgvector, OpenSearch and Elasticsearch, and its file storage can use S3-compatible, Azure Blob or Google Cloud Storage. Langflow leaves retrieval storage to the components you wire into each flow. Decide which vector store and object store your security team will back up and restore, and confirm the exact backend for each Dify knowledge base and Langflow flow.
Authentication and secret handling
Official Langflow release packages and Docker images disable automatic login by default and require a superuser password set through LANGFLOW_SUPERUSER_PASSWORD. Dify uses SECRET_KEY to sign session cookies and JWTs and to encrypt OAuth credentials, and changing it after deployment logs out all users. Record both secrets in your vault before the first deployment, and confirm how each platform rotates them in your environment.
Deployment targets and the operations they add
Langflow's docs cover Docker images, remote servers behind Caddy or Nginx with HTTPS, and Kubernetes for production-grade, high-availability deployments. Dify's community edition runs anywhere Docker runs, while Dify Enterprise adds Kubernetes deployment for high availability. Each target adds ingress, TLS, backups and on-call work. Ask your platform team whether they will own a Kubernetes cluster for either tool, or whether a Docker host is the right fit for your scale.
How authentication defaults differ before any SSO is added
Out of the box, Langflow does not open an unauthenticated admin console. Its official release packages and Docker images disable automatic login by default and require a superuser password set through LANGFLOW_SUPERUSER_PASSWORD. Before you expose a Langflow instance to anyone, set that variable from your secrets store, confirm the password is not in a committed compose file or shell history, and test that a browser session without credentials is refused. Langflow's own identity model beyond the superuser account is something to confirm in the current documentation and your own test environment, not something to assume from the project README.
Dify handles the same question differently. Its SECRET_KEY signs session cookies and JWTs and also encrypts OAuth credentials, so the value is part of the trust boundary, not just a setting. The environment reference warns that changing it after deployment logs out all users. Generate it once, store it in your secrets manager, and treat rotation as a planned outage. Workspace encryption keys can be held locally or in Azure Key Vault, which is a decision to make before you load provider credentials.
Where SSO matters, the gap is in what is documented as available. Dify Enterprise lists OpenID Connect, SAML and OAuth2, with identity providers such as Microsoft Entra ID, Okta and GitHub, and separate SSO scopes for workspace access and web app access. For Langflow, the equivalent is not established by the material reviewed here, so ask the vendor and your architects which identity options a self-hosted deployment supports, whether they require custom work behind a reverse proxy such as Caddy or Nginx, and who owns session management. Confirm each option in a staging environment with your own identity provider before you commit to either platform.
Dify and Langflow side by side on the facts that decide
This table compares Dify and Langflow on license, builder audience, RAG and agents, publishing, databases, vector stores, observability, SSO and deployment targets. Where the researched facts stop, the cell tells you what to confirm with the vendor or in your own test deployment, so no gap is filled with a guess.
| Capability | Dify | Langflow |
|---|---|---|
| License | Modified Apache License 2.0 (Dify Open Source License). Multi-tenant operation and console logo or copyright removal need a commercial license from LangGenius (LICENSE file). | MIT license (license metadata of the langflow-ai/langflow repository). |
| Primary builder audience | Mixed teams: prompt IDE, visual workflows and app publishing suit product and ops staff alongside developers. | Developers comfortable with Python, since components are Python-customizable (Langflow README). |
| Built-in RAG and agents | Yes. RAG pipelines and agents are built through the visual interface (Dify GitHub repository). | Yes for agents and multi-agent orchestration (Langflow README). Confirm RAG component coverage against your document sources. |
| App publishing | Backend-as-a-service APIs and app management in the console (Dify docs). | Flows deploy as an API, JSON export or MCP server (Langflow README). |
| API or MCP exposure | API exposure through backend-as-a-service APIs. Confirm MCP support against current Dify docs before committing. | Flows served as an API and as an MCP server (Langflow README). |
| Default metadata database | PostgreSQL (Dify environment variable reference). | SQLite (Langflow custom database docs). |
| Production database options | PostgreSQL, MySQL or OceanBase for metadata (Dify environment variable reference). | PostgreSQL is the documented choice for production concurrency and integrity (Langflow custom database docs). Confirm other engines. |
| Vector store options | Weaviate by default, with Qdrant, Milvus, pgvector, OpenSearch and Elasticsearch as options (Dify environment variable reference). | Not covered in the supplied facts. Confirm which vector stores its components support. |
| Observability integrations | LLMOps monitoring built in (Dify GitHub repository). Confirm export options for your SIEM. | LangSmith, Langfuse and others (Langflow README). |
| SSO availability | Community edition has no SSO. SSO with OpenID Connect, SAML and OAuth2 is in Dify Enterprise (Dify Enterprise SSO docs). | Official packages disable automatic login and require a superuser password (Langflow README). Confirm SSO options with the vendor. |
| Deployment targets | Docker Compose for Community; Kubernetes for high availability in Enterprise (Dify deployment overview). | Python package, Docker image or Langflow Desktop; remote servers behind Caddy or Nginx; Kubernetes for production (Langflow README and deployment docs). |
What the license and editions allow for each platform
Dify is released under the Dify Open Source License, a modified Apache License 2.0. Most of the Apache terms still apply, but two conditions change the picture once Dify becomes shared infrastructure, and the editions split features and support in a way that affects who can use one installation.
- Multi-tenant operation: Running a multi-tenant environment from the Dify source requires written authorization from LangGenius. A tenant is one workspace, so a shared service that gives each business unit its own workspace falls inside this term.
- Console branding: The license forbids removing or modifying the logo or copyright information in the Dify console. White-labeling an internal portal therefore needs the same clearance as a multi-tenant deployment.
- Community edition: The self-hosted Community edition is free and limited to a single workspace. It suits one team or one internal app line that does not need separate tenants.
- Enterprise edition: The self-hosted Enterprise edition is custom priced and adds SSO, multiple workspaces, advanced security, a commercial license and professional support. It can also be deployed on Kubernetes for high availability.
Before you choose an edition, confirm with LangGenius whether your planned use counts as multi-tenant and whether the Enterprise quote includes the commercial license you need.
Langflow is released under the MIT license. MIT is one of the most permissive open-source licenses, allowing use, modification and redistribution, including in commercial settings, as long as the copyright notice and license text travel with the code. The license itself sets no per-user, per-workspace or per-tenant limits, so the scope of sharing is a deployment decision rather than a licensing one.
- Permissive terms: You may run one Langflow instance for several teams and modify the code for internal use without a separate commercial agreement under the MIT terms.
- Branding: The MIT license does not require keeping vendor branding in the interface, so any change to the UI is governed by the license text alone. Have counsel review it before external distribution.
- Paid offerings: The materials reviewed for this comparison do not describe a paid Langflow edition, so confirm directly with the vendor whether commercial support, managed hosting or an enterprise distribution exists.
- Security setup: Official release packages and Docker images disable automatic login and require a superuser password set through
LANGFLOW_SUPERUSER_PASSWORD. The license does not change this setup work.
Before standardizing on Langflow, get a written statement from the vendor covering any support, paid features and response expectations, because the MIT license alone says nothing about service levels.
The two licenses reach the same decision from different directions. Dify's terms and paid editions are defined in documents you can read, while Langflow's license is simple but the commercial support question stays open. Procurement and legal teams should translate each license into the specific questions their deployment raises before signing anything.
- Tenancy scope: Write down how many teams, workspaces or customer-facing tenants will share one instance, and ask whether that pattern needs written authorization under the Dify license.
- Enterprise inclusions: Ask the Dify vendor to list which features the Enterprise quote covers, including SSO, workspace limits, security controls and professional support.
- Langflow support: Ask the Langflow maintainers whether a paid edition, support contract or hosted option exists, and what it includes.
- Branding and distribution: Confirm whether your internal portal or any external delivery modifies the Dify console or Langflow interface, and record the approval for each.
- Written terms: Keep license decisions, quotes and support commitments in writing so the team can show what was agreed when the deployment is audited or expanded.
If the answer to the tenancy question is unclear, resolve it before the first build, since the license position determines which edition the rollout needs.
What drives the running cost of each platform
Both platforms are free to download and run, so the running cost sits in the infrastructure, the people who build and maintain flows or apps, the model and vector store choices, and any paid edition you add. Start by separating one-time costs (planning, initial deployment, integration with your identity provider, hardening and backup design) from recurring costs (hosting, model usage, upgrades, testing and support). For Dify, the Docker Compose guide asks for at least 2 CPU cores and 4 GiB of RAM and starts PostgreSQL, Redis, Weaviate, Nginx and a code sandbox alongside the api, worker and web services, so the baseline is a multi-container stack to size and patch. Langflow installs as a Python package, a Docker image or a desktop app, and its production guidance moves you from SQLite to PostgreSQL, so its baseline is smaller but the database and Kubernetes or reverse proxy setup still need an owner.
Upgrade cadence is a recurring cost you should price in. Dify's releases have arrived roughly monthly, with 1.16.0 on July 17, 2026, 1.17.0 on August 25, 2026 and 1.17.1 on September 10, 2026, so plan for regular test and rollout cycles. Langflow publishes weekly patch releases, which keeps fixes flowing but means more frequent change to review, especially for flows that depend on custom Python components. Model provider and vector store choices move the bill more than either platform's license. Hosted model usage is billed by the provider, and the vector store you pick (Weaviate by default in Dify, or options such as Qdrant, Milvus or pgvector) determines whether you run another stateful service. Dify's published prices are the only ones to cite: the self-hosted Community edition is free and limited to a single workspace, the self-hosted Enterprise edition is custom priced, and Dify Cloud Professional is listed at 590 US dollars per year. Langflow has no published paid edition in the supplied facts, so confirm with its maintainers what support, if any, you can buy.
When you request a quote, ask for each item separately: the infrastructure sizing and who operates it, the skills and hours needed to build and maintain flows or apps, the database and vector store configuration, the upgrade and regression testing process, the number of workspaces or tenants in scope, and what support window and response commitments are included. For Dify, confirm early whether a single workspace is enough, because a second tenant changes the license and edition question. For Langflow, ask who will own the MCP and API endpoints once flows are published. DeployOpen plans, implements, hardens, backs up, upgrades and supports either platform inside your infrastructure under a written, fixed scope, and provides retainers for ongoing support, but it does not publish prices, so the figures come from your agreed scope.
Moving flows or apps from one platform to the other
This sequence moves a working set of Langflow flows or Dify apps to the other platform without losing track of models, tools, data or access. It ends with consumers of the published APIs or MCP servers confirmed against the new system before the old one is switched off.
Inventory flows, apps and their dependencies
List every Langflow flow or Dify app in scope, along with the model providers, external tools, API keys, knowledge sources and databases each one calls. Record which applications, scripts or MCP clients consume each endpoint, and who owns each item. Done means every flow or app has a row in a shared inventory that names its dependencies and its consumers, reviewed by the team that owns the business use case. Illustrative example: a support assistant that calls one model provider, one ticket API and a document index is one row with three dependencies.
Decide what to rebuild and what to export
Sort each item into one of two groups. Langflow flows can be exported as JSON, and custom Python components stay code that must be ported by hand, since Dify uses its own workflow nodes and tool definitions. Dify apps are rebuilt as Langflow flows or Python components, not imported. Mark each node as portable (prompts, parameters, simple logic) or rebuild (custom code, provider-specific tools, agent logic). Done means a written decision per item, with the rebuild effort assessed by the platform engineer who will do the work. Confirm with each vendor's current export and import options before assuming a format is portable.
Rebuild the knowledge and vector data layer
Decide where the retrieval data will live on the target platform. Dify ships with Weaviate by default and can be configured for Qdrant, Milvus, pgvector and other stores, while Langflow connects to whichever vector store the flow is built against. Re-ingest source documents with the same chunking settings where possible, and compare retrieval results on a fixed set of test questions. Done means the new index returns answers that the knowledge owner has reviewed as acceptable. Export of vectors between stores is not assumed: confirm with each vendor whether raw embeddings can be exported, and plan to re-embed from source documents otherwise.
Rebuild the application database, storage and secrets
Set up the metadata and application databases for production. Dify uses PostgreSQL by default and supports MySQL or OceanBase, while Langflow uses SQLite by default and its docs recommend PostgreSQL for production. Configure file storage, and move API keys and provider credentials into the target platform's secret handling rather than copying them from the old flow files. Dify's SECRET_KEY signs sessions and JWTs and encrypts OAuth credentials, so generate it fresh and record it in your secrets manager. Done means the new platform starts against production-grade databases with no credentials stored in exported files.
Re-create identity and administrator access
Configure administrator and user access on the target platform before any user touches it. For Langflow, official packages and Docker images disable automatic login by default and require a superuser password set through LANGFLOW_SUPERUSER_PASSWORD, so set that from your secrets store. For Dify Community, confirm which access features your edition includes, since Dify Enterprise adds SSO and multi-workspace management per Dify's pricing page. Map existing roles to the target platform's roles and document any gap. Done means each named administrator can log in, and each role has a documented equivalent or an accepted exception.
Test API and MCP consumers against the new endpoints
Point a copy of each consuming application, script or MCP client at the new endpoint in a test environment. Langflow serves flows as an API and as an MCP server, while Dify exposes backend-as-a-service APIs for apps, so request paths, authentication headers, payload shapes and streaming behavior will likely differ. Update client configuration and compare responses from the old and new systems for the same inputs. Done means every consumer returns the expected output and error handling in the test environment, signed off by its owner. Confirm the exact endpoint contract with each platform's current API documentation.
Cut over and retire the old platform
Schedule the switch with the owners of each consumer, freeze changes to the old flows or apps, and point production traffic to the new endpoints. Keep the old platform and its database read-only for a rollback window agreed in advance, and record the rollback steps. After the window closes, archive exports, configuration and the inventory, then decommission. Done means production consumers run on the new platform, rollback was tested or explicitly accepted as untested, and an archive of the old configuration is stored under your retention policy.
Where Dify and Langflow implementation projects usually run long
Most delays on either platform come from ownership and scope questions that were never written down, not from the software itself. On Dify, the work that stretches a project is knowledge base ingestion, model provider configuration, the choice of vector store and the workspace and tenant model. Dify's default metadata database is PostgreSQL, and the vector store defaults to Weaviate with options such as Qdrant, Milvus and pgvector, so the vector store decision should be made before any documents are loaded, because re-indexing a large corpus into a different store is rework your team pays for. Decide early how many workspaces you need, since the Community edition is limited to a single workspace, and whether SSO for Enterprise will be in scope, because SSO is one of the features that only Enterprise includes.
On Langflow, the long tail usually sits in custom Python component development, the move off SQLite and the HTTPS and high availability layer. Langflow uses SQLite by default and its docs say PostgreSQL is better suited to production, so plan the database cutover and a data migration path for flows, users and stored state before go-live rather than after. Official Langflow packages disable automatic login and require LANGFLOW_SUPERUSER_PASSWORD, which means someone must own the credential and the reverse proxy configuration behind Caddy or Nginx. If you plan to run Kubernetes for high availability, confirm with your platform team who operates that cluster before the project starts, since the Langflow deployment docs describe it as the production path but do not size it for you.
Across both platforms, write the scope before work starts and define four things: who builds flows or apps and who operates the platform, the licensing position for multi-tenant or customer-facing use (Dify's license forbids operating a multi-tenant environment from its source without written authorization), the identity integration and its owner, and the data migration plan including any prior flows or knowledge bases. Ask each vendor or implementation partner for a quote that lists these items separately, so that a change to any one of them shows up as a scope change rather than an overrun.
Questions buyers ask before choosing Dify or Langflow
Can our team run Dify or Langflow without outside help?
Yes, a team with Docker experience can run either platform without an outside partner, because both are open source and install inside your own infrastructure. Langflow installs as a Python package, a Docker image or Langflow Desktop, so a developer can start it quickly. Dify's Docker Compose guide asks for at least 2 CPU cores and 4 GiB of RAM and starts PostgreSQL, Redis, Weaviate, Nginx and a code sandbox alongside the API, worker and web services. The harder work comes after the first run: HTTPS, backups, upgrades, identity integration and security review. Decide now who owns those tasks after go-live, and whether that person has the time to keep them current.
What drives implementation effort, and is fixed scope typical?
Effort follows the number of connections you need. The main drivers are the model providers you call, the vector store you choose (Dify defaults to Weaviate and also lists Qdrant, Milvus, pgvector, OpenSearch and Elasticsearch), the identity integration you require, the data sources feeding your knowledge bases, and the security review of outbound and sandbox settings. Dify's SSO features sit in Dify Enterprise, not in Community. Most DeployOpen engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts, so ask for a work breakdown that lists each integration as its own line.
How long does a first deployment take?
No duration is supplied for either platform, so treat any single number from a vendor, blog or partner as unverified until it matches your own scope. The drivers are the same ones that set effort: how many integrations and data sources are in scope, whether identity must be connected before users log in, which vector store and file storage you choose, how many environments you run (for example, a test and a production instance), and how many approvals your security and change teams require. Ask for the timeline in the written scope, with milestones tied to deliverables and to the client inputs each milestone depends on.
What does the work need from our own team?
A named platform owner is the first requirement, and the work needs several other roles to answer on time. Plan for an infrastructure contact who provisions hosts, databases, storage and network paths, an identity owner for SSO or directory integration, a data owner for each knowledge source, an owner for model provider accounts and API keys, a security reviewer for the sandbox, outbound proxy and secret handling, and someone on call for backups and upgrades. Release cadence matters too. Dify's minor releases have arrived roughly monthly, with 1.16.0 on July 17, 2026, 1.17.0 on August 25, 2026 and 1.17.1 on September 10, 2026, so schedule a recurring upgrade window.
Can Langflow be made multi-user safe for production?
Yes, but it takes deliberate changes, because the defaults are a starting point rather than a production setup. Official Langflow releases and Docker images disable automatic login and require a superuser password set through LANGFLOW_SUPERUSER_PASSWORD. Langflow uses SQLite by default, and its docs say PostgreSQL is better suited to production because of concurrent users, data integrity and scalability, so move the database early. Then:
- Put the app behind HTTPS with Caddy or Nginx.
- Use Kubernetes for high availability if downtime matters to your users.
- Map user accounts and flow ownership to your identity and access rules, and test them on your version.
- Send traces to LangSmith or Langfuse so runs can be reviewed.
Can one Dify Community install serve several customers?
Not as one shared Community installation without written authorization. Dify Community is limited to a single workspace, and the Dify license forbids operating a multi-tenant environment from the source code without written authorization from LangGenius, where one tenant is one workspace. Serving several customers from one install would fall under that restriction. Running a separate installation for each customer may be a different question, so confirm it with LangGenius before you design around it. If you need several workspaces with shared administration, SSO and advanced security, the Enterprise edition is the paid path, and it is priced by quote on the Dify pricing page.
How do we move away from Dify or Langflow later?
Start by keeping your data portable, since the app layer is usually easier to rebuild than the documents and records behind it. Langflow flows can be exported as JSON, so flow definitions travel as data, but custom Python components will need rewriting elsewhere. Dify stores prompts, apps and knowledge bases in its own database and vector store, so choose standard options where you can: PostgreSQL for metadata and a vector store such as pgvector or Qdrant that you can query directly. Keep source documents in your own storage so embeddings can be rebuilt. Before you commit, ask your implementer to confirm which export formats your Dify version supports for apps, knowledge bases and conversation logs.
How DeployOpen helps teams choose and implement between Dify and Langflow
DeployOpen plans, implements, customizes, hardens, documents and supports self-hosted open-source platforms inside the client's own cloud accounts, data centers or air-gapped networks. For a Dify vs Langflow decision, we help teams settle the choice against their own licensing, database and identity requirements, then deliver the chosen platform as a fixed-scope engagement.
How we scope
- Confirm which builders will author flows and apps, and whether they need a visual console, Python components or both
- Review the license conditions that apply to your planned use, including multi-tenant operation and console branding
- Agree in writing on the database, file storage, vector store and identity provider the production deployment will use
How we build
- Deploy the chosen platform in your infrastructure with PostgreSQL in place of the default SQLite for Langflow, or with the Dify Docker Compose services
- Configure authentication before any user access, including the Langflow superuser password and Dify secret and session settings
- Test flows or apps against your model providers, data sources and observability integrations under a documented test plan
How we hand over
- Provide runbooks for upgrades, backups and restores covering the database, object storage and vector store your team will operate
- Document how builders publish flows as APIs, MCP servers or Dify apps, with access rules your reviewers can audit
- Transfer ownership of configuration, secrets handling and the license conditions your organization has accepted
How we support
- Offer ongoing support, upgrades and continuous security testing as a retainer after handover
- Review new platform releases against your scope and schedule upgrades in your own change process
- Confirm licensing questions with the vendor before expanding to additional workspaces, tenants or user groups

