Database documentation can be a deliverable or a reference that changes with the database. A document generator gives a project team a snapshot of tables, routines and relationships for a handoff. A modeling tool can add diagrams and notes from its schema project. A catalog is more useful when definitions and ownership need to remain accessible through several releases.

SQL Doc and dbForge Documenter are geared toward a generated reference. DbSchema, dbdocs and the command-line tools fit workflows where a project or build produces the documentation. Dataedo, OpenMetadata and Atlan keep metadata in a catalog. Purview Data Map is a consideration for existing users planning their transition. The decision depends on who owns the descriptions, how readers reach them, and how a schema change makes its way into the next version.

SQL Server documentation tools at a glance

Start with the output and ownership model. The refresh test shows what to verify with a changed column description and a new view before committing to a tool.

SQL Server documentation output, source and refresh checks
ToolBest useWhat it publishesWhat to check on refresh
Redgate SQL DocSQL Server release handoffGenerated documentation from a selected projectChanged extended property, new view, and exported format
dbForge DocumenterDeliverable for a specific database releaseHTML, PDF or Markdown reportObject filters and description appear in the regenerated report
DataedoCurated descriptions and relational documentationRepository catalog, with publish and writeback optionsFirst import from SQL Server, then survival of a curated value
DbSchemaDiagram-oriented technical handoffModel-based HTML5, PDF or Markdown documentationRefresh live metadata and verify diagrams, model notes and paths
SchemaSpyStatic browser reference from a repeatable runHTML schema pages with relationship diagramsConfirm JDBC scope, descriptive values and inferred links
SchemaCrawlerReviewable snapshots and before-and-after reportsCommand-line schema output or diff reportKeep flags stable and distinguish real changes from scope changes
dbdocsVersion-controlled diagrams and descriptionsHosted documentation from DBMLReview SQL import changes against hand-maintained model notes
Microsoft PurviewSQL Server discovery in an existing Microsoft catalogData Map assets from registered scansScan identity, runtime, scope and version-specific catalog policy
OpenMetadataShared catalog with a self-managed optionMSSQL connector assets and configured metadata tasksCheck view discovery, account permissions, and refresh behavior
AtlanShared asset discovery and ownershipSQL Server objects from scheduled crawlsMatch asset types to connector coverage and verify manual context

Redgate SQL Doc

Redgate SQL Doc reads SQL Server object definitions and produces database documentation from a configurable project. A developer can include the tables, views and routines relevant to an application and reuse descriptions already stored in the database. This makes it a practical way to deliver a reference with a release.

It is strongest when the recipient needs a generated document and the team has a defined database version to generate it from. A document describes the state visible to the account at the time it was made. An object added later, or hidden from the documentation login, will require another generation or a scope change.

Store the SQL Doc project that defines the included databases and objects alongside the release pipeline when that fits the team. Its command-line interface accepts an existing project. Run it after a schema deployment and attach the output to the release identifier so readers can find the applicable snapshot.

Use the same scoped SQL Server login on the first and second generation. Check the changed column description on the table page and whether the report picked up the new view. Capture the scope in the output so anyone comparing snapshots can explain a missing schema.

Redgate SQL Doc product overview and example output
Redgate’s product overview shows the documentation workflow and available output formats. Documentation screenshot
Compatibility
Redgate documents supported SQL Server objects, project options and publishing formats.
License and trial
Commercial. SQL Doc entitlement depends on the product license or bundle.

Devart dbForge Documenter for SQL Server

Devart dbForge Documenter generates database documentation for SQL Server from selected schema objects. Its report settings let a team choose which object types and descriptions go into the output. A scoped report can give the next engineer the columns, keys and routine definitions involved in a handoff.

It fits a deliverable with a known audience and database version. The format and categories matter because a useful application handoff may need only a subset of a large database. A rerun from a different deployment should be tied to that deployment so readers can tell which schema the report describes.

Devart documents HTML, PDF and Markdown output. Pick a format a reader can open after delivery and include only the objects relevant to the handoff. A small Markdown export can be compared in review, while a PDF can be distributed as a dated release artifact.

Generate two reports with identical object selection and format. Add a view to the source after the first run and check whether the selection updates or whether that view must be added explicitly. Open the output links from an account without access to the Documenter workstation.

Devart dbForge Documenter for SQL Server product overview
Devart’s overview describes file generation and database documentation scope. Documentation screenshot
Compatibility
Devart documents SQL Server object coverage and report options. Available output formats depend on the tool release.
License and trial
Commercial. Standalone and bundle entitlements depend on the selected edition.

Dataedo

Dataedo imports SQL Server metadata into a catalog that can also hold business descriptions. It can read source descriptions stored in extended properties for applicable objects. Adding a definition to a field gives readers context that a schema listing alone cannot provide.

It is most useful when a team expects descriptions to be maintained after the initial import. A reimport affects how source updates and catalog edits meet. If descriptions are also written back to SQL Server, deciding which system owns them helps avoid one copy replacing useful edits made in the other.

Use the first import to capture a column's SQL Server description. Dataedo documents that an existing nonblank repository description takes precedence on subsequent imports. To test that behavior, edit the description in the catalog, change the source property separately, and see which value each reader sees.

Export is a separate workflow with separate database permissions. If the team wants to write curated descriptions back to SQL Server, document who approves the change and which tables the mapping covers. Run ingestion with its ordinary account and test writeback under a dedicated role only where needed.

Dataedo sample HTML data dictionary
Dataedo publishes a generated HTML data dictionary example. Documentation screenshot
Compatibility
Dataedo documents SQL Server metadata import, descriptions and additional connector capabilities.
License and trial
Commercial. Connectors, catalog modules and users affect the license.

DbSchema

DbSchema can reverse-engineer selected SQL Server objects into a model and generate schema documentation from that model. The project can include diagrams and notes alongside definitions. This suits a technical handoff where the relationships are easier to explain visually than through an object list alone.

The reason to choose it is that the project can carry diagram context across generations. The documentation describes the model, which may be newer or older than the deployed database. How the project refreshes after a change therefore matters when readers use the result to understand a live schema.

DbSchema generates documentation from a diagram and model. The Markdown option includes the diagram as a separate image, so move the image with the exported Markdown when publishing it. Compare the handoff as a reader and confirm it includes both the diagram and the column descriptions.

After a schema refresh, verify a changed object that appears on more than one diagram. Keep the project notes you want to persist under review, and verify how the model handles an object missing from the connected database. The project should identify the database and schema version it represents.

DbSchema documentation generation dialog
DbSchema’s generation dialog shows the documentation format and selected output settings. Publisher example
Compatibility
DbSchema documents SQL Server JDBC connectivity and project-based schema documentation. Export options depend on edition.
License and trial
Commercial options vary by edition and documentation format.

SchemaSpy

SchemaSpy connects to a database and builds browsable static schema documentation. For SQL Server, the reader gets a map of discovered tables and relationships that can be hosted without a separate catalog application. This is useful for publishing a reference from a scheduled job.

It suits a team that wants a reproducible snapshot and can own the runtime and static hosting. A missing object can reflect login scope, and a relationship diagram can include links inferred from metadata. Readers need enough context to tell what the database explicitly enforces.

Keep the JDBC driver version, database type and schema selection in the documentation job's configuration. Run the job under the same metadata permissions as the protected production route. It should publish the expected table, field and relationship pages without depending on the operator's SQL Server account.

Open the rendered HTML as a reader and compare any implied relationship with an explicit foreign key. Generate the fixture again after changing a description and compare the rendered text. Decide where operational notes live so they stay linked after the next static site generation.

SchemaSpy generated table documentation for a PostgreSQL example
SchemaSpy demonstrates its generated table report with a PostgreSQL sample. Verify the same output from your SQL Server connection. Documentation screenshot
Compatibility
SchemaSpy documents JDBC setup and database type configuration. SQL Server driver and metadata permissions determine the accessible scope.
License and trial
Open source. Runtime, graph rendering and documentation hosting are owned by the team.

SchemaCrawler

SchemaCrawler uses database metadata to generate reports from a command-line workflow. Its SQL Server configuration can target a particular database and schema. The same settings can be used to produce reports before and after a change, so differences in the output are easier to attribute to the actual database.

It fits engineering teams that prefer reviewable configuration and repeatable runs over a desktop project. A report only reflects the schemas and objects available through the chosen connection. Stable output options matter when the report is also used to spot changes.

SchemaCrawler's changes report workflow can pair a previous schema snapshot with a current one. Stabilize catalog, schema and table selection before relying on differences for review. Changing the account or discovery depth between two reports can look like a large deployment even if nothing meaningful changed.

Use the output intended for review and identify the actual changes you expect in it. For documentation, check the new view and comments as well as keys and constraints. For deployment safety, send resulting differences through the same approval process as any generated change script.

SchemaCrawler schema documentation output options
SchemaCrawler documents its output types and how they serve schema reviews. Documentation screenshot
Compatibility
SchemaCrawler documents SQL Server support through JDBC and schema scope settings.
License and trial
Open source. The team owns configuration, scheduling and distribution.

dbdocs with DBML

dbdocs publishes database documentation from DBML. A team can keep the model and its notes in version control, then publish a browsable reference after review. The DBML CLI also documents an import path for Microsoft SQL Server.

This works well when the published reference should follow a curated model rather than a particular live database connection. Import coverage determines which SQL Server-specific constructs appear in DBML. A regenerated model can also overwrite local additions if the project has not decided how to combine the imported schema with hand-written context.

The DBML tooling supports converting SQL Server DDL or starting from a SQL Server connection. Keep imported DBML and reviewer-authored notes in a controlled workflow. Review the diff rather than silently overwriting a model that contains business context and custom relationships.

Take a table with a SQL Server-specific feature and inspect what the DBML import represents. Give readers a link to the real DDL where details live outside the model. Publish after validating the generated view against the reviewed source version and check who can access it.

dbdocs example published data dictionary for a table
The dbdocs product example shows a published table reference with column descriptions. Publisher example
Compatibility
DBML documents SQL Server import and CLI generation. Model coverage depends on the supported constructs.
License and trial
The dbdocs plan determines access and sharing options. Generation also uses the DBML tooling.

Microsoft Purview Data Map

Microsoft Purview Data Map can scan on-premises SQL Server sources to collect metadata into an existing governance environment. Readers can use the catalog to discover objects without browsing each server directly. It matters most when teams already rely on the registered sources and scan results.

The product decision now includes Microsoft’s move to Fabric. Microsoft says existing classic governance capabilities remain in maintenance mode through November 12, 2027. For an existing installation, the scan configuration, reader access and metadata used downstream are part of the eventual transition work.

Use the on-premises scanner setup documentation to identify where connectivity, credentials and the integration runtime must be available. Register one source with a deliberate scope and compare the first scan with an object inventory from that same database. Keep catalog access separate from source access.

Test scan freshness and who can discover assets after a view is added to SQL Server. Record which catalog or governance environment owns that process today, including any planned Microsoft migration. Source metadata, classifications and business labels can have different permissions and maintenance workflows.

Microsoft Purview Data Map source selection for SQL Server
Microsoft documents SQL Server registration before scanning the source. Publisher example
Compatibility
Microsoft documents on-premises SQL Server scanning and the required runtime. Connector capabilities depend on configuration.
License and trial
Existing accounts only. Microsoft lists maintenance mode through November 12, 2027.

OpenMetadata

OpenMetadata ingests SQL Server metadata through an MSSQL connector into a shared catalog. Its database, schema and table records give readers a reference that stays connected to the ingestion workflow. This is useful when the same platform serves several databases or data systems.

It is a good candidate for organizations that want an open metadata platform and can operate ingestion and access control. Scan completion and freshness are important. Catalog edits and source descriptions may have different owners, so the useful comparison is how the deployed version reconciles those values after a refresh.

Use the MSSQL guide for the catalog release you actually deploy. Set the database and schema filters before testing so missing objects can be traced to scope, account visibility or connector capability. Store the ingestion configuration with a record of which workflows the catalog runs.

Inspect the imported view, column description and ownership separately. Re-run the same ingestion after adding a SQL Server object and editing a description in the catalog. Collect the scan status and outputs so the team can explain which edits were preserved and which changed.

OpenMetadata remote SQL Server connection settings
OpenMetadata documents the connection settings for its MSSQL connector. Publisher example
Compatibility
OpenMetadata documents MSSQL ingestion, permissions and connector capabilities by version.
License and trial
Open-source and managed deployment options. Platform and connector operations still need ownership.

Atlan

Atlan’s SQL Server connector crawls supported object types into a catalog used by the data team. Readers can find database assets and add organizational context where the workflow supports it. The catalog is useful when people need to discover the right asset across several systems before asking its owner.

It fits a company that already wants a shared catalog with ownership and search. A SQL Server crawl has a defined scope. Coverage depends on the selected databases, supported asset types and permissions. After a rename or new object, the scan schedule determines how quickly readers see the change.

Atlan publishes a list of crawled SQL Server asset types. Use it as the inventory for the pilot and check what connected users see in the catalog. Where query history is relevant, verify the separate workflow and permissions instead of treating it as part of a basic asset crawl.

Assign an owner or a description in the platform, then rename or add an object in the disposable SQL Server schema. After the next crawl, check the catalog entry, last refresh and manual context. Use the result to decide who reconciles renamed or retired assets.

Atlan documentation for Microsoft SQL Server metadata crawl coverage
Atlan lists the SQL Server asset kinds and properties its crawler collects. Documentation screenshot
Compatibility
Atlan documents the SQL Server crawler, configuration and supported asset types.
License and trial
Commercial catalog. Connector entitlement, implementation and access terms depend on the plan.

SQL Server documentation tools by workflow

What you needTools to shortlistWhat to verify
Create a scoped handoff or release referenceGenerate a sample in the recipient’s format. Verify descriptions, keys and scope.
Generate documentation from a scheduled jobRegenerate after a schema change and confirm the output, source artifact and access controls.
Maintain SQL Server business descriptions in a catalogImport source descriptions, add catalog context and refresh after a change.
Discover SQL Server assets within a governed catalogConfirm the connector’s asset coverage, scan cadence and what a normal reader can find.

Choose how readers will use the documentation

Pick the output based on the maintainer and the audience. A deployment team and an analyst can use the same SQL Server metadata through different delivery paths.

Who needs the documentation after the first run?
  • A team receiving a release or support handoff

    Generate a dated schema export

    Save the output with its database and deployment version.

  • Developers maintaining diagrams and field notes in review

    Keep a versioned schema model

    Diff imported metadata and retain curated text as part of the project.

  • Several teams browsing and assigning ownership

    Evaluate a recurring catalog

    Compare asset scope, freshness, annotations and access control.

Compare metadata coverage and description ownership

Use a scoped account to test object visibility. SQL Server metadata visibility follows permissions, and source scans can require connector-specific grants. Confirm which object definitions and properties are visible before requesting broader access.

Pick an owner for each type of description. A generated snapshot can reread the database on every run, while a catalog may preserve a manual entry even after the source text changes. Use the tool's documented rules to interpret the difference.

Expected checks before and after the metadata refresh
CheckInitial scanRefresh or direct SQL expectation
Table and new viewOne table. No reporting view.Both objects appear, and a supported dependency view shows that the new view reads the table.
Column descriptionGross receipt amount.Settled gross receipt amount in SQL Server. A nonblank curated description may take precedence in a catalog.
Business noteAdd a note to the model or catalog after the first scan.Verify the note stays on the object after refresh or is retained in source control.
Reader scopeRun with intended metadata permissions.The same scope sees both objects. Object visibility follows granted permissions.

How to compare these tools

Give each tool the same schema and permissions. Change a column description and a relationship, regenerate the output and check what a reader can find in the exported reference. Sources checked .

Refresh a real schema and see which context survives

Run the following setup in a disposable SQL Server database, generate the initial documentation, then run it again with the refresh flag set to 1. Use the same tool configuration and account for both scans.

SQL

Create a two-phase SQL Server documentation refresh fixture

T-SQL · 52 lines

SET NOCOUNT ON;SET XACT_ABORT ON;DECLARE @ApplyRefresh bit = 0; -- Set to 1 after the first scan. IF DB_ID() <= 4    THROW 50000, 'Use a disposable user database.', 1; IF @ApplyRefresh = 0BEGIN    IF OBJECT_ID(N'dbo.DocTrialReceipt') IS NOT NULL        THROW 50000, 'The fixture table already exists.', 1;     BEGIN TRANSACTION;    CREATE TABLE dbo.DocTrialReceipt (        ReceiptId int NOT NULL PRIMARY KEY,        GrossAmount decimal(10,2) NOT NULL    );    EXEC sys.sp_addextendedproperty        @name=N'MS_Description', @value=N'Gross receipt amount.',        @level0type=N'SCHEMA', @level0name=N'dbo',        @level1type=N'TABLE', @level1name=N'DocTrialReceipt',        @level2type=N'COLUMN', @level2name=N'GrossAmount';    COMMIT TRANSACTION;ENDELSEBEGIN    IF OBJECT_ID(N'dbo.DocTrialReceipt', N'U') IS NULL        OR OBJECT_ID(N'dbo.DocTrialReceiptSummary') IS NOT NULL        THROW 50000, 'Run the initial phase before the refresh.', 1;     BEGIN TRANSACTION;    EXEC sys.sp_updateextendedproperty        @name=N'MS_Description', @value=N'Settled gross receipt amount.',        @level0type=N'SCHEMA', @level0name=N'dbo',        @level1type=N'TABLE', @level1name=N'DocTrialReceipt',        @level2type=N'COLUMN', @level2name=N'GrossAmount';    EXEC sys.sp_executesql N'CREATE VIEW dbo.DocTrialReceiptSummary AS    SELECT SUM(GrossAmount) AS GrossAmount FROM dbo.DocTrialReceipt;';    COMMIT TRANSACTION;END; SELECT c.name AS ColumnName, CONVERT(nvarchar(200), p.value) AS DescriptionFROM sys.columns AS cJOIN sys.extended_properties AS p    ON p.class = 1 AND p.major_id = c.object_id AND p.minor_id = c.column_idWHERE c.object_id = OBJECT_ID(N'dbo.DocTrialReceipt')    AND p.name = N'MS_Description'; SELECT OBJECT_NAME(referencing_id) AS ViewName, referenced_entity_nameFROM sys.sql_expression_dependenciesWHERE referencing_id = OBJECT_ID(N'dbo.DocTrialReceiptSummary');
Review before runningT-SQLUTF-852 lines
  1. Generate the first snapshot with the proposed scanner identity. Record the visible objects and add a clearly marked business note to the model or catalog if the tool supports it.
  2. Change the fixture's @ApplyRefresh flag to 1 and rerun. The source gets a revised column description and a new view. Refresh the documentation using the same scan scope.
  3. Compare a direct SQL metadata read with both outputs. Check the new view and its dependency, the active source description, and the retained note. Repeat using the intended deployment account if you initially used a DBA account.

Conclusion

Choose a format and an update process readers can rely on. A file works for a handoff, a scheduled report works for release-by-release changes, and a catalog works for shared ownership and discovery. Validate the output against SQL Server and assign someone to maintain the descriptions.

Frequently asked questions

What should SQL Server database documentation include?

Start with the schemas, tables, columns, keys, constraints, views and routines people need to use the database. Add readable descriptions and ownership where they answer a real question. Publish the collection scope and refresh date.

Can a documentation tool read MS_Description values in SQL Server?

Some tools import extended properties or database descriptions. Check the connector, permissions and selected output. Add a known table or column description and verify the generated result.

What is the difference between a database documentation file and a data catalog?

A documentation file records an export for a particular handoff or release. A catalog adds searchable assets, metadata ingestion and collaboration in supported workflows. Verify who owns descriptions and how each result is refreshed.

Why can a documentation tool miss SQL Server objects?

The selected database and schemas, visible metadata and connector capabilities all affect the result. Compare the output with the account’s SQL Server permissions and a known reference schema.

How do I keep SQL Server documentation current?

Automate generation or scans at a useful cadence, usually around database changes. Test how manual descriptions survive refresh and assign an owner who reviews changes and fixes gaps.

Why does a refreshed catalog still show the old column description?

Some tools make a previously entered catalog description authoritative after import. Compare the current SQL Server MS_Description value with the catalog value, then review the connector's import rules before changing either copy.

Related guides

Guide~15 min readUpdated 15 Nov 2026
LinkedInXEmail