---
title: "Deploy OpenMetadata"
description: "OpenMetadata on Railway — catalog, column lineage, data quality tests"
category: "Analytics"
url: https://railway.com/deploy/open-metadata
---

# Deploy OpenMetadata

OpenMetadata on Railway — catalog, column lineage, data quality tests

**[Deploy OpenMetadata on Railway](https://railway.com/template/open-metadata)**

- **Creator:** A3A
- **Category:** Analytics

## Template content

### Postgres https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/postgresql.svg

- **Image:** ghcr.io/railwayapp-templates/postgres-ssl:18

### openmetadata https://raw.githubusercontent.com/open-metadata/OpenMetadata/2.0.0-release/openmetadata-ui/src/main/resources/ui/public/logo192.png

- **Source:** https://github.com/gridalpha/openmetadata-railway
- **Health check:** /healthcheck
- **Public domain:** Yes

### elasticsearch https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/elasticsearch.svg

- **Source:** https://github.com/gridalpha/openmetadata-railway
- **Health check:** /

### ingestion https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/apache-airflow.svg

- **Source:** https://github.com/gridalpha/openmetadata-railway
- **Health check:** /api/v2/monitor/health

## Documentation

![OpenMetadata logo](https://open-metadata.org/assets/header/hero-header.webp)

# 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.

![Diagram of the OpenMetadata, Elasticsearch, ingestion and Postgres services](https://res.cloudinary.com/rroe4rtk/image/upload/v1788240491/openmetadata-architecture.png)

## 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.

![OpenMetadata ingestion agents reporting 268 assets ingested](https://res.cloudinary.com/rroe4rtk/image/upload/v1788240493/openmetadata-ingestion-agents.png)
![Explore browsing catalogued Postgres tables and columns](https://res.cloudinary.com/rroe4rtk/image/upload/v1788240494/openmetadata-explore-catalog.png)
![Table page listing the columns and types of table_entity](https://res.cloudinary.com/rroe4rtk/image/upload/v1788240495/openmetadata-table-columns.png)

## 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

| Variable | Service | Purpose |
|---|---|---|
| `OM_ADMIN_EMAIL` | openmetadata | First administrator's email |
| `OM_ADMIN_PASSWORD` | openmetadata | Password applied before first start |
| `AUTHENTICATION_ENABLE_SELF_SIGNUP` | openmetadata | Leave `false` to stay invite-only |
| `AUTHENTICATION_PROVIDER` | openmetadata | `basic`, or `oidc` for SSO |
| `AIRFLOW__CORE__PARALLELISM` | ingestion | Concurrent ingestion tasks |

### 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

| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 4 vCPU total | 8 vCPU |
| RAM | 8 GB total (2 GB each for server, search, ingestion) | 16 GB |
| Storage | 5 GB per volume | 20 GB search, 10 GB ingestion |
| Runtime | Java 21, Python 3.12, PostgreSQL 14+ | as shipped |


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.


## Similar templates

- [Typesense vs Meilisearch](https://railway.com/deploy/typesense-vs-meilisearch) — self-hosted Typesense vs Meilisearch
- [Betterlytics](https://railway.com/deploy/betterlytics) — Betterlytics is a cookieless analytics platform GDPR-compliant.
- [Finance Tracker](https://railway.com/deploy/finance-tracker-1) — Private multi-user household finance ledger with budgets and CSV import.

Open this page in a browser: https://railway.com/deploy/open-metadata