Leaving Vertabelo for an Offline Modeller

What is Vertabelo used for?

Vertabelo is a web-based database modeling platform designed for collaborative database design in the browser. Redgate's acquisition of Vertabelo Data Modeler closed on 17 September 2025, and the tool was relaunched as Redgate Data Modeler on 7 October 2025. Vertabelo now points visitors to Redgate Data Modeler and continues as a standalone education business[1]. The software provides visual Entity-Relationship diagramming, physical and logical design, live model validation with instant SQL preview, reverse engineering, and automated SQL script generation[2]. Redgate states that it supports 10 database types, including SQL Server, Oracle, PostgreSQL, and MySQL[3].

Development teams primarily use the tool to design schemas without local client installations. Because the software operates entirely inside a web browser, team members share access to central models hosted on cloud infrastructure. This cloud-first architecture simplifies initial onboarding, but it also creates an ongoing dependency on continuous internet connectivity and third-party servers.

• Visual modeling: Design database schemas in a browser-based workspace, with physical design in the Standard edition and physical plus logical design in Pro[2].
• Engine support: Design for 10 database types, including SQL Server, Oracle, PostgreSQL, and MySQL[3].
• Script generation: Export create, drop, or partial change scripts directly from the model[2].
• Collaboration: Share live models across distributed team members with real-time collaboration and role-based access[2].
• Validation: Validate models live and preview the generated SQL instantly[2].

For database architects working in secure or regulated environments, this cloud dependency introduces trade-offs around data residency, offline reliability, and repository versioning.

How much does Vertabelo cost?

Redgate Data Modeler uses an annual subscription model per user seat. Pricing is split into two primary commercial tiers based on model capacity and advanced modeling features[4].

• Standard Edition: $189 per user, per year. This tier limits teams to 20 database models and 100 tables per model, covering physical design only[4].
• Pro Edition: $303 per user, per year. This tier removes table and model limits, adding logical modeling and API access[4].

Recurring software-as-a-service subscriptions accumulate substantial costs over multi-year project lifecycles. Both tiers are billed per user, per year ($189 for the Standard edition and $303 for the Pro edition), so a multi-seat architecture team pays the same seat fee again every renewal cycle without ever gaining permanent ownership of the software.

Offline desktop modelers are typically sold the other way round: a one-time perpetual licence per developer, with maintenance renewals as an optional extra once the first year of updates expires. That structure keeps the tooling usable indefinitely after purchase and gives enterprise engineering teams more predictable long-term budgeting than an annual per-seat subscription.

Why migrate to an offline database modeler?

Database architects increasingly migrate away from cloud-hosted modelers to regain control over security, privacy, and development speed. When working inside a web-based tool, your complete schema metadata - including table structures, proprietary business logic, column constraints, and foreign key topologies - resides on an external SaaS platform.

Enterprise compliance standards like GDPR, HIPAA, and SOC 2 often discourage or prohibit hosting proprietary schema designs on third-party cloud infrastructure. A local desktop IDE guarantees that schema definitions remain strictly within your corporate perimeter, with zero external metadata leakage.

• Guaranteed data privacy: Keep schema structures on local workstations without exposing enterprise architecture to external SaaS platforms.
• Uninterrupted offline access: Design and inspect complex database models on trains, flights, or air-gapped secure networks.
• Zero cloud lock-in: Store schema designs in standard, open file formats rather than proprietary database repositories.
• Native desktop rendering: Work on large schemas in a native desktop canvas instead of a browser one.

A desktop-native modeling IDE saves every project as an offline, human-readable XML model file (.dbs). You can design complex schemas using offline design mode without an active database connection, then safely validate and deploy changes whenever you choose.

Team projects: Cloud environments vs. Git

Collaborative schema design requires robust version management. Cloud-based modeling tools manage collaboration through proprietary web workspaces, forcing team members to log into a central web portal and rely on vendor-managed revision histories.

This cloud-hosted workflow isolates schema evolution from application code. When software engineers update application entities in Git, the database schema remains locked inside an external SaaS silo, creating coordination bottlenecks and deployment drift.

An offline modeler treats database models as first-class software artifacts. Because the model file is pure XML, teams commit .dbs files directly to Git alongside application code. This enables standard pull requests, branch reviews, and secure team design with Git entirely within your corporate infrastructure.

What carries over from Vertabelo

Schema migration from a web-based modeler relies on standard SQL Data Definition Language (DDL) scripts. Because relational engines adhere to standardized DDL specifications, the core structural definitions transfer into your new desktop environment.

When exporting your schema from Vertabelo or Redgate Data Modeler, generate a clean DDL SQL export targeted at your physical database engine. That script carries the relational structure of the model; the visual layer does not travel with it, as the next section sets out.

• Tables and columns: All entity definitions, column names, nullability flags, and comments transfer completely.
• Data types: Standard native data types (such as VARCHAR, INTEGER, NUMERIC, TIMESTAMP, and JSONB) map directly to target engines.
• Primary and foreign keys: Uniquely identifying keys and relational constraints remain intact.
• Unique and check constraints: Business validation rules defined at the column or table level carry over.
• Indexes and sequences: Performance indexes, composite keys, auto-increment sequences, and default values transfer via DDL.

Standardized DDL keeps the functional schema architecture intact across schema migrations.

What breaks during the migration

Visual styling and vendor-specific canvas settings do not carry over through standard DDL exports. SQL scripts define data structures, but they contain no standard syntax for canvas positions, color schemes, or user permissions.

Database architects should prepare to re-establish visual arrangements after importing raw SQL scripts into a new environment. Knowing what breaks in advance prevents unexpected surprises during project handovers.

• Coordinate layouts: Absolute X/Y positions of tables on the canvas do not exist in DDL files.
• Subject area boundaries: Proprietary visual grouping boxes and colored section panels are omitted from SQL scripts.
• Visual annotations: Sticky notes, canvas text labels, and decorative shapes do not export to standard DDL.
• SaaS permission rules: User role matrices, cloud team access lists, and web sharing links stay behind in the cloud portal.

When you import DDL into a desktop modeler, the tool automatically calculates an optimal layout for your entities. You can then quickly group tables into dedicated sub-diagrams, assign color headers, and save the layout permanently inside your local design model file.

The concrete import path to an offline modeler

Migrating your database schema into an offline modeler takes only a few minutes. Follow these practical steps to transition your models into an offline, Git-versioned workflow.

1. Export DDL script: In Vertabelo (or Redgate Data Modeler), open your model and select Export -> Generate SQL DDL script. Save the generated .sql file to your local computer.
2. Open DbSchema: Launch the application and either pick Open SQL File on the Welcome Screen, or use Model > Load From External Format.
3. Parse the schema: Point DbSchema at the exported .sql file and let it parse the CREATE TABLE statements. It extracts the tables, columns and foreign keys, displays them as a diagram, and saves the result as a local .dbs model file.
4. Organize sub-diagrams: Use the layout tools to arrange entities, create specialized sub-diagrams for functional modules, and add table comments.
5. Save and commit: Save the .dbs model file into your application's Git repository. Model > Git Collaboration is a built-in Git client, so you can clone, commit and push from inside DbSchema.

Once your model is saved, you can work completely offline, generate interactive HTML5 documentation, or connect directly to live databases to synchronize schema diffs and deploy migration scripts.

Choosing the right database design tool gives your engineering team full control over schema privacy, offline accessibility, and Git collaboration.

To start working offline with local Git versioning, download DbSchema. Offline design, saving the model to a .dbs file and Git collaboration are unlocked from the Pro edition upward.

Frequently asked questions

Is Vertabelo still available?

Vertabelo Data Modeler was acquired by Red Gate Software LTD in September 2025. It has been rebranded and is now available as Redgate Data Modeler, offering cloud-based schema design.

How much is Redgate Data Modeler?

Redgate Data Modeler (formerly Vertabelo) charges a recurring yearly subscription. The Standard edition costs $189 per user, per year, and the Pro edition is priced at $303 per user, per year.

Can I export an XML model from Vertabelo?

Yes, but the two exports are not interchangeable once you move to a desktop tool. DbSchema imports design models from CSV, Excel and SQL DDL files containing CREATE TABLE statements, so the standard DDL SQL script is the export to take with you; another vendor's own XML model format is not one of DbSchema's import formats.

Does DbSchema require an internet connection to design schemas?

No. DbSchema is a desktop application that saves your design model locally as a .dbs file in plain XML, so the model opens with no database reachable. With offline design, available in the Pro and Architect editions, you can design, edit and document your schema completely offline.

How do I migrate my ER diagram layout between modeling tools?

Visual layouts (coordinates, object colors, and specific visual groupings) generally break or do not carry over between different modeling tools. The core tables and relationships migrate via SQL DDL, but the visual arrangement must be recreated.

Download DbSchema to run the import yourself, and keep the resulting .dbs model in the same repository as the code that reads the schema.

Sources

1. vertabelo.com
2. red-gate.com
3. red-gate.com
4. red-gate.com