Deploy OpenMetadata

Deploy and Host OpenMetadata on Railway

OpenMetadata is an open-source metadata platform: a searchable catalog of every table, dashboard, pipeline, topic and ML model in your data stack, with column-level lineage, data quality tests, a business glossary and governance workflows on top. It answers the questions that otherwise cost hours in Slack — where did this number come from, who owns this table, what breaks if I drop this column. It ships 75+ connectors under Apache-2.0, so there is no seat cost and no data leaves your infrastructure.

Deploy OpenMetadata on Railway and you get the production shape, not a demo container. The template runs four services: the server (API and React UI) on a public domain, an Elasticsearch node backing search and lineage, an Airflow-based ingestion agent running your connector jobs on a schedule, and managed PostgreSQL holding the catalog. They talk over the private network, so only the web UI is exposed. To self-host OpenMetadata otherwise means writing a Compose file and generating your own signing keys.

Getting Started with OpenMetadata on Railway

Set OM_ADMIN_PASSWORD before you deploy — it becomes the password for admin@open-metadata.org, created before the server takes its first request, so the documented admin/admin default never exists on your instance. First boot runs the migrations and generates a JWT key pair, so allow four or five minutes before the URL answers.

Sign in, then connect a data source. Go to Settings → Services → Databases → Add New Service, pick a connector such as Postgres, Snowflake or BigQuery, and fill in the host, port, database and credentials. Click Test Connection — it runs inside the ingestion agent, so a green result also proves that tier is healthy. Finish the wizard and OpenMetadata deploys scheduled agents for you; the metadata agent runs immediately. Watch the Agents tab until it reports assets ingested with zero errors, then open Explore. Self-signup is off by default, so add colleagues from Settings → Members → Users rather than sharing the admin login.

About Hosting OpenMetadata

OpenMetadata began at Uber and is maintained by Collate under Apache-2.0. It suits a team that has outgrown a spreadsheet of table owners but does not want a per-seat SaaS catalog holding a map of its warehouse. The closest alternatives are DataHub, stronger if you will build on its metadata model, and Amundsen, which is search and little else.

Key features:

• Unified discovery — search across tables, dashboards, pipelines, topics, ML models and APIs.
• Column-level lineage — parsed from query history and dbt, drawn as an interactive graph.
• Data quality — declarative tests, freshness and volume checks, per-column profiles, alerting.
• Glossary and classification — business terms, tags and PII labels that follow lineage.
• Governance — approval workflows, ownership, certification, tiers and domains.
• Open APIs and MCP — REST API, Python SDK and a Model Context Protocol server for AI assistants.

The server is a Java application serving the REST API and the React UI, and owns every write. PostgreSQL is the system of record: entities, relationships, lineage edges, test results and encrypted credentials. Elasticsearch holds the indexes Explore and lineage read from, rebuilt from PostgreSQL. The ingestion agent is an Airflow instance carrying the connector library, which the server deploys DAGs into.

Why Deploy OpenMetadata on Railway

Running this stack yourself means four containers, a private network and generated keys.

• Server, search, ingestion and database wired together in one click.
• Private networking, so only the web UI is reachable from the internet.
• Persistent volumes for the search index, ingestion DAGs and signing keys.
• Per-deployment JWT and encryption keys generated automatically.
• Scale memory or CPU without changing the topology.

Common Use Cases for Self-Hosted OpenMetadata

• Warehouse discovery — one search box across Snowflake, BigQuery, Redshift and Postgres.
• Impact analysis — lineage shows every dashboard and model depending on a field before you drop it.
• Data quality monitoring — freshness, null-rate and row-count tests that alert the owning team when a table goes stale.
• PII tracking — auto-classify sensitive columns and follow the tag to where regulated data ends up.

Dependencies for OpenMetadata

• openmetadata/server:2.0.0 — API and React UI on 8585, admin port 8586.
• docker.elastic.co/elasticsearch/elasticsearch:9.3.0 — single-node search index on 9200, private.
• openmetadata/ingestion:2.0.0 — Airflow 3.3 plus the connector library, private on 8080.
• Railway managed PostgreSQL 18 — the catalog database.
• Source repository: https://github.com/gridalpha/openmetadata-railway

Environment Variables Reference

Deployment Dependencies

• Site: https://open-metadata.org — docs: https://docs.open-metadata.org
• Source: https://github.com/open-metadata/OpenMetadata
• Images: hub.docker.com/r/openmetadata/server, hub.docker.com/r/openmetadata/ingestion

Hardware Requirements for Self-Hosting OpenMetadata

Elasticsearch is the memory-hungry service; its heap is sized from the container limit, so raising its memory raises the heap too.

Self-Hosting OpenMetadata

Upstream ships Compose files for a local install. This starts the quickstart stack:

git clone https://github.com/open-metadata/OpenMetadata.git
cd OpenMetadata/docker/docker-compose-quickstart
docker compose -f docker-compose-postgres.yml up -d

The UI answers on http://localhost:8585. To run the server image against databases you already have, set the connection variables and generate your own encryption key rather than the one baked into the config file:

docker run -d -p 8585:8585 \
  -e DB_SCHEME=postgresql -e DB_HOST=postgres -e DB_PORT=5432 \
  -e DB_USER=openmetadata_user -e DB_USER_PASSWORD=change-me \
  -e OM_DATABASE=openmetadata_db -e ELASTICSEARCH_HOST=elasticsearch \
  -e FERNET_KEY="$(openssl rand -base64 32 | tr '+/' '-_')" \
  openmetadata/server:2.0.0

Two values must be unique per install and stable across restarts: FERNET_KEY, which encrypts stored connector credentials, and the RSA pair signing session tokens. The published image ships defaults for both, so a stock install shares them with every other. On Railway both are generated once onto the server's volume and reused.

How Much Does OpenMetadata Cost to Self-Host?

OpenMetadata is free and open source under Apache-2.0, with no seat limits, feature gates or licence key. Collate sells a hosted version and an enterprise build with extra governance features, but this is the complete open-source platform. On Railway you pay only for the compute, memory and storage the four services use.

FAQ

What is OpenMetadata? An open-source metadata platform and data catalog. It indexes the tables, dashboards, pipelines and ML models across your stack, records lineage between them, runs data quality tests, and gives teams a shared glossary and ownership model.

What does this Railway template deploy? Four services: the OpenMetadata server and web UI on a public domain, an Elasticsearch node, an Airflow-based ingestion agent, and managed PostgreSQL. The server is the only one reachable from the internet.

Why does OpenMetadata need both PostgreSQL and Elasticsearch? PostgreSQL is the system of record for every entity, relationship and test result. Elasticsearch holds the indexes behind Explore and lineage; they are rebuilt from PostgreSQL, so losing them costs a reindex, not data.

How do I log in to self-hosted OpenMetadata for the first time? As admin@open-metadata.org, with the password you set in OM_ADMIN_PASSWORD. The account exists before the server serves traffic, so the quickstart guide's defaults are never active.

How do I connect Snowflake, BigQuery or dbt to self-hosted OpenMetadata? Use Settings → Services, choose the connector, enter its credentials and run Test Connection. Credentials are encrypted at rest with the deployment's own key.

Can I use SSO instead of a username and password? Yes. Set AUTHENTICATION_PROVIDER to oidc and supply the OIDC_* client settings for Google, Okta, Azure AD, Auth0 or Keycloak, with the callback URL on your public domain.