The database work a DBA does, on the servers you already have.
MariaDB, PostgreSQL and MongoDB installed from their own repositories and secured on the way in — bound to localhost, no anonymous users, authorization on from the first minute. Then every screen a database needs, and the two that nobody offers: replication and sharding built from one page and proved on the wire.
One engine, the same screens
Enter an engine and the menu is the same whether it is MariaDB, PostgreSQL or MongoDB. A secondary or a standby says so before any write feature and names the primary; a config server or a shard member takes no data writes at all.
Databases
Every database as a thing: what it holds, what it weighs, who reaches it. Opened: every collection or table with its numbers, every index and whether anything has used it, what runs against it this second. New database makes one with a user of its own that sees nothing else.
Explorer
MongoDB the Compass way — a filter in mongosh's syntax, documents edited as text, a pipeline, the schema sampled, the planner asked. The SQL engines the Studio way — a statement run, rows edited in place, a row inserted from its columns, a table made from a file. Export as JSON, CSV or Excel.
Users
Each account opened: every database it may touch and at what level, locked or not, how its password is hashed, whether it must use TLS, its live connections. MongoDB by its own role names, custom roles, and where a user may connect from — the only thing between a leaked password and anyone using it.
Backups
Every dump on the box with a note saying what it is. Back up now as a job; schedules as plans on the box to any repository, encrypted to your key; put back into the same name or another; a dump uploaded from elsewhere goes back the same way.
Performance
What is slow, from the log the engine keeps anyway, grouped by the shape of the query, costliest first — and the index that would stop it, one click away. Live metrics like Monitor, a sampler the box keeps for a week, a trace that keeps sampling after you leave.
Security, firewall, settings
Everything after the firewall as verdicts with the switch on the row. The engine's port as three lists read from every member. Settings as rows in words, with what the box's RAM says they should be, written to one Lens file, restarted the checked way.
Replication from one screen
The server is the door; the set is the thing. File it once — members, addresses, roles — and every member's tab shows the same page with "you are here". Drag servers onto the members table; a box without the engine is offered the install at the set's version. Apply makes the boxes match: keyfile, bind, port, checked restarts, every wire proved from the box, then the set initiated or the member added from the primary.
- MongoDB replica sets, and MariaDB or PostgreSQL primaries with their replicas, on the same frame. A SQL replica seeds itself from the primary over the database port from its own box — no SSH key between servers.
- TLS between members is Lens's: it is the set's certificate authority, the keys never leave your computer, and the mode is walked up with no downtime. Apps are untouched.
- Step down, switchover, failover, rejoin, rolling restart and rolling upgrade — replicas first, the primary last. The Linux updates of the members walked the same safe order.
- Auto-set firewall lets every member in on every other, from what the set itself reports. Add-only: it never removes an address.
Sharding by dropping servers into boxes
A sharded MongoDB cluster is replica sets stacked, so the builder is drop boxes: config servers, shards, and the app boxes that get a mongos. Name it, Build: one job gives every set the cluster's keyfile and its role, puts a router on each app box, and adds the shards through a router. Every box is read before anything starts.
- Shard a collection on a key, with per-shard bars and the balancer's verdict. Chunk size, drain a shard, grow the cluster, upgrade it when a newer MongoDB is in the repository.
- One certificate authority for the whole cluster, every piece restarted once, a piece filed but not yet in taking the CA on its way.
- The canvas: routers on top, the config set in the middle, the shards below, no wires among routers because a mongos never talks to a mongos. Confirm connectivity proves every wire again.
- The cluster backed up as one thing: balancer paused, every shard and the config set dumped with the oplog at the same moment on a secondary of its own, a manifest beside every piece. Put back through a router, sharded again on the keys the manifest kept. Rehearse it into fresh boxes.
Connect apps, Lens Mirror, reports
Connect apps is the one page an app developer needs: the URI, whether the door speaks TLS and the CA to trust it by, and a job that lets each app server in on every door from the address it actually leaves from and prints the URI per box.
Lens Mirror copies one database of another MongoDB into a database on your box, faithfully and one way: a snapshot to start, then the source's own change stream, seconds behind, resumable. The worker runs on the box under systemd; the source only needs a read-only user.
Reports are what Lens already reads, drawn on screen — big numbers, tables, matrices — with the PDF as a button for the person who does not have Lens. A box, a set, a whole cluster: overview, users, security, firewall on every member, versions, TLS on every piece, the wires proved.
Redis and Valkey, and Sentinel
Redis is fast and famous for being left open to the internet. Lens installs it bound to the box, protected mode on, the password you give on the default user from the first minute, memory limited to a quarter of the box with allkeys-lru, users kept past restarts. Then: a keys explorer, ACL users with roles, performance, settings live and in the file, TLS beside the plain port, connect strings per driver.
A Sentinel set is built by dropping three or more servers: one primary, replicas that copy it, a sentinel beside each. When a majority agree the primary is gone, one promotes a replica and apps that speak Sentinel follow by themselves. Failover now, grow, remove, disband.
Rules the database screens never break
A primary is never restarted without a step down
A restart on a set's primary steps it down first; on a SQL primary it asks instead of refusing. A member of a set does not get Update or Restart on the map — its updates go through the set's own walk.
A shard is never backed up alone
A shard holds one slice of every sharded collection. A dump taken there is not a database, and Lens says so; the cluster is backed up through a router, as one thing.
Every wire is proved from the box it starts at
Reach is measured on the source; listen and allow are read on the destination. Your computer never claims to know whether two servers can talk.
The login Lens keeps stays on the box
The engine login is tested first, kept root-only on the server, and never on your computer. Uninstalling an engine is a ceremony: Touch ID, the warning, the phrase typed, Touch ID again — for one box, never a group.
See it done, screen by screen
A replica set in two minutes, TLS, updates with no downtime, sharding to nineteen servers, the cluster backed up to R2 and restored whole.