← Back to blog

Published on

How do you host Metabase in Brazil and pay in reais?

Deploy Metabase from Zenifra’s official template: the official image at a pinned version, on the Premium Plus plan (2 vCPU and 2 GB), with 5 GB of persistent storage at /plugins and a managed PostgreSQL as the application database instead of H2. On a monthly contract, the setup costs R$ 134.20 per month (R$ 173.76 for a 720-hour month on hourly billing, the template default), in reais with no IOF tax, against US$ 100 per month for Metabase Cloud Starter, or R$ 565.33 on a card with PTAX and IOF; this guide walks through the template and the manual setup, the production variables, connecting to managed databases, and the comparison with a VPS, using official sources read on November 6, 2026.

The short answer: Metabase with managed PostgreSQL, in reais

To host Metabase in Brazil and pay in reais, deploy Zenifra’s official Metabase template: the official image at a pinned version, on the Premium Plus plan (2 vCPU and 2 GB of RAM), with 5 GB of persistent storage and a managed PostgreSQL as the application database, which stores accounts, questions, and dashboards. On a monthly contract, the application, the volume, a db-starter database, and 1 GB of database disk add up to R$ 134.20 per month, paid by PIX, boleto, or card, with no currency exchange and no IOF tax.

Metabase Open Source is free and does not charge per user. If you host it yourself, you pay for infrastructure: the machine that runs Metabase and the database where it keeps its own state. The Metabase documentation is direct about that database: the embedded H2 is for trying things on your computer, and in production the application database should be a dedicated PostgreSQL. On Zenifra, that database is a separate project, with mandatory TLS and automatic backups included in the plan, and the template already tunes JVM memory to the plan and asks for the encryption and session keys Metabase recommends.

There are other paths, and this guide puts numbers on them. Metabase Cloud, the version hosted by Metabase itself, starts at US$ 100 per month on the Starter plan, with 5 users included, or R$ 565.33 on an international card; it has a São Paulo region and handles upgrades, backups, and email delivery. A VPS with 2 vCPU and 4 GB in São Paulo costs US$ 20 per month, or R$ 113.07, and leaves all operations to you. The sections below show when each option makes more sense.

Zenifra prices come from the public plan, database, and storage catalogs checked on November 6, 2026. Dollar prices were read on the official pages the same day and converted with the PTAX selling rate of November 5, 2026 (R$ 5.4621), plus the 3.5% IOF tax on international card purchases (Decree 6,306/2007, art. 15-B, item VII, as amended by Decree 12,499/2025). Conversions are rounded to the cent; Zenifra prices are exact, as they appear in the catalog.

What Metabase needs to run in production

Metabase works with two kinds of database, and mixing them up is the most common mistake on a first install. The application database stores Metabase’s own state: user accounts, questions, dashboards, collections, and settings. The data sources, which the documentation calls the data warehouse, are the databases you analyze. The application database is small and has to be reliable; the data sources stay where they already are, and Metabase only queries them.

Without configuration, Metabase creates a file-based H2 database. The official documentation says to avoid H2 in production for three reasons: in a container, the file disappears when the container is replaced; H2 can become corrupted over time and take every question and dashboard with it; and it cannot be shared between two Metabase instances. The recommended database is PostgreSQL, version 14 or later. MySQL 8.4.0 and MariaDB 10.6.0 also work, with the utf8mb4 character set, but Metabase emphatically recommends PostgreSQL. Metabase reads the connection from the MB_DB_TYPE, MB_DB_HOST, MB_DB_PORT, MB_DB_DBNAME, MB_DB_USER, and MB_DB_PASS variables at startup and creates its own tables; it just does not create the database itself, which on Zenifra already exists under the name app.

For machine sizing, Metabase’s production article gives a rule: the application needs at least 1 core and 1 GB of RAM, plus 1 CPU and 2 GB for every 20 people using it at the same time; with 40 concurrent people, that is 3 cores and 5 GB. For the application database, the starting point is 1 core and 2 GB, plus 1 core and 1 GB for every 40 concurrent people, and that database should not be used for anything else. Zenifra’s template starts from Premium Plus, with 2 vCPU and 2 GB, above Metabase’s minimum, and tunes the JVM heap to that size.

ItemWhat Metabase recommendsHow it maps on Zenifra (catalog as of Nov 6, 2026)
Metabase serverAt least 1 core and 1 GB, plus 1 CPU and 2 GB for every 20 concurrent peoplePremium Plus (2 vCPU, 2 GB), the template plan: R$ 119.90 per month; the next plan is Business (8 vCPU, 8 GB): R$ 479.90 per month
Application databaseDedicated PostgreSQL; starting point of 1 core and 2 GB, plus 1 core and 1 GB for every 40 concurrent peopleThe template recommends db-starter (0.3 vCPU, 256 MB) with 1 GB; db-premium (2 vCPU, 2 GB) meets Metabase’s recommendation; db-basic (1 vCPU, 1 GB) sits in between
PostgreSQL version14 or later15, 16, 17, or 18; the template uses 18
Connections to the application databasePool of up to 15 connections by default (MB_APPLICATION_DB_MAX_CONNECTION_POOL_SIZE)Plan limit: 15 on db-starter, 72 on db-basic, and 147 on db-premium
Application database backupDaily, with weekly vacuum and analyzeAutomatic and included: 1 per day kept 7 days on db-starter, 2 per day kept 7 days on db-basic, 2 per day kept 14 days on db-premium

Two points in the table drive the choice. The template’s db-starter accepts exactly the 15 connections that Metabase’s default pool can open: it covers the template’s single instance, but leaves no headroom if you raise the pool size or run more instances. And no plan below db-premium has the 2 GB Metabase suggests as a starting point: db-starter is an inexpensive starting point, below the official recommendation, and it is worth watching performance through metrics and logs before moving up a plan.

JVM memory, secret keys, and MB_SITE_URL

Besides the six MB_DB_* connection variables, Zenifra’s Metabase template declares three variables that the Metabase documentation describes for production: JAVA_TOOL_OPTIONS, MB_ENCRYPTION_SECRET_KEY, and MB_SESSION_SECRET_KEY. They all go in the Environment variables step when creating the project, or later in Edit project; saving a change restarts the instances, and each project accepts up to 50 variables.

Metabase runs on the JVM, which reserves memory differently from other applications. According to Metabase’s troubleshooting documentation, by default the JVM uses about one fourth of the machine’s RAM and does not give reserved memory back to the system; on 2 GB, one fourth would be about 512 MB of heap. The symptoms of a short heap are the message java.lang.OutOfMemoryError: Java heap space in the logs or a sawtooth memory pattern, with back-to-back garbage collections tying up the CPU.

That is why the template sets JAVA_TOOL_OPTIONS=-Xmx1600m, a 1,600 MB heap tuned to Premium Plus’s 2 GB. It is about 80% of the plan’s memory, the same logic Metabase used in the load test published in its production article, with JAVA_TOOL_OPTIONS and -Xmx at 80% of RAM to leave room for non-heap memory. If you change plans, adjust -Xmx along with it, keeping that margin. If the heap error still shows up, the machine is short on RAM, and the next step is a plan with more memory, not an -Xmx above the plan’s RAM.

MB_ENCRYPTION_SECRET_KEY makes Metabase encrypt, with AES256 and SHA512, the data source connection details it stores in the application database; the key must be at least 16 characters, the documentation suggests generating it with openssl rand -base64 32, and losing or changing the key means re-entering the connections. MB_SESSION_SECRET_KEY makes Metabase store sessions signed with that secret, so that a valid session cannot be created with database access alone; it also requires at least 16 characters, and setting or changing the value logs out every active session.

bash
# Template variables
MB_DB_TYPE=postgres
MB_DB_HOST=<postgresql-host>
MB_DB_PORT=<postgresql-port>
MB_DB_DBNAME=app
MB_DB_USER=app
MB_DB_PASS=<postgresql-password>
JAVA_TOOL_OPTIONS=-Xmx1600m
MB_ENCRYPTION_SECRET_KEY=<output of openssl rand -base64 32>
MB_SESSION_SECRET_KEY=<another output of openssl rand -base64 32>

# Optional, from the Metabase docs
MB_SITE_URL=https://<project-address>
JAVA_TIMEZONE=America/Sao_Paulo
MB_ANON_TRACKING_ENABLED=false

Outside the template, the Metabase documentation describes three more useful variables. MB_SITE_URL is the address people use to reach Metabase, including https://; it shows up in email links, login redirects, and embedding, and if left empty, Metabase learns the value from the first admin who signs in, but it is worth setting when you use your own domain. JAVA_TIMEZONE sets the time zone for reports, and MB_ANON_TRACKING_ENABLED=false turns off anonymous usage data collection, which is on by default.

The port needs no variable: Metabase listens on 3000 by default (MB_JETTY_PORT), the same as the template. The project’s exact address, in the *.clients.zenifra.com format, appears on the project page after creation. Keep both keys outside the project as well: anyone with the project.env.read permission can read variable values in plain text, and without the encryption key, saved connections cannot be read.

Step by step with the Metabase template

The shortest path is the official template. Metabase is in Zenifra’s public Templates catalog with the Official Template badge and the flag that it requires a database (requires_database: true in the public catalog API). In its current configuration, the application uses the docker.io/metabase/metabase:v0.63.17.2 image, port 3000, the Premium Plus plan with hourly billing and 1 instance, and 5 GB of persistent storage at the /plugins directory; the recommended database is PostgreSQL 18 on the db-starter plan, with 1 instance and 1 GB. The project you create is independent: later changes to the template do not change it.

/plugins is the directory where Metabase, on Docker, keeps database drivers: it extracts the drivers bundled with the distribution there and loads any third-party drivers you add, so the folder must be writable. With the persistent volume, whatever is in it survives restarts. Metabase’s own Cloud page lists community or custom drivers as one of the cases where self-hosting is the better path.

There are two buttons, and the difference matters for Metabase. Deploy creates only the application, with the author’s recommendations, after a confirmation that shows an automatic name and a summary of plan, billing, access, and instances. Customize opens project creation with everything filled in and offers Create a database with the project, which creates the PostgreSQL and the application in one operation and fills in the connection variables the author linked to the database. Without an external database, Metabase writes its settings to an H2 file that, in the container, lives at /metabase.db, outside the persistent volume, and is lost on restart; for real use, choose Customize.

  • 1. In the Console menu, open Templates and, under Public templates, use Official or Most used to find Metabase.
  • 2. Open the card and review the author, revision, application, port, persistence, variables, and defaults.
  • 3. Click Customize.
  • 4. Review the name, plan, and billing mode. The template comes with Premium Plus and hourly billing; for continuous use, compare it with monthly in the cost section below.
  • 5. Check the storage: 5 GB of persistent storage at /plugins. The directory is fixed by the template; the capacity can be adjusted.
  • 6. Select Create a database with the project. PostgreSQL 18 on db-starter with 1 instance and 1 GB comes preselected, and you can switch to another compatible option from the catalog, such as db-basic or db-premium.
  • 7. Fill in MB_ENCRYPTION_SECRET_KEY and MB_SESSION_SECRET_KEY with random values of at least 16 characters, for example generated with openssl rand -base64 32; according to the templates documentation, secrets never come with a default value. Variables linked to the database appear filled in, read-only, with sensitive values masked.
  • 8. Review the summary of both resources and the cost, then click Create project.

Creating the database together requires the database.create permission in addition to project.create; without it, the option is unavailable. If any step fails, Zenifra rolls back everything it created in that operation. After creation, the application and the database are separate projects: deleting one does not delete the other, and changing the database password means updating the Metabase variable by hand.

When customizing, the form accepts exactly the variables the template declares. The optional variables from the previous section, such as MB_SITE_URL and JAVA_TIMEZONE, can be added later in Edit project, keeping in mind that saving restarts the instances. Because the encryption and session keys go in at creation, connections saved from the very first data source are encrypted, which is the simple case described in the Metabase documentation.

Step by step by hand with the official image

To set everything up by hand, or to understand what the template does, use the same values it does. Create the PostgreSQL first, because Metabase needs the connection details on its very first start. In the Console sidebar, click Create project, choose PostgreSQL Database, pick the db-starter plan and the payment model, enter a name of 6 to 32 characters, and choose version 18 (the default), 1 instance, and 1 GB of storage, as in the template. You do not choose a user or database name: both are app, and the password appears only once, on the final creation screen. Copy the host, port, and password before leaving that screen.

Then create the application. In the Console, click + Create Project, choose HTTP, and fill in the fields with the template configuration:

bash
MB_DB_TYPE=postgres
MB_DB_HOST=<postgresql-host>
MB_DB_PORT=<postgresql-port>
MB_DB_DBNAME=app
MB_DB_USER=app
MB_DB_PASS=<postgresql-password>
JAVA_TOOL_OPTIONS=-Xmx1600m
MB_ENCRYPTION_SECRET_KEY=<output of openssl rand -base64 32>
MB_SESSION_SECRET_KEY=<another output of openssl rand -base64 32>
FieldTemplate value
Project sourceOCI Image
Imagedocker.io/metabase/metabase:v0.63.17.2
RegistryPublic, no authentication
PlanPremium Plus (2 vCPU and 2 GB of RAM)
Billing modeHourly in the template; monthly or yearly for continuous use
Port3000
Instances1
Persistent storageYes: 5 GB at the /plugins directory

In the Configure storage step, choose Yes for Persistent storage, set 5 GB, and enter /plugins as the directory to persist; that directory cannot be changed after creation. In the Environment variables step, add the variables above with the details copied from the database and two different random keys. The project name, 6 to 32 characters with lowercase letters, numbers, and hyphens, also defines the *.clients.zenifra.com address. Review the estimated cost and click Create Project. Metabase may take a few minutes to start the first time: follow the project logs until the interface responds, create the admin account in the setup wizard, and connect your first data source. If the application does not respond, check the logs, the configured port, and the troubleshooting guide.

About the version: Zenifra pins a tested Metabase version in the template, currently v0.63.17.2, and pinning the tag is the right call, because Zenifra’s documentation advises against latest in production. Metabase ships new versions often, so read the release notes before switching. To switch, update the image in the Console or run zenifra project image set --project <id> --image docker.io/metabase/metabase:<tag>, always with a backup of the application database taken first, as Metabase asks.

What it costs per month on Zenifra, line by line

The template bill has four parts: the application plan, the persistent storage at /plugins, the PostgreSQL plan, and the database disk. The HTTP plan sets Metabase’s CPU and memory, and the database plan sets those of each PostgreSQL instance. The application volume costs R$ 0.44 per GB per month, billed on its full capacity, and the PostgreSQL disk costs R$ 0.20 per GB per month on each instance (44 and 20 cents in the storage catalog, the same products the public calculator uses). On hourly billing, both are billed in proportion to time, at the monthly price divided by 720, and they keep being billed while the project is stopped.

The application database starts at 1 GB, the template recommendation. It stores accounts, questions, dashboards, metadata, and, if you enable it, cached results, and it grows with use. The Console shows the database disk usage with alerts at 80% and 95%. On hourly billing, the database disk and the /plugins volume can grow later but never shrink; on monthly and yearly billing, they stay fixed for the contract. The table uses a 30-day month (720 hours) for the hourly column.

  • Template with db-basic (1 vCPU, 1 GB) instead of db-starter, same volume and 1 GB of disk: R$ 172.20 monthly, R$ 1,893.60 yearly, and R$ 215.52 for a 720-hour month on hourly billing.
  • Template with db-premium (2 vCPU, 2 GB), which meets Metabase’s recommendation for the application database: R$ 252.20 monthly, R$ 2,773.60 yearly, and R$ 290.40 for a 720-hour month on hourly billing.
  • Business (8 vCPU, 8 GB) instead of Premium Plus, with db-premium: R$ 612.20 monthly, R$ 6,721.60 yearly, and R$ 751.20 for a 720-hour month on hourly billing.
Template itemHourly720-hour month on hourly billingMonthly contractYearly contract
Premium Plus application (2 vCPU, 2 GB), 1 instanceR$ 0.22R$ 158.40R$ 119.90R$ 1,315.90
5 GB of persistent storage at /plugins5 × R$ 0.44 ÷ 720R$ 2.20R$ 2.20R$ 26.40
PostgreSQL 18 db-starter (0.3 vCPU, 256 MB), 1 instanceR$ 0.018R$ 12.96R$ 11.90R$ 130.90
Database disk, 1 GB1 × R$ 0.20 ÷ 720R$ 0.20R$ 0.20R$ 2.40
Template totalR$ 0.238 per running hour, plus storageR$ 173.76R$ 134.20R$ 1,475.60

To try it before committing, hourly billing, the template default, is the cheapest. Three days in a row (72 hours) with the template configuration cost R$ 17.376: R$ 15.84 for the application, R$ 1.296 for db-starter, R$ 0.22 for the volume, and R$ 0.02 for the database disk. At the end of the cycle, running hours are added up and rounded up to the full hour, and a stopped project is not charged for compute, only for storage.

For continuous use, monthly pays off. Metabase needs to stay on: its documentation advises against services that shut servers down when nobody is using them, because syncs, scans, and scheduled sends stop, and the first visit after a pause suffers from the startup time. Running 720 hours, the template on hourly billing adds up to R$ 173.76; on a monthly contract, R$ 134.20. The application alone breaks even at 545 hours in the month (R$ 119.90 ÷ R$ 0.22). On monthly and yearly billing, plan, instances, and storage are fixed for the contract, so if you do not know the right size yet, measure on hourly billing before signing a contract.

How to connect Metabase to a Zenifra managed database

Once Metabase is up, data sources go in Admin > Databases > Add a database, where you choose PostgreSQL and fill in the form. For a Zenifra PostgreSQL, the details are on the database’s connection card in the Console: the host in the postgresql-<project-id>.managed.zenifra.com format, the port set by the platform (copy it from the Console instead of assuming it), the app database, the app user, and the password shown at creation or after the last rotation. Always use the host from the Console: the certificate is issued for that name, and connections by IP address fail validation.

Zenifra requires TLS on database connections by default, and the Console URI uses sslmode=require. In the Metabase form, keep Use a secure connection (SSL) on; according to the Metabase documentation, it tries SSL first and, if that works, makes the secure connection the default. The SSL Mode field accepts allow, prefer, require, verify-ca, and verify-full, and the same documentation notes that verify-ca and verify-full require the root certificate in PEM, by local path or by file upload.

  • Display name: the name of the source inside Metabase.
  • Host: postgresql-<project-id>.managed.zenifra.com, or <project>.<organization-id>.zenifra.local over a private connection.
  • Port: the port shown in the Console, or 5432 over a private connection.
  • Database name and Username: app.
  • Password: the database password.
  • Use a secure connection (SSL): on; SSL Mode require, as in the Console URI, or verify-full with the root certificate in PEM if you want to validate the certificate.

When Metabase also runs on Zenifra, there is a documented path that skips the internet. A private connection links the Metabase application to a database in the same organization: in the Console’s connection map, drag from Metabase to the database, confirm, and wait for the Active status (the source application may restart). Metabase then reaches the database at <project>.<organization-id>.zenifra.local, on port 5432. Over that address the connection is encrypted, but the certificate belongs to the public name, so the documentation says to use TLS without hostname verification, which in Metabase is the require SSL Mode. With every source connected this way, you can turn off the database’s Public access card, and it stops accepting connections from the internet.

Zenifra’s example guide recommends connecting Metabase to your data with a read-only user. On a Zenifra PostgreSQL with 2 to 6 instances, the Console shows a read-only URI that routes queries to the replicas; over a private connection, the read address is ro.<project>.<organization-id>.zenifra.local. That way, reports do not compete with your application for the primary instance. In Metabase, keep features that write to the database turned off, such as Data actions and Editable table data, which require write permissions.

Watch the pool as well. Metabase opens up to 15 connections per data source (MB_JDBC_DATA_WAREHOUSE_MAX_CONNECTION_POOL_SIZE), and the db-starter plan accepts 15 connections in total. If your application uses the same database Metabase queries, lower that variable or use a plan with more connections; past the limit, PostgreSQL refuses the new connection with remaining connection slots are reserved.

Metabase Cloud or Metabase on Zenifra: which costs less?

For a small team, Metabase Open Source on Zenifra costs less: R$ 134.20 per month with the template configuration, or R$ 252.20 with the database on db-premium, against R$ 565.33 for Metabase Cloud Starter (US$ 100 per month, on a card with PTAX and IOF), and the Zenifra cost does not change with the number of users. Metabase Cloud pays off when you would rather have Metabase handle upgrades, backups, and email, or when you need paid features such as SSO and row and column permissions.

The prices in the table come from Metabase’s official business intelligence pricing page, read on November 6, 2026. Starter exists only in the cloud and includes 5 users; Pro, in the cloud or self-hosted, includes 10. For Metabase, a user is anyone who signs in to the instance, directly or through SSO, and the page notes that prices exclude applicable taxes. The conversion accounts only for the PTAX rate of November 5, 2026, and the 3.5% IOF tax on card purchases.

Metabase planOfficial priceUsers includedAdditional userIn reais, with PTAX and IOF
Open Source (self-hosted)FreeUnlimitedNot applicableR$ 0.00 in licenses; you pay for infrastructure
Starter (cloud), monthlyUS$ 100 per month5US$ 6 per monthR$ 565.33 per month; each extra user, R$ 33.92
Starter (cloud), yearlyUS$ 1,080 per year5US$ 65 per yearR$ 6,105.54 per year
Pro (cloud or self-hosted), monthlyUS$ 575 per month10US$ 12 per monthR$ 3,250.63 per month; each extra user, R$ 67.84
Pro, yearlyUS$ 6,210 per year10US$ 130 per yearR$ 35,106.83 per year
EnterpriseFrom US$ 20,000 per yearCustom pricingCustom pricingFrom R$ 113,065.47 per year

With more people, the gap widens. With 10 users, Starter monthly goes to US$ 130, or R$ 734.93; with 20 users, to US$ 190, or R$ 1,074.12. On a yearly contract, the Zenifra template costs R$ 1,475.60, against R$ 6,105.54 for yearly Starter with 5 users. On Zenifra, what sets the plan is how many people use Metabase at the same time, not how many accounts exist, so a larger team that opens Metabase at different times can stay in the same scenario.

What Cloud delivers that you would otherwise do yourself: automatic upgrades to the current version, backups, a preconfigured email server for alerts and dashboard subscriptions, a choice of region (the Cloud page lists North Virginia, Frankfurt, São Paulo, Singapore, and Sydney), and, on Starter, support by email, support form, Slack, or Teams. There is a 14-day free trial. If your team has nobody to look after versions and backups, or if you need SSO, usage auditing, and row and column permissions, Cloud can be the right choice even at a higher price. Those paid features also exist on self-hosted Pro, for the same US$ 575 per month in licenses, on top of the infrastructure cost.

Is a VPS cheaper for running Metabase?

On server price alone, yes: a VPS with 2 vCPU and 4 GB in São Paulo costs US$ 20 per month on Vultr, or R$ 113.07 on a card with PTAX and IOF, less than the R$ 134.20 of the Zenifra template, and it fits Metabase and PostgreSQL on the same machine. In exchange, installation, HTTPS, the database, backups, upgrades, and monitoring become your job.

Prices come from Vultr’s official public plans and regions API, read on November 6, 2026, which lists São Paulo among its regions and the two plans below as available there. The table puts side by side what each option delivers for Metabase, not just the price, because what really changes between them is who does the operations work.

OptionResourcesPriceIn reaisWhat stays with you
Vultr Cloud Compute VPS, São Paulo2 vCPU, 4 GB, 80 GB disk, 3,072 GB of transferUS$ 20 per monthR$ 113.07 with PTAX and IOFOperating system, Docker, PostgreSQL, HTTPS, backups, upgrades, monitoring, and email
Vultr Cloud Compute VPS, São Paulo4 vCPU, 8 GB, 160 GB disk, 4,096 GB of transferUS$ 40 per monthR$ 226.13 with PTAX and IOFThe same
Zenifra, template: Premium Plus + 5 GB at /plugins + db-starter with 1 GB2 vCPU and 2 GB for Metabase; 0.3 vCPU and 256 MB for the databaseR$ 134.20 per monthAlready in reais, no IOFMetabase version, data source connections, and email (SMTP)
Zenifra, template with db-premium2 vCPU and 2 GB for Metabase; 2 vCPU and 2 GB for the databaseR$ 252.20 per monthAlready in reais, no IOFThe same

The difference in resources needs to be clear. On the 4 GB VPS, Metabase and PostgreSQL share the same memory, and the Metabase documentation recommends the opposite: separate instances for the application and the application database, ideally on the same network. By the official rule of 2 GB for the database and 1 GB plus 2 GB for every 20 concurrent people for Metabase, 4 GB is tight for both; the 8 GB VPS has room and costs R$ 226.13. If you know how to run Linux and have the time, a VPS gives you more RAM per real, and that is the honest answer.

The VPS price does not include the work a managed platform or Metabase Cloud does: HTTPS with renewed certificates, a daily backup of the application database stored off the machine, weekly vacuum and analyze (a Metabase recommendation), operating system and Metabase upgrades, and an alert when something goes down. The VPS or managed platform guide on this blog works out maintenance hours with explicit assumptions; apply the same reasoning to Metabase before deciding.

Where does the data live when Metabase runs on Zenifra?

On Zenifra, the Metabase application, the /plugins volume, and the PostgreSQL application database run on infrastructure in Brazil (in São Paulo, according to Zenifra’s FAQ), and the database’s automatic backups are also kept on Zenifra infrastructure in Brazil. That covers everything Metabase writes to its own database: accounts, questions, dashboards, data source connection details, and, when caching is on, query results.

Caching deserves attention in the comparison with Cloud. Metabase’s caching documentation says that, on a self-hosted install, cached results are stored in the application database; on Metabase Cloud, they are stored on Metabase’s servers in the United States, because Cloud manages that database. The Cloud page offers a São Paulo region for the instance, so if data location is a contract or internal policy requirement, confirm with Metabase where each kind of data lives before signing up. It is also worth knowing that Metabase caches column values for filters, from the first 1,000 distinct rows of each table: real fragments of your data are stored by Metabase, not only read at query time.

Some flows depend on configuration and may leave the country, whatever the hosting: anonymous usage data sent to Metabase (MB_ANON_TRACKING_ENABLED, on by default), the email server you choose for alerts and subscriptions, and the AI provider, if you use Metabase’s AI features with a provider key. Review each one against your policy. Data sources stay where they are: Metabase queries them.

Where data lives is a technical fact, not a compliance seal. Zenifra’s security documentation makes clear that the published application remains responsible for defining the legal basis, minimization, retention, and deletion of the data it collects. For Metabase, that means deciding who sees what with data permissions, not bringing more personal data into dashboards than needed, and restricting access to the instance, for example with the Premium Plus IP allowlist.

Day-to-day operations: healthcheck, upgrades, access, and metrics

Premium Plus includes a healthcheck: Zenifra calls a GET route every minute and restarts the instance once a failure is confirmed. For Metabase, use /livez. Its documentation explains that /api/health also checks the application database and that, used as the only check, it can make Metabase restart endlessly when the database is unavailable; /livez only confirms that Metabase responds. Turn it on in Edit, in the Application healthcheck section (Enable healthcheck and Check path), after the first startup has finished.

Upgrades call for care with the application database. Between minor versions, Metabase usually does not change the schema; on a major version, it runs migrations at startup, with some downtime, and the documentation asks that the platform not kill the process midway, at the risk of corrupting the database. It also asks for a single instance during a major upgrade, which is the template default. Before changing the tag, take a pg_dump of the application database, turn off the healthcheck, change the image, follow the logs until the migrations finish, and only then turn the healthcheck back on. The automatic backup still applies, but restores are done by support, so the pg_dump is your fastest way back.

For internal BI, restrict access. From Premium Plus up, public projects accept IPv4 allowlists and blocklists in CIDR, with up to 10 entries in each list, and changing the lists does not restart the instances. To use your own domain, such as bi.yourcompany.com.br, add it in Edit, in the Custom domains section, create the DNS records shown, and set MB_SITE_URL to the new address. Also set up an SMTP server in Admin > Settings > Email: without one, a self-hosted install sends no password resets, invitations, alerts, or dashboard subscriptions.

Watch the project metrics, included from Premium up. Metabase suggests alarms when the application goes above 80% to 90% CPU and 80% RAM, and when the application database goes above 90% CPU, 80% RAM, and 80% disk. Zenifra’s database metrics (CPU, memory, connections, read cache, locks, and latency) are on db-premium and db-enterprise; on other plans, including the template’s db-starter, the Console shows storage usage, with warnings from 80% and 95%. In the Metabase logs, the App DB connections: 12/15 line shows how much of the pool is in use.

How much does it cost to try Metabase on Zenifra before committing?

On hourly billing, the template default, 72 hours in a row cost R$ 17.376: R$ 15.84 for Premium Plus, R$ 1.296 for db-starter, R$ 0.22 for the 5 GB volume, and R$ 0.02 for the database disk. The template uses Premium Plus because Metabase needs its 2 GB of RAM, with the JVM heap tuned to that size.

For the test, create db-starter, deploy Metabase on hourly Premium Plus pointing to it, and stop the application when you are done: a stopped project is not charged for compute, but the persistent volume keeps being billed until you delete the project. Sign-up asks for a CPF or CNPJ, a mobile number, and an address in Brazil.

How do you move a Metabase that uses H2 today to Zenifra?

Use Metabase’s own load-from-h2 command to copy the H2 file into an empty PostgreSQL, with the same Metabase version from start to finish, then bring up the project on Zenifra with the MB_DB_* variables pointing to that database. A newly created Zenifra PostgreSQL works as the target: the app database starts empty, and public access, on by default, lets you run the migration from your own computer.

The Metabase documentation lays out the order: confirm you can connect to the target database, stop the current Metabase, back up the H2 file (on Docker, docker cp CONTAINER_ID:/metabase.db ./), download the JAR for the same version that produced the file, and run the migration. Metabase creates the schema, copies the data, and exits. Only after confirming that everything arrived is it time to think about upgrading: migrating and upgrading at the same time is exactly what the documentation says to avoid.

bash
export MB_DB_TYPE=postgres
export MB_DB_CONNECTION_URI="jdbc:postgresql://<host>:<port>/app"
export MB_DB_USER=app
export MB_DB_PASS=<password>
java --add-opens java.base/java.nio=ALL-UNNAMED -jar metabase.jar load-from-h2 /path/to/metabase.db

The path ends in metabase.db, without the .mv.db extension. Passing the user and password in MB_DB_USER and MB_DB_PASS, separate from the URI, is what the documentation suggests when the password has special characters. The connection to the Zenifra PostgreSQL requires TLS; to validate the certificate in the JDBC URI, the Metabase documentation shows the sslmode and sslrootcert parameters.

On Zenifra, the project has to run the same version you migrated. If it differs from the one the template pins, create the project through the manual path with the tag of the migrated version and upgrade later, with a backup. If the old Metabase already used MB_ENCRYPTION_SECRET_KEY, use the same key in the new project, because without it saved connections cannot be read; if it did not, follow the Metabase documentation section on encrypting an existing install.

How many people can Metabase on Premium Plus serve?

By Metabase’s rule of a 1 core and 1 GB baseline plus 1 CPU and 2 GB for every 20 people using it at the same time, Premium Plus’s 2 GB falls short of the 3 GB suggested for 20 concurrent people. Proportionally, which is our own arithmetic and not an official figure, 2 GB corresponds to about 10 people using Metabase at the same time, with the application database sized separately.

Concurrent is not the same as registered: a team of 30 people who open dashboards at different times has far fewer simultaneous sessions. To grow, there are two paths. The vertical one is Business, with 8 vCPU and 8 GB, at R$ 479.90 per month, adjusting the -Xmx in JAVA_TOOL_OPTIONS along with it. The horizontal one, which Metabase recommends for many users, is running more than one instance: the template starts with 1, and each extra instance opens its own pool of up to 15 connections to the application database, so the database has to handle the sum (db-starter accepts 15 and db-basic 72). On monthly and yearly billing, the instance count is fixed for the contract, and during a major upgrade Metabase asks for a single instance.

Price Premium Plus with DB-Starter in the calculator

We respect your privacy

We use essential cookies to run this site. Measurement and marketing cookies, such as Google Ads, are only enabled when you accept all cookies. Read our cookie policy.