Migrate from Apache Atlas to OpenMetadata

Moving from Apache Atlas to OpenMetadata is mostly a re-ingestion and mapping project, not a database copy. This page explains what carries over, which documented paths to use, and how a parallel run leads to cutover.

On this page

How do you migrate from Apache Atlas to OpenMetadata without losing lineage and ownership?

The move from Apache Atlas to OpenMetadata is mainly a re-ingestion and mapping project. Most tables, topics and lineage edges are rebuilt by running OpenMetadata connectors against the Hive and messaging sources, and only the items that exist solely in Atlas need to be carried over by export. Effort depends on three things: the size and shape of your Hive and messaging estate, the number of Atlas classifications you rely on, and how much governance is maintained by hand inside Atlas rather than derived from the sources. Before estimating, confirm your Atlas version, how the Atlas hooks are configured on Hive and Kafka, and the target OpenMetadata version. Those three facts decide which ingestion paths, export methods and upgrade steps apply.

Lineage needs the most careful handling. Atlas builds lineage from hook messages it receives when Hive queries or Kafka streams run, so an edge exists in Atlas only if the hook fired and Atlas accepted the message. OpenMetadata builds lineage from the connectors it runs and from OpenLineage events where your pipelines emit them, covering table, column, dashboard, pipeline and metric lineage. The two sources will not produce identical graphs. Export the Atlas lineage edges for a sample of critical tables and topics through the Atlas REST API, then check whether each edge appears in OpenMetadata after ingestion. Edges that exist only in Atlas need an explicit decision: rebuild them with an OpenLineage emitter, add them through the OpenMetadata API, or accept the gap and record it. Keep that list as a deliverable owned by the data platform team.

Ownership is the field most likely to be lost silently. Ingestion from Hive or Kafka does not know who Atlas says owns a table or topic, so owners must be carried over deliberately. Create the teams and users in OpenMetadata first, through your identity provider's SSO integration or another provisioning path you choose, because an owner reference can only point to an entity that already exists. Then export the Atlas owner attributes and any custom ownership attributes, map each one to a user or team, and assign them through the API after ingestion. Run a check that counts entities without an owner in each system and review the differences by domain. Ask your data owners whether the Atlas owner names are still current, since a migration is a good moment to find stale assignments.

Atlas classifications are often the largest source of hidden governance logic, because each one may carry attributes, propagation rules or manual assignments made over several years. Build a mapping table with one row per classification: the OpenMetadata tag or glossary term it becomes, the business owner who approves that mapping, and whether the classification is used at all. Consolidate classifications that describe the same thing and retire unused ones. The fewer classifications you map, the less rework you carry into the target. Manual tag assignments made in Atlas must be reapplied in OpenMetadata, and any automated propagation has to be recreated explicitly. Test a sample of sensitive columns to confirm each one carries the expected tag and glossary term after migration.

Verification should drive the cutover date rather than follow it. For each Hive database and messaging cluster in scope, compare entity counts by type, owner coverage, classification coverage and lineage edges between the two systems, and record every difference with a named decision. Run both catalogs in parallel for an agreed period so that data consumers can check their searches and dashboards against OpenMetadata, and keep Atlas available in read-only mode for rollback. Before any decommissioning, confirm how Atlas stores its backend data and whether an export of its history is required, because some metadata and audit trails may not be visible through its API. The final sign-off should name the person who accepts each remaining gap.

What maps cleanly from Atlas to OpenMetadata and what does not

This table compares how each major Apache Atlas capability maps to OpenMetadata and what the migration involves for each one. Read the migration notes first: direct mappings still need checks, re-ingested metadata comes from source systems, and rows marked for rework need a decision before any data moves. The main takeaway is that Hive, Kafka and lineage are rebuilt from their sources, while custom Atlas types need an explicit decision.

Atlas capabilityOpenMetadata equivalentMigration notes
Hive databasesDatabase and schema entities under a database serviceRe-ingest from the Hive metastore. Atlas records are not copied across. Confirm service names and schema filters before ingestion.
Hive tables and columnsTable and column entities with data types and descriptionsRe-ingest from source. Descriptions and tags added in Atlas need a separate export and review step.
Kafka topicsTopic entities under a messaging serviceRe-ingest from the Kafka cluster. Confirm schema coverage and which Atlas attributes your teams still need.
ClassificationsTags and tag categoriesDirect in concept: map each Atlas classification to a tag category. Decide whether propagation behavior matches what Atlas did.
Glossary termsGlossaries and glossary terms with descriptions and relationshipsDirect for term names and definitions. Relationship types and term hierarchies need a mapping decision before import.
OwnershipOwner fields on tables, services and other entitiesManual rework: Atlas owner attributes often hold names or groups. Match them to OpenMetadata users and teams first.
LineageLineage edges between tables, columns and pipelinesRe-ingest or rebuild: pipeline lineage comes from connectors or OpenLineage events. Confirm coverage for each source.
Custom types and attributesNo direct field for most custom attributesDecision required: map to custom properties, tags or descriptions, or keep in Atlas. Inventory every custom type first.

Why Hive and messaging services should map first

The first mapping pass should cover the Hive and messaging services because Atlas records most of its structure there, and everything else attaches to that structure. In Atlas, Hive databases contain tables, tables contain columns, and Kafka topics carry names and owners. Classifications, lineage and glossary links are later applied to these objects. If the hierarchy is wrong at this stage, every later step attaches metadata to the wrong parent. Start by exporting the Atlas entities for Hive databases, tables, columns and messaging topics. For each one, record its parent service, its owner, and whether it still exists in the source system.

Naming is where most of the risk sits. OpenMetadata identifies each asset by a fully qualified name built from the service, database, schema and table names. Atlas identifies entities by its own qualifiedName convention, which can include cluster or host details that OpenMetadata does not use. These two schemes rarely line up by default. Decide the OpenMetadata service names first, then build a mapping table that converts each Atlas qualifiedName into its target fully qualified name. Check case handling, the default schema behavior for Hive databases, and how topic names containing dots or hyphens are treated by the connector you choose.

Unmatched names create duplicate assets. Illustratively, if a connector ingests a Hive table as one fully qualified name while the migrated Atlas record lands under a different service and schema, the catalog holds two entries for one table. Owners, tags and descriptions then split across them, and search returns both. Duplicates also break lineage, because edges point at one entity while documentation sits on the other. After the first pass, run a reconciliation query that counts assets per fully qualified name and flags any table or topic that appears under two services. Zero duplicates should be the exit condition for this section.

Connector coverage is the final check. OpenMetadata lists more than 130 connectors for warehouses, BI tools, pipelines and ML platforms (OpenMetadata GitHub). Confirm which Hive and messaging connectors you will use, the OpenMetadata version they support, and their documented scope: which metadata they read, whether they capture columns, ownership and topic schemas, and what they leave out. Any Atlas metadata that the chosen connector does not cover will need a manual or API-based path. Record those gaps now, so owner assignments and naming decisions are made with the actual connector behavior in view.

Which documented paths carry metadata into OpenMetadata

OpenMetadata documents several ways to bring metadata in, and no single one replaces an Atlas export on its own. Each path below suits a different kind of Atlas content, so the migration plan should map Atlas entity types to a path before any load starts.

Metadata connectors for Hive and messaging

OpenMetadata lists more than 130 connectors for warehouses, BI tools, pipelines and ML platforms, and this migration starts with the connectors for Hive and messaging services. Confirm, for each Atlas entity type you hold, whether the matching connector ingests that object type and at what depth. Atlas custom types and attributes often have no direct connector field, so inventory them before assuming a connector carries them.

Kafka and streaming connector coverage

Atlas commonly holds Kafka topics and their schemas, which are a typical starting point for messaging services in OpenMetadata. Check the connector's documented scope for topic configuration, schema registry details and ownership, since Atlas relationships to producers and consumers may not map one to one. Test the connector against a non-production cluster and compare counts before accepting it as the source of record.

REST APIs for controlled loads

OpenMetadata provides REST APIs for creating and updating entities programmatically, which suits Atlas content the connectors do not reach. Use the APIs to load owners, descriptions and custom mappings in a repeatable script, and record each request so the load can be rerun. Confirm the API version, authentication method and rate behavior against your deployed release before writing the loader.

Python SDK for scripted loads

The Python SDK offers programmatic access for teams that already keep migration logic in Python. It fits transformation work such as mapping Atlas glossary terms or classifications to OpenMetadata objects before writing them. Confirm the SDK version matches your OpenMetadata server, because ingestion and API models change between releases.

TypeScript packages and Java libraries

OpenMetadata provides TypeScript packages and Java libraries for programmatic access, which may suit teams whose tooling is built in those languages. Choose one client language per migration to keep mappings, tests and credentials in one place. Verify which entity types each package exposes before relying on it for a particular Atlas object.

OpenLineage events for lineage

OpenMetadata supports table, column, dashboard, pipeline and metric lineage with OpenLineage event integration. Atlas lineage is often built from hook-based events, so decide whether the pipelines that emit lineage today can send OpenLineage events, or whether historical lineage must be rebuilt. Confirm which lineage levels your pipeline tools emit and test column-level lineage on one pipeline first.

How a parallel run and cutover from Atlas are sequenced

This sequence moves metadata governance from Apache Atlas to OpenMetadata without a period where teams cannot find data or trust its owners. Each step produces a named deliverable and a check that must pass before the next step starts. Atlas stays readable until reconciliation and cutover are signed off.

  1. Inventory Atlas types, classifications and lineage sources

    Your Atlas administrators, with DeployOpen if the work is engaged, list every type definition, classification, glossary term and lineage source in Atlas. The inventory also covers the hooks, bridges and feeds that write metadata into Atlas, because those define where lineage comes from. The deliverable is a written inventory with a count per category and a named owner for each item. The check is that a second reviewer can trace every Hive and messaging source in the inventory to a system of record. Confirm with your Atlas team which custom types exist, since those are often missing from existing documentation.

  2. Map concepts and stand up OpenMetadata

    Map each Atlas classification and glossary term to an OpenMetadata tag, glossary term or domain, and record where each one lands. In parallel, deploy OpenMetadata on a supported model: Kubernetes on a managed or on-premises cluster, or bare metal. For bare metal, the documented prerequisites are Java 21, MySQL 8.0.42 or later or PostgreSQL 15 or later, and Elasticsearch 9.x or OpenSearch 3.x. The deliverable is a concept mapping document and a running instance in your environment. The check is a passing health check and a successful sign-in through your identity provider.

  3. Pilot one Hive database and messaging service

    Ingest one Hive database and one messaging service into OpenMetadata, then compare each asset against what Atlas shows for the same source. Record which entities, owners, tags and lineage edges carried over through the mapping, which had to be re-ingested from the source system, and which need manual work. The deliverable is a pilot report with a row for each asset type and its disposition. The check is that the pilot owners confirm search results, ownership and tags match what their users expect before any other source is migrated.

  4. Run both catalogs in parallel

    Keep Atlas as the catalog people read from while OpenMetadata ingests the same in-scope sources on a schedule you set. Expand the pilot to the remaining sources in batches, and assign an owner to each source feed. The deliverable is a parallel-run schedule and a register that lists which sources feed each catalog. The check is that ingestion from every in-scope source completes without unexplained errors for the whole run window, and any failed run is logged with its owner and the fix applied.

  5. Reconcile counts, owners and lineage

    For each in-scope source, compare entity counts, owner assignments and lineage edges between Atlas and OpenMetadata. Classify each difference as a migration gap to fix, a change in the source system, or an accepted change with a recorded reason. The deliverable is a reconciliation report with a named decision owner for every open item. The check is that no difference remains unexplained, and the data owner for each domain has signed off the report before consumers are moved.

  6. Cut over consumers and governance workflows

    Repoint dashboards, search integrations, API clients and stewardship workflows from Atlas endpoints to OpenMetadata. Use the REST APIs or the Python SDK for consumers that are scripted, and retrain stewards on the workflows they will use. The deliverable is a consumer inventory with a cutover status and a rollback note for each consumer. The check is that every consumer returns the expected results from OpenMetadata, and no production process still reads from Atlas.

  7. Decommission Atlas after the retention period

    Place Atlas in read-only mode and keep it for a retention period set by your records and compliance team. Take a backup before shutdown and test that it restores. The deliverable is a decommission record covering the backup location, the access removed, and the final reconciliation result. The check is that the retention period has ended, the restore test passed, and no consumer still calls Atlas. Confirm the retention requirement in writing before the read-only date is set.

Replacing Atlas classifications with OpenMetadata tags and glossary terms

The first decision here is not technical. List every Atlas classification in use and record what each one means to your organization before choosing a target. Atlas classifications often encode sensitivity levels, retention periods or regulatory scope, and they are commonly attached to an entity so they flow downstream through lineage. Export the classification definitions, the entities carrying them and any attributes stored on each one. Then sort each classification into one of two groups. Classifications that describe a property of an asset, such as a sensitivity level or a retention label, usually become OpenMetadata tags, which teams can search and filter on. Classifications that name a business concept, such as a loan product or a customer identifier, usually belong in the glossary, where terms carry a definition, an owner and relationships to other terms. Record the decision and the approver for each row.

Propagation is the part most likely to be assumed away. In Atlas, a classification can propagate along lineage so that a sensitive source column marks derived columns automatically. Before assuming OpenMetadata behaves the same way, confirm how your Atlas propagation rules actually work: which classification types propagate, in which direction, whether propagation can be blocked on a single entity, and whether anyone has overridden it by hand. Pull a sample of entities that inherited a classification through lineage and record whether each label was inherited or set directly. OpenMetadata supports table and column lineage with OpenLineage event integration, but whether a tag applied upstream reaches downstream assets in your deployment depends on how lineage and tagging are configured. Write the expected behavior for each classification as a rule, test it on a known path after migration, and log any gap with a named owner.

Reapplying classifications is a separate step from moving metadata, and re-ingested assets arrive without the Atlas labels. Keep the mapping in version control as a versioned artifact. Each row should hold the Atlas classification, its OpenMetadata target (tag, glossary term or domain), the approver and the pipeline that applies it. Apply labels through the REST API or the Python SDK in a script that can run again without creating duplicates. Then check how your connector runs treat tags that someone has already set in the user interface. Depending on configuration, a re-ingestion may overwrite manual changes or leave them alone, so confirm this on a test source before the production run. Also decide what happens to labels on assets that still exist in your sources but were removed from Atlas, since no one may own that decision yet.

Finally, check that the governance decisions still hold. Build a checklist from the Atlas inventory: every asset that carried a sensitivity classification should carry its equivalent tag, every glossary term should have an owner and a definition, and domains should match the business areas that own the data. Review any access or retention decision that relied on an Atlas label against the new label before relying on it. Run the same queries against both catalogs during the parallel period and reconcile each difference with the data owner. Have your compliance lead sign off the reconciled list. This produces evidence an independent auditor can review, but it does not replace the audit itself. Keep the reconciliation records alongside the mapping so the reasoning behind each decision can be traced later.

What drives the cost and duration of an Atlas migration

This table lists the drivers that change the effort of moving from Apache Atlas to OpenMetadata, with the items to request in a quote. Read the one-time migration drivers first, then the recurring ones that continue after cutover, such as consumer maintenance and access administration. Most of the effort sits in inventory, lineage rebuilding and owner cleanup, so ask for those in writing.

DriverWhy it mattersWhat to ask for in a quote
Hive databases and messaging servicesOne-time: each database and messaging service becomes a mapping and validation unit, so effort grows with the count.Inventory of Hive databases and messaging services, and the connector scope for each.
Custom Atlas types and classificationsOne-time: each custom type needs a target in OpenMetadata tags, custom properties or glossary terms, decided before import.Export of the type and classification catalog, with a mapping decision for each item.
Hook-based lineage that must be rebuiltOne-time: lineage captured by Atlas hooks may not carry over and may need rebuilding from source connectors or OpenLineage events.Which lineage paths come from hooks, and which pipelines already emit OpenLineage events.
Quality of owner and glossary dataOne-time: missing owners, stale terms and unreviewed glossary entries add cleanup before import and sign-off by data stewards.Who approves owner and term mappings, and the cleanup scope agreed before import starts.
Downstream consumers reading the Atlas APIRecurring after cutover if unchanged: each script, report or application calling Atlas REST endpoints needs a tested replacement path.A list of consumers, the Atlas endpoints each one calls, and the replacement approach for each.
Parallel run lengthOne-time, but it adds operating load: both systems need owners, monitoring and reconciliation while they run side by side.Exit criteria for the parallel run and a named owner for each system during the overlap.
SSO and access control integrationRecurring: OpenMetadata documents SSO with several providers and does not allow SSO combined with basic authentication, so access design affects ongoing administration.Confirmation that your identity provider is on the documented list, and a mapping from Atlas policies to OpenMetadata roles.
New or existing OpenMetadata deploymentOne-time for a new deployment (build, hosting and integration). Recurring for both: upgrades, patching and capacity follow the deployment you choose.Current OpenMetadata version, hosting model and whether upgrade and operations support is included in scope.

What usually goes wrong when migrating from Apache Atlas

Most migration problems appear only after both catalogs run side by side, when names, lineage, tags, owners and callers disagree. Each card below names one failure mode and a check to run before cutover.

Duplicate assets from mismatched names

Atlas identifies entities by qualified names that may follow different conventions from OpenMetadata fully qualified names, which are built from service, database, schema and table. Ingesting the same Hive or messaging objects under a second name creates duplicates that split lineage, tags and owners across two records. Before the first full run, build a mapping table from each Atlas qualified name to its target FQN, run ingestion in a staging instance, and check for doubled tables and topics.

Lineage gaps from hook-only sources

Atlas hooks may have been the only place certain Hive, Spark or messaging lineage was captured, so those edges exist nowhere else. OpenMetadata lineage depends on the sources you ingest, including query history and OpenLineage events where your stack emits them. Inventory each lineage edge by its original capture method, confirm an equivalent source for every engine, and trace a sample pipeline end to end in staging before you retire the hook.

Classifications that lose propagation

Atlas classifications can propagate to downstream entities along lineage, so a sensitive tag on a source table can reach derived tables automatically. OpenMetadata tags and glossary terms are applied and governed differently, so confirm how any inheritance or propagation behaves in the release you deploy. List each Atlas classification with its propagation setting, choose the target tag or glossary term, and test that a downstream asset shows the expected label.

Owners not carried over

Atlas owner information often lives in custom attributes or free-text fields that do not map directly to OpenMetadata users and teams. Ownership gaps surface later as assets nobody answers for during access reviews or incidents. Export owner attributes for every migrated entity, map each value to an existing user or team, and report assets with no owner before cutover. Confirm in writing who approves any exceptions.

Consumers still calling Atlas APIs

Scripts, notebooks, internal portals and scheduled jobs often call Atlas REST endpoints directly, and they keep working until the day the source is switched off. Once Atlas stops receiving updates, those calls may return stale or missing data without raising an error. Build an inventory from gateway or access logs, rewrite each caller against OpenMetadata REST APIs or its Python SDK, and run both catalogs for a defined period with a dated retirement decision.

Ingestion images and versions unvalidated

Ingestion runs in container images whose Python, Airflow and connector versions must match the OpenMetadata release you target. If you target 2.0.0, review its breaking changes first, including rebuilding custom ingestion images for Python 3.12, migrating Great Expectations to 1.3, and new credential and Databricks auth formats. Rebuild and test images in staging, pin versions, and follow the OpenMetadata upgrades procedure for the upgrade path itself.

Questions buyers ask about migrating from Apache Atlas

How much does an Apache Atlas to OpenMetadata migration cost?

The cost follows from a written scope, and DeployOpen does not publish a price list. The main drivers are how many Atlas types, classifications and glossary terms need mapping, how many Hive databases and messaging services are in scope, how many source systems feed Atlas today, whether historical lineage must be validated or rebuilt, and how long Atlas and OpenMetadata must run side by side.

Costs fall into two groups. One-time work covers assessment, mapping, scripted loading, validation and cutover. Recurring costs cover the infrastructure that hosts OpenMetadata and its database and search services, plus any support or upgrade retainer you choose. Ask each quote to list phases, deliverables, assumptions about your Atlas export and which tasks your own team performs.

How long does migrating from Apache Atlas take?

Duration depends on scope, so no fixed timeline applies until the scope is written. The biggest factors are the volume of Atlas metadata, the number of Hive and messaging services to map, how much classification and glossary cleanup is needed, the lineage you must keep, how quickly your team can grant access to Atlas, and how fast owners review their assets.

Governance decisions often set the pace. Someone must decide how each Atlas classification becomes an OpenMetadata tag, glossary term or domain before loading starts. Ask for milestones tied to your own decisions and approvals, with dependencies named and decision dates agreed before work begins.

What does our team need to provide for the migration?

Plan on your team supplying access and decisions, not only time. Expect to provide read access to the Atlas REST API or exports, including type definitions, classifications and entity relationships. You will also need an inventory of the Hive and messaging services in scope, named owners for each domain, governance decisions on which classifications become tags, glossary terms or domains, a test environment, and security sign-off on service accounts and credentials.

For hosting, the OpenMetadata bare metal guide lists minimums of 2 vCPUs, 4 GB RAM and 20 GB storage for the server, and at least 2 vCPUs, 2 GB RAM and 30 GB storage each for the database and search services. These figures are minimums, so confirm production sizing in the scope. Ask the proposal to name each client task and its owner.

Can our own team migrate from Atlas using documented connectors?

Yes, a capable internal team can do parts of the work, but confirm first whether OpenMetadata's documented connectors cover the Atlas data you hold and the Hive and messaging services you run. OpenMetadata is released under the Apache License 2.0 and lists more than 130 connectors for warehouses, BI tools, pipelines and ML platforms. It also provides REST APIs, a Python SDK, TypeScript packages and Java libraries for scripted loading.

Connector scope and stage vary by service, so check the documentation for each one you need. Mapping Atlas classifications to OpenMetadata tags and glossary terms also requires business decisions from governance owners, and those decisions should be made before any script runs. Decide early which parts your team will build and which parts you want a partner to deliver.

Does Apache Atlas lineage carry over to OpenMetadata automatically?

Do not assume it does. Run a test extract and confirm what lineage Atlas exposes for your entities and how it maps to OpenMetadata's table, column, dashboard, pipeline and metric lineage. OpenMetadata supports OpenLineage event integration, so lineage can also come from live pipeline events going forward.

Historical lineage usually needs validation. Entities that were renamed, moved or deleted in Atlas, and edges that someone curated by hand, need a manual check. Ask for a lineage reconciliation report in the written scope that lists which edges moved, which were rebuilt from source systems and which were dropped, with the reason for each.

How are parallel running and cutover handled during migration?

Parallel running means Atlas and OpenMetadata both exist while owners compare results. A typical plan keeps Atlas read-only as the reference, compares entity counts, owners, classifications and lineage by domain, and logs every gap with a named owner. Running both catalogs also means hosting OpenMetadata alongside Atlas, so include that infrastructure in the cost discussion.

Cutover happens after owners approve their domains. The plan should name a freeze point for Atlas writes, the switch of links and browse paths, the retirement of Atlas hooks and the feeds that publish to Atlas, and a rollback path that keeps Atlas available until users confirm. Ask for the cutover runbook and the rollback criteria in the scope, and confirm which consumers, such as scripts or Kafka hooks, still depend on Atlas.

What usually breaks when moving from Atlas to OpenMetadata?

Most problems start in identity mapping and ownership. Common failures include entity names or qualified names that do not match between the two catalogs, which creates duplicate assets. The same table can also be ingested from two sources, classifications can be copied without a governance decision and create tag sprawl, owners can be stale, and access rules set in Atlas may not be reproduced.

Authentication needs early planning. OpenMetadata documents SSO with providers such as Okta, Azure, Google, Keycloak and custom OIDC, but it does not support combining SSO with basic authentication. Plan administrator access and a recovery path before SSO goes live. Also check the runtime prerequisites on the day you install: Java 21, MySQL 8.0.42 or later or PostgreSQL 15 or later, and Elasticsearch 9.x or OpenSearch 3.x.

How DeployOpen works on this

DeployOpen plans, builds, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For an Apache Atlas to OpenMetadata migration, we start with a written inventory of what Atlas holds and what your teams need from the catalog, then move it in controlled stages with checks at each step.

How we scope

  • Inventory Atlas types, entities, classifications and lineage before agreeing what migrates
  • Map Hive and messaging service metadata to OpenMetadata services first, as the initial scope
  • Agree in writing how Atlas classifications become OpenMetadata tags and glossary terms
  • Fixed-scope engagements are agreed in writing with deliverables and timelines before work starts

How we build

  • Stand up OpenMetadata in your environment on Kubernetes or bare metal, sized to your workload
  • Configure the Hive and messaging connectors and run test ingestion against a non-production copy
  • Rebuild Atlas classifications as tags and glossary terms, then validate lineage edges against source records
  • Check counts, owners and descriptions against the Atlas export before any cutover decision

How we hand over

  • Provide runbooks for ingestion schedules, connector configuration and credential rotation
  • Document the mapping decisions, exceptions and any metadata that was re-ingested rather than carried over
  • Walk your platform and data teams through the catalog, governance model and upgrade procedure
  • Deliver the migration record so your auditors and owners can trace how each item moved

How we support

  • Ongoing support, upgrades and continuous testing are available as a retainer after handover
  • Plan OpenMetadata upgrades with the 2.0 breaking changes reviewed before any version change
  • Confirm with your team which Atlas-dependent consumers still need access during the transition period
  • Retire the Atlas instance only after you sign off on parity checks and a rollback path

Sources and further reading

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.