DataHub vs Apache Atlas

Apache Atlas suits Hadoop estates that already run HBase, Solr and Ranger and want to keep that model. DataHub suits estates spanning many non-Hadoop sources that can operate Kafka, a relational database and Elasticsearch or OpenSearch.

On this page

Which catalog fits your Hadoop estate, and what the choice turns on

Keep Apache Atlas if your metadata work stays inside Hadoop and Ranger must keep enforcing access at runtime; move to DataHub if most of your data sits outside Hadoop and you need broader connectors and a modern discovery interface. Atlas is built around Hive, HBase, Kafka and Sqoop hooks, and its README ties metadata veracity to Apache Ranger so that unauthorized access paths are blocked at runtime. DataHub lists more than 150 integrations, including Snowflake, BigQuery, Databricks, dbt, Looker and Tableau, so it fits teams whose lineage must cross warehouses, BI tools and cloud services. Neither choice is wrong by default; the estate and the operating model decide it.

Three questions settle the choice. First, how much of the estate sits outside Hadoop? Count the sources you need cataloged and lineage-tracked, not the ones you have today, and check whether Atlas hooks or DataHub ingestion sources cover each one. Second, must Ranger enforcement stay in place? If it must, confirm how your Ranger policies would be reflected in the new catalog, because DataHub's access model is not the same as Atlas's Ranger-backed model and this needs to be verified with the vendor and in your own environment. Third, can your team run the services each platform needs? Atlas depends on JanusGraph with HBase and Solr, while DataHub Core needs Kafka, a MySQL or PostgreSQL database, Elasticsearch or OpenSearch and a graph index. Operating both stacks at once is the costliest path, so decide which set your team will patch, back up and upgrade for the next several years.

Which platform fits each estate scenario

This table maps six common estate scenarios to the platform that fits better and the condition under which the other one would win. Read each row against your own estate, and treat the Atlas and DataHub columns as the conditions to test rather than settled verdicts.

ScenarioBetter fitWhen the other platform wins
Hive and HBase estate with Ranger enforcementApache Atlas. Its Hive and HBase hooks and its documented tie to Apache Ranger for runtime access control match this estate directly.DataHub wins if most new lineage and discovery needs come from tools outside Hadoop, or if you can no longer staff HBase and Solr operations alongside the Hadoop stack.
Mixed estate with Snowflake, dbt, Looker or Tableau alongside HadoopDataHub. Its README lists more than 150 integrations, including Snowflake, dbt, Looker and Tableau, so non-Hadoop sources are covered without custom hooks.Atlas wins if the Hadoop side dominates and the cloud warehouses are a secondary concern. Confirm which Atlas hooks or community connectors cover your specific cloud tools before deciding.
Team already running HBase and SolrApache Atlas. Its documented storage path uses JanusGraph on HBase with Solr for indexing, so existing skills and clusters carry over.DataHub wins if you want to retire HBase and Solr and move to Kafka, a relational database and Elasticsearch or OpenSearch, which is the service set DataHub documents.
Team with no Hadoop operations skillsDataHub. Its documented services (GMS, Kafka, MySQL or PostgreSQL, and Elasticsearch or OpenSearch) are more common to operate than an HBase and Solr stack, though Kafka and search still need owners.Atlas wins if a managed Hadoop distribution already runs HBase and Solr for you and the team only needs the catalog layer. Confirm the support terms with that vendor.
Kubernetes-first platform teamDataHub. It is deployed with Helm charts plus a prerequisites chart, and its system-update job handles schema changes and reindexing on upgrade.Atlas wins if your Kubernetes platform is not the target and you already run Atlas on virtual machines. Confirm current Atlas container guidance with the Apache project before assuming parity.
Team starting a catalog from scratchDataHub. Its features include column-level lineage, a business glossary, profiling and data quality assertions, and its Docker quickstart supports evaluation before a production install.Atlas wins if the only sources are Hadoop components and you want its type system and Ranger-based access model from day one. Check the Atlas release line you plan to adopt, since its latest documented release is 2.5.0.

How each platform is built and what that means for operations

Atlas and DataHub both store metadata in services you must patch, scale and upgrade, but the service sets differ sharply. Atlas leans on the Hadoop stack you may already run, while DataHub brings its own Kafka, relational database, search and graph layers. The cards below set out each component and the operating question it raises for your team.

Atlas graph repository on HBase and Solr

Atlas persists metadata in JanusGraph, which is the only graph implementation it supports, with Apache HBase as the storage backend and Apache Solr for indexing in the documented setups. An alternative BerkeleyDB setup also exists. Your team must already operate HBase and Solr, or be ready to, and must confirm which storage combination the Atlas release you plan to run supports. Ask who owns HBase tuning and Solr index health.

Atlas REST API and Kafka hook messaging

Atlas exposes all of its functionality through a REST API and also integrates through a Kafka-based messaging interface. Hooks for Hive, HBase, Kafka, Sqoop, Storm, Falcon and Couchbase send metadata into Atlas, and consumers receive change events. Each hook is a component to version and patch alongside the Hadoop service it reads from. Check which hooks your estate needs and whether each one is maintained for your Hadoop distribution.

DataHub GMS with MAE and MCE consumers

DataHub centers on a metadata service (GMS). On Kubernetes, the MAE Consumer and MCE Consumer process metadata change events flowing through Kafka, and the Frontend serves the user interface. These are separate deployments, so scaling ingestion and serving can be planned independently. Confirm your Kafka throughput, consumer lag monitoring and how you will scale the consumers as the number of ingested sources grows.

MySQL or PostgreSQL with search and graph indices

DataHub stores metadata in MySQL or PostgreSQL and serves search from Elasticsearch or OpenSearch. The Kubernetes guide adds a graph index on Neo4j or Elasticsearch. Each store needs its own backup, capacity planning and version upgrades, and the search index can be rebuilt from the database. Decide whether your organization already runs these engines as shared services, and confirm which graph index option fits your support model before you commit.

DataHub Helm charts and system-update job

DataHub is deployed with Helm charts from the acryldata/datahub-helm repository, plus a separate prerequisites chart for Kafka, databases and search. On upgrades, the chart runs a system-update job that applies schema changes and reindexes search when needed. Treat that job as a release step with its own rollback plan, and test it against a copy of production metadata. Atlas upgrades involve Hadoop component compatibility checks instead, so the two change processes look different.

What Ranger-based security means for an Atlas estate

The Atlas README says Apache Ranger keeps metadata veracity by preventing unauthorized access paths to data at runtime, and that Atlas security is both role based and attribute based. For a team with Hive and Ranger policies in place, this means Atlas metadata is not the access control layer on its own. Ranger sits in the path and decides who can reach the data, while Atlas supplies the classifications and metadata that Ranger policies can reference. Before planning a move, record which Ranger policies depend on Atlas tags and which would still apply if the catalog changed.

A move to DataHub changes where some of those decisions are made. DataHub's documented single sign-on covers OpenID Connect providers such as Google, Okta and Azure AD, so identity can be federated, but that does not by itself reproduce Ranger's runtime enforcement on Hive or HDFS. On self-deployed DataHub Core, the operator configures the frontend server for OIDC SSO, so someone on your side owns that configuration and its upkeep. DataHub Cloud enables OIDC SSO through its interface instead. Confirm DataHub's authorization model, including how roles and metadata-level permissions are assigned, in its own documentation.

Treat the question of whether DataHub can honor existing Ranger policies as open until a proof of concept answers it. Ask the vendor or the community directly, then test it: take a Hive table with a Ranger masking or row filter policy, ingest it into DataHub, and check whether a user who is denied in Ranger can still see the data, its schema or its lineage in the catalog. Decide in advance whether catalog visibility is acceptable to your data owners, because a metadata catalog that exposes restricted table names or column descriptions can create its own disclosure risk.

Capabilities side by side

This table compares DataHub and Apache Atlas on license, release line, metadata model, lineage, integrations, ingestion, APIs, identity, and the services each one needs to run. Where the supplied sources do not settle a point, the cell says what to confirm with the vendor documentation before you decide.

CapabilityDataHubApache Atlas
License and maintainerApache-2.0, maintained by the DataHub project, with DataHub Cloud sold separately by its companyApache-2.0, an Apache Software Foundation project
Latest release linev1.6.0.3 released September 25, 2026, with v1.8.0 release candidates in October 20262.5.0 released April 30, 2026, with 2.6.0 release candidate tags in the repository
Metadata modelEntity-based metadata graph covering datasets, pipelines, dashboards and other assets from connected toolsType system of types and entities covering technical and business metadata, plus relationships between them
LineageColumn-level lineage listed as a core featureLineage depth and supported levels: confirm in the Atlas documentation for your Hive and Kafka hooks
Integrations beyond HadoopMore than 150 integrations, including Snowflake, BigQuery, Databricks, dbt, Looker and TableauDocumented hooks for Hive, HBase, Kafka, Sqoop, Storm, Falcon and Couchbase
Ingestion modelBoth push and pull ingestionHook-based capture that sends metadata through Kafka messaging
API surfaceGraphQL and REST access to the metadata service: confirm current endpoints in the DataHub docsFull functionality exposed through a REST API, plus Kafka topics for hooks and change event consumers
Identity integrationOpenID Connect SSO with providers such as Google, Okta and Azure AD; self-deployed Core requires operator configurationRole-based and attribute-based security, with Apache Ranger used for runtime access control
Glossary and data qualityBusiness glossary and data quality assertions with monitoring listed as core featuresBusiness metadata is part of the model; confirm glossary and data quality tooling in the Atlas docs
Build or runtime requirementsDocker quickstart needs 8 GB of RAM and Python 3.10 or later; Kubernetes needs more than 7 GB of RAM on MinikubeBuilds with Java 8, 11 or 17, per the Atlas README
Storage and search servicesKafka, MySQL or PostgreSQL, Elasticsearch or OpenSearch, and a graph index on Neo4j or ElasticsearchJanusGraph on Apache HBase with Apache Solr for indexing in documented setups, or a BerkeleyDB alternative
Deployment toolingHelm charts from acryldata/datahub-helm, with a prerequisites chart and a system-update job on upgradeInstallation instructions in the Atlas docs; confirm the packaged deployment options for your Hadoop distribution

What each license covers and what is paid for

Apache Atlas is an Apache Software Foundation project licensed under Apache-2.0. Its code, and the right to run, modify and redistribute it, comes with that licence, and the project's own documentation describes it as core governance services for Hadoop that also integrate with the wider enterprise data ecosystem. The downloads page lists release 2.5.0 on April 30, 2026, 2.4.0 on January 2, 2025 and 2.3.0 on December 6, 2022. The GitHub repository also carries 2.6.0 release candidate tags, which are not a production release.

  • Licence: Apache-2.0, governed by the Apache Software Foundation, with no separate enterprise edition in the supplied facts.
  • Release dates: 2.5.0 (April 30, 2026), 2.4.0 (January 2, 2025) and 2.3.0 (December 6, 2022), per the downloads page.
  • Commercial editions: none appear in the supplied facts, so any paid distribution or support contract comes from a third party.
  • Cost components: your own staff, the HBase, Solr and JanusGraph stack, and the Hadoop estate it attaches to.

Confirm with any vendor distributing Atlas whether they offer support, patches or extra connectors, and what those terms cost and cover.

What drives running cost on each side

The running cost of Apache Atlas is mostly the cost of the Hadoop-adjacent stack it depends on. Atlas stores metadata in JanusGraph, the only graph implementation available, with Apache HBase as the storage backend and Apache Solr for indexing in the documented setups. Each of those components needs its own sizing, patching, backup and monitoring, and the people who run them are usually the same Hadoop platform engineers who already keep Hive and Ranger healthy. If your estate already runs HBase and Solr, the marginal infrastructure cost may be small. If it does not, you are paying for a new distributed storage and search tier. Confirm which Atlas version and storage setup you plan to run, since the installation documentation describes more than one, including a BerkeleyDB alternative. Upgrade effort also recurs: the Atlas downloads page lists 2.5.0 (April 30, 2026) as the latest release, so ask your vendor or internal team how the HBase and Solr versions you run align with it before you commit.

The running cost of DataHub Core is driven by its service dependencies. The architecture centers on GMS with Kafka for streaming metadata changes, a MySQL or PostgreSQL database, Elasticsearch or OpenSearch for search, and a graph index on Neo4j or Elasticsearch. Each one is a service your team must size, secure, back up and upgrade, and production installs should use external managed or operator-run instances rather than the bundled quickstart. Memory is the first sizing figure to check. The Kubernetes guide says more than 7 GB of RAM is needed to run DataHub and its dependencies on Minikube, and the README cites 8 GB for the Docker quickstart. Treat both as evaluation figures, not production sizing. Ask for a load-based estimate built on your own metadata volume. Upgrades recur as well, and the Helm chart's system-update job applies schema changes and reindexes search when needed, so plan a maintenance window for each release.

Several costs are one-time and several recur. One-time work includes the migration of Atlas types, entities and lineage into DataHub, building integrations for Hive, Kafka and any Atlas hooks you rely on, and configuring SSO through OIDC on Core, where the operator configures the frontend server. Recurring costs include hosting, staff time for upgrades and monitoring, and any support retainer. Edition choice matters too: DataHub Cloud is the vendor-managed option with an SLA and no infrastructure to run, while Core is the Apache-2.0 product you operate. Before requesting a quote from DeployOpen, ask for a written scope listing the components in scope, the environments (cloud accounts, data centers or air-gapped networks), the integrations and their count, the SSO provider, the migration source and volume, the upgrade and retainer terms, and the acceptance criteria. DeployOpen does not publish a price list, and quotes follow from that written scope.

What a move from Atlas to DataHub involves, in order

This sequence moves governed metadata from Apache Atlas to DataHub without losing lineage, ownership or glossary content, and it keeps Atlas running until DataHub has proven it can answer the same questions. Each step ends with a check you can record before moving to the next one.

  1. Inventory Atlas types, entities, hooks and Ranger paths

    Your platform or data governance team lists every custom and built-in Atlas type, the entity counts per type, each active hook (Hive, HBase, Kafka, Sqoop, Storm, Falcon or Couchbase), and the Apache Ranger policies that gate access to the assets Atlas describes. Record which consumers call the Atlas REST API and which read the Kafka notification topics. The step is done when the inventory is signed off by the data owners and the security team, and every hook has a named owner. Use this list as the scope baseline for everything that follows.

  2. Map the Atlas type system to DataHub in staging

    In a staging environment, your architects map each Atlas type and relationship onto DataHub's entity model, noting where a single Atlas type splits into several DataHub entities or where custom attributes need a home. Decide which business metadata becomes glossary terms, which becomes ownership or tags, and which has no direct equivalent and needs a documented workaround. Confirm these mappings with DataHub's documentation and with a test extract, since the supplied materials do not describe a migration tool. The step closes with a written mapping document that the data owners have reviewed against a sample of real assets.

  3. Stand up DataHub on external Kafka, database and search

    The platform team deploys DataHub with its metadata service, consumers and frontend, pointed at Kafka, a MySQL or PostgreSQL database and Elasticsearch or OpenSearch that you operate yourselves, rather than the bundled quickstart services. Plan the graph index that DataHub requires, which runs on Neo4j or Elasticsearch, and confirm the sizing and version requirements with the DataHub Kubernetes guide for your target environment. The step is complete when health checks pass for every component and a test entity can be created, searched and viewed in the UI.

  4. Rebuild ingestion for each hook-fed source

    For every source that an Atlas hook fed, the data engineering team configures a DataHub ingestion recipe using push or pull ingestion, depending on whether the source system can emit metadata or DataHub must read it. Hive, Kafka and other sources with existing connectors are checked first against DataHub's integrations list. Anything without a connector is documented as a custom emitter to build and test. The step ends when each source has a scheduled or event-driven ingestion job and a run that produces the expected entity counts in staging.

  5. Migrate glossary terms and ownership

    The governance team exports glossary terms, term relationships and asset ownership from Atlas, where export options are available in your Atlas version, and loads them into DataHub's business glossary. Where export is not available or incomplete, the team recreates terms from the mapping document and assigns owners from the inventory. Confirm the available export and import paths with DataHub before you rely on them. The step is done when a sample of terms and owners matches between the two catalogs and the data owners have confirmed their assets.

  6. Rebuild access controls and SSO in DataHub

    The security team recreates the access model that Apache Ranger enforced for Atlas-described assets, since DataHub does not inherit Ranger policies. They configure SSO through OpenID Connect on the self-deployed frontend, following the DataHub OIDC guide, and test role assignments with named test accounts. The step closes when a policy review confirms that every user group reaches only the assets it reached before, and the access results are recorded for audit.

  7. Run both catalogs in parallel and compare lineage

    For a defined period agreed by the governance and data teams, both catalogs run side by side. Each week, the team compares lineage graphs, entity counts and search results for a fixed set of critical pipelines between Atlas and DataHub, logging every difference and its cause. DataHub's column-level lineage is checked against the Atlas lineage for the same tables. The step ends when the critical pipelines show no unexplained differences and the owners sign off that the lineage is complete enough to rely on.

  8. Cut over consumers and retire Atlas dependencies

    Once parallel running is signed off, the platform team points consumers from the Atlas REST API and Kafka notification topics to DataHub's interfaces, then stops the Atlas hooks. Atlas, its JanusGraph store on HBase and its Solr index are kept in read-only mode until the retention requirement set by your compliance team is met, then retired in a controlled change. The step is done when no consumer calls Atlas, the hooks are off, and the archive and decommissioning record is approved.

Where Atlas and DataHub projects usually run long

Atlas projects tend to run long in the hook and index layer rather than in the catalog itself. Each source needs its hook configured and tested: Hive, HBase, Kafka and any other hooks you enable, plus whatever sources you add beyond them. Confirm which sources have a supported hook in your Atlas version and which would need custom work. HBase and Solr also need tuning for your metadata volume, and that tuning is easy to underestimate because the JanusGraph storage sits on top of them. Ranger policy alignment is the other common slip. Atlas security is role based and attribute based, and Ranger keeps metadata veracity by blocking unauthorized access paths at runtime, so every policy that exists in Ranger today has to be mapped, reviewed and tested against the Atlas model before cutover.

DataHub projects tend to run long in the platform layer. A production install means Helm charts from the acryldata/datahub-helm repository, a separate prerequisites chart, and external Kafka, MySQL or PostgreSQL, Elasticsearch or OpenSearch and graph index services that you size and operate. Plan for OIDC configuration on DataHub Core, where the operator configures the frontend server, and write ingestion recipes for each source you need, since coverage depends on connectors rather than hooks. Rehearse the system-update job in a non-production environment before any production upgrade, because it applies schema changes and reindexes search when needed. Staff who lack Kubernetes or search operations experience will find this stage hardest, so confirm that skill before committing to a date.

Both projects share two slip points. The first is custom types: Atlas uses its type system for technical and business metadata, and DataHub has its own entity model, so unmapped custom types in either direction mean rework during migration. The second is lineage gaps for sources without a hook or connector. Build an inventory of every source that feeds your governance reports, mark which have native support in each platform, and assign an owner to each gap before implementation starts.

Questions buyers ask before hiring help

What does it cost to run DataHub Core compared with Apache Atlas?

Both are open-source under Apache-2.0, so the license fee is zero for either, and the cost is the infrastructure and people needed to run them. DataHub Core runs as several services: a metadata service (GMS), Kafka for streaming metadata changes, MySQL or PostgreSQL storage, and Elasticsearch or OpenSearch for search, with a graph index on Neo4j or Elasticsearch. Atlas typically runs on JanusGraph with HBase and Solr, alongside the Hadoop stack it already depends on. The main cost drivers are the number of services you operate, the size of your metadata estate, and how much of that stack your team already runs. Ask any vendor or partner to quote infrastructure, staffing and support separately, and confirm which parts are one-time (installation, integration, hardening) and which recur (patching, upgrades, on-call).

Can an internal team run DataHub Core without outside help?

Yes, many internal teams can, but the answer depends on existing Kubernetes, Kafka, database and search skills. The DataHub Kubernetes guide deploys with Helm charts from the acryldata/datahub-helm repository plus a separate prerequisites chart for dependencies. Production operation means running Kafka, a database, Elasticsearch or OpenSearch and the graph index as services you own. The Helm chart runs a system-update job on upgrades to apply schema changes and reindex search when needed, so upgrade planning matters. Self-deployed DataHub Core also requires the operator to configure SSO on the frontend server. Before deciding, have your engineers test a non-production install and confirm the upgrade path with the DataHub project's current documentation.

How long does a migration from Apache Atlas to DataHub take?

The duration depends on the number of Hive, HBase, Kafka and other hooks you rely on, the volume and shape of existing entities and classifications, how much custom type-system modeling you have, and how many downstream consumers call the Atlas REST API or Kafka change events. Atlas exposes its functionality through a REST API and a Kafka-based messaging interface, so each consumer needs an equivalent path in DataHub. DataHub's ingestion covers more than 150 integrations, but you must confirm each source you need. No timeline is established here. Ask for a written scope that lists sources, metadata to migrate, parallel-run period and cutover criteria before accepting any estimate.

Is Apache Atlas still needed if Apache Ranger stays?

Ranger and Atlas do different jobs, so keeping Ranger does not automatically replace Atlas. Atlas README describes Ranger as the mechanism that maintains metadata veracity by preventing unauthorized access paths to data at runtime, while Atlas provides the metadata model, classifications and lineage. If your audit or governance processes depend on Atlas entities, tags or lineage that Ranger consumes, removing Atlas changes that workflow. Confirm with your security and data governance owners which Ranger policies rely on Atlas classifications, and test whether DataHub's integrations and tagging can supply the same information before retiring Atlas.

Does DataHub need DataHub Cloud for single sign-on?

No. DataHub supports single sign-on through OpenID Connect providers such as Google, Okta and Azure AD. On self-deployed DataHub Core, the operator must configure the frontend server, which is an engineering task in your environment. DataHub Cloud enables OIDC SSO through its interface, which reduces that configuration work but moves the platform to a managed, paid service. Confirm with the vendor which SSO features, group mappings and provisioning options are available in each edition, since the OIDC SSO guide documents the Core configuration path and your identity provider's settings will determine the exact steps.

What does a fixed-scope implementation need from our team?

A fixed-scope engagement works only when scope, deliverables and timelines are agreed in writing before work starts, and that agreement depends on your team's input. Typically you need named owners for the data sources in scope, access to the Hadoop, Hive or Ranger environments and to the target infrastructure, decisions on identity integration and metadata ownership, and people who can review and accept deliverables. DeployOpen plans, implements, integrates, hardens, backs up, upgrades and documents self-hosted platforms inside your own cloud accounts, data centers or air-gapped networks, so access to those environments is part of the scope. Ask for a written list of your responsibilities alongside the vendor's deliverables.

Can we run a proof of concept before committing to a migration?

A proof of concept is a sensible way to test fit before a full migration, and it can run in a non-production environment that mirrors your Hadoop and Hive estate. Choose a representative slice: a few Hive databases, one Kafka hook path and the consumers that rely on Atlas APIs. Measure ingestion coverage, lineage accuracy, search behavior, and how your Ranger-related workflows behave. For DataHub, the Docker quickstart requires Docker with 8 GB of RAM and Python 3.10 or later, which suits evaluation rather than production. Confirm with the DataHub project which deployment path you should use for the proof of concept and what it leaves behind for production.

Can DeployOpen run security testing on the finished deployment?

Yes. DeployOpen runs security testing for applications and APIs, cloud and infrastructure, and AI systems, and it can test a finished self-hosted deployment inside your environment. Testing is a separate scope from implementation, so it is agreed in writing with its own deliverables and timeline. Most engagements are fixed-scope, and ongoing continuous testing is available as a retainer. Testing covers the platform as deployed, including the DataHub services or the Atlas and Hadoop components you run, network paths, identity integration and access controls. Confirm with DeployOpen which systems, environments and test types are in scope before you agree a quote.

How DeployOpen helps choose, implement or migrate

DeployOpen is a Chainscore Labs company that plans, implements, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure. For a DataHub vs Apache Atlas decision, we work from your Hadoop, Hive and Ranger estate and your target services before recommending a platform, and we only build what the written scope covers.

How we scope

  • We inventory your Hadoop, Hive, Ranger and other source systems to define which metadata and lineage must be captured.
  • We confirm the services you will run yourselves, such as Kafka, a relational database, search and any graph or storage backend.
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts.
  • We document which features you need from the open-source edition and which you must confirm with the vendor.

How we build

  • We deploy the chosen platform in your cloud accounts, data centers or air-gapped network, using your approved infrastructure patterns.
  • We configure ingestion from Hive, Hadoop and other sources, and test lineage output against sample pipelines you provide.
  • We wire authentication and authorization to your identity provider and review access controls against your Ranger policies.
  • We run security testing on the deployment and document the findings and fixes before cutover.

How we hand over

  • We deliver architecture diagrams, runbooks, configuration records and a migration plan for moving existing Atlas metadata.
  • We run knowledge transfer sessions with your platform, data and security teams so they can operate the system.
  • We prepare controls and evidence that your team and any independent auditor can review, without issuing attestations ourselves.
  • We document upgrade steps so your team can plan future releases on the platform's own cadence.

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers after handover.
  • A retainer can cover monitoring of release notes and planned upgrades for the services you run.
  • We can repeat security testing after changes to ingestion sources, identity settings or deployment topology.
  • Support scope, response expectations and fees are set in the written agreement, and we provide a quote from your scope.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.