The useful part of a masked SQL Server copy is the data that still behaves like the application expects. Names and email addresses can change, but required fields, unique indexes and joins still have to work. This is why a repeatable masking job needs both rules for sensitive values and a way to keep related columns compatible.

Redgate, Tonic and DATPROF offer workflows for applying rules or generators to recurring test data. Delphix, Accelario and Informatica are candidates when masking is one stage in a managed refresh. FieldShield and DataSunrise can suit a job with a defined destination. The important differences are where the original data is staged, how the rules handle a shared identifier, and what happens when a new sensitive column appears.

SQL Server data masking tools for developer copies

The table compares static masking workflows for SQL Server test data. Check where a tool reads the original records and where the masked values are written.

Eight SQL Server static masking tools by workflow, rule review and licensing
ToolCopy workflowRule or job focusPilot checkLicensing
Redgate Test Data ManagerSupported SQL Server anonymization in a test data workflow.Rules and CLI runs.Check related keys, uniqueness and automation.Commercial plan.
Tonic StructuralSQL Server connector and supported output mode.Generator configuration and consistency.Compare repeated source values across tables.Commercial plan and deployment terms.
DATPROF PrivacySQL Server test data using supported drivers.Repeatable SQL Server masking rules.Verify identifier consistency and repeatability.Commercial licensing.
Perforce Delphix Continuous ComplianceSupported SQL Server source or target through the masking job.Inventory, profiling and configured masks.Check job options and deterministic mappings.Enterprise contract.
IRI FieldShieldRelational SQL Server masking via a prepared job.Discovery, reusable fields and masking algorithms.Check data lineage, connections and repeatable output.Commercial and deployment terms.
DataSunrise Static Data MaskingDocumented SQL Server static copy or masking workflow.Choose sensitive columns and rules.Check the written values with SQL Server queries.Confirm static masking entitlement.
Accelario Data MaskingDocumented SQL Server masking and anonymization paths.Masking rules and changes to the test copy.Match source version and referential checks.Commercial deployment and terms.
Informatica Test Data ManagementMasking plan for a compatible SQL Server runtime.Profiles, policies and execution plans.Verify related fields and scheduler behavior.Enterprise product and runtime entitlement.

Redgate Test Data Manager

Redgate Test Data Manager organizes anonymization around treatments and rules for the selected database. A team can review the tables and columns in a treatment and run masking as part of a command-line workflow. That is useful when developers receive a refreshed copy regularly and the masking policy needs a version people can inspect.

The strength is repeatability across refreshes. A treatment that preserves application relationships on one copy can still miss a field added later. Redgate also documents restrictions on masking key columns because changing an identifier affects uniqueness and joins. Those constraints determine which data can be changed safely under one rule.

Redgate is useful when a team wants SQL Server test data rules checked into a repeatable provisioning process. Confirm which jobs can run from the command line and which rule definitions the team reviews. Start with two related tables to verify a realistic copy.

Measure the maintenance workload by changing a schema between refreshes. Decide who updates coverage and how incomplete runs block distribution. Use the chosen entitlement and actual runtime when comparing costs.

Redgate Test Data Manager guide to reviewing and editing masking rules
Redgate documents how to inspect the rules in an anonymization treatment. Documentation screenshot
Compatibility
Redgate documents supported SQL Server versions, anonymization treatments and CLI execution.
License and trial
Commercial. Anonymization, subsetting and provisioning entitlements depend on the Test Data Manager license.

Tonic Structural

Tonic Structural assigns generators to fields in a SQL Server data workflow. Supported generators can preserve specific kinds of consistency. For example, a value that recurs in a source can be mapped to a consistent replacement where those options apply. The result can be more usable for tests built around recognizable relationships.

Its main appeal is control over the shape of the replacement data. Consistency, uniqueness and stability between generation runs are separate properties. A mask that produces valid-looking email addresses may still collide under a unique index, and a mapping that is consistent in one run may need additional settings to stay stable across refreshes.

Tonic is worth testing when developers need plausible replacement data and the same source value must resolve consistently across columns. Verify the generator and consistency options supported by your output mode.

Run separate refreshes against an eligible SQL Server pair. Inspect repeated contact values, uniqueness and long text, then check what would be missed if one new column were omitted from the policy.

Tonic Structural documentation for consistent masking or generation
The consistency documentation explains the generator behavior relevant to repeated masked values. Documentation screenshot
Compatibility
The SQL Server connector and generator consistency options are documented. Behavior depends on the generator and output mode.
License and trial
Commercial. Connector, generation and deployment terms depend on the selected plan.

DATPROF Privacy

DATPROF Privacy applies masking rules to SQL Server data and documents deterministic options. A repeatable replacement for an identifier can preserve a test that expects the same logical customer to appear in related tables.

It is a reasonable fit when preserving application joins is a central requirement. Deterministic masks can make data easier to correlate across refreshes. The lookup data or secrets used by those rules therefore need protection too. A schema change can also expose a new sensitive field unless it is included in the rule review.

DATPROF fits environments that need a repeatable masking project for copies of related SQL Server data. Map repeated identities across the tables using documented deterministic rules and verify the destination.

Test the deployment as a scheduled refresh and keep the rule definitions with the job. An exception for a new SQL Server column should be visible to the reviewer before the copy reaches a developer.

DATPROF Privacy product overview of masking and synthetic data generation
DATPROF describes repeatable masking and test data generation for application teams. Documentation screenshot
Compatibility
DATPROF documents SQL Server masking, driver requirements and deterministic masking workflows.
License and trial
Commercial. Subsetting, scheduling and masking components can have separate entitlements.

Perforce Delphix Continuous Compliance

Perforce Delphix Continuous Compliance supports profiling and masking jobs for SQL Server through documented connectors. Profiling helps build a list of columns that deserve review. Masking then applies defined rules to a prepared database copy, with operations visible through its job workflow.

That combination is useful when the regular refresh already has an operator and distinct steps for preparing and releasing a copy. Profiling and verified coverage are different outcomes. Sensitive notes or unusual values can still fall outside a discovery rule. The preparation and permissions on the target also matter when the database has triggers or constraints against the affected columns.

Delphix fits larger estates where connection inventory, profiling and masking jobs already need centralized operation. Verify the documented SQL Server connector release, runtime identity and deployment type before selecting a workflow.

Use the same pair of connected tables and record deterministic mapping, privileges and retry behavior. A new column in a regularly refreshed schema is a useful test of the team's review process.

Delphix Continuous Compliance masking jobs list
Perforce’s example shows the Delphix masking jobs list and job status fields. Publisher example
Compatibility
Perforce documents supported SQL Server connectors, preparation steps and job setup by release.
License and trial
Commercial. Continuous Compliance, provisioning and support scope depend on the contracted products.

IRI FieldShield

IRI FieldShield can apply masking rules to relational data that it reads and writes through supported connections. A repeatable job can take SQL Server source data and produce a sanitized target. Deterministic rules are useful for fields that must still match after two tables are transformed.

The main fit is a DBA-managed flow where the source, rule configuration and target need to be explicit. The output still has to satisfy the target schema, including lengths, Unicode handling and NULL values. Execution also creates an operational question about where intermediate data and the rule inputs are stored.

IRI fits a workflow built around explicit relational jobs and reusable rules. Choose the compatible SQL Server source and target path. Check how rules for emails, repeated keys and free text are maintained and applied.

Generate a local synthetic refresh and inspect stored output. If data is staged or exported, include those intermediate files in the trial and verify which retained artifact is handed to developers.

IRI FieldShield relational database masking documentation
IRI documents a database masking job in FieldShield. Documentation screenshot
Compatibility
IRI documents relational masking, SQL Server connectivity and deterministic rule options. Source and target modes affect setup.
License and trial
Commercial. Execution hosts, connectivity and automation terms depend on the licensed deployment.

DataSunrise Static Data Masking

DataSunrise documents a static masking workflow that reads from a source and writes transformed data to a target SQL Server environment. A completed copy can expose the altered values to developers through ordinary table access. That makes the target’s contents the basis for evaluating the result.

It suits a refresh with a defined source, destination and set of tables. Application usability depends on how related rows, keys and free-text fields are handled. An interrupted load also needs to be distinguishable from a completed masked copy before the destination can be released.

Evaluate the product's static SQL Server path using a copied dataset and the documented connection options. The intended result is a prepared dataset with changed values that a developer can work on.

Inspect the output with direct database queries. Check relationships, NULL treatment and any logged samples from the masking job. Compare the product edition that includes the static workflow.

DataSunrise static data masking configuration for Microsoft SQL Server
The DataSunrise example shows configuration for static masking output. Publisher example
Compatibility
DataSunrise documents static masking for Microsoft SQL Server. Connector and encoding coverage depend on source and target.
License and trial
Commercial. Static masking, discovery and target scope vary with the purchased plan.

Accelario Data Masking

Accelario Data Masking applies anonymization policies to database copies. Its support matrix distinguishes SQL Server versions and deployment environments. This matters when copies of the same application are made on different SQL Server releases or hosting platforms.

The product is a candidate when the organization wants masking to be a regular step in distributing test copies. Matching the deployment to the published matrix is the first practical distinction. Within that setup, policy coverage for linked identifiers and newly added fields still determines whether a completed copy is usable.

Accelario is relevant when a team needs to discover and mask SQL Server test data as part of a repeated refresh. Verify SQL Server version and platform coverage and confirm the exact workflow the selected product will run.

Use the lab tables to test a failed refresh and a rerun with a newly added field. Inspect whether the same commercial plan covers the schedule and validation reports you need.

Accelario Data Masking version and feature support matrix documentation
Accelario’s support matrix documents which source versions and features the masking module covers. Documentation screenshot
Compatibility
Accelario publishes a SQL Server version and platform matrix for masking and discovery.
License and trial
Commercial. Supported source editions, masking automation and provisioning depend on the package.

Informatica Test Data Management

Informatica Test Data Management runs masking operations as part of an integration workflow. A SQL Server source and target can be incorporated through supported connections, with a plan describing the data to change. This is useful when operations already manages data movement in Informatica.

It fits established Informatica installations where the scheduler, connector identities and job monitoring are already understood. The operational cost is the surrounding runtime and its dependencies. The resulting tables still have to satisfy the application’s data types and constraints. Successful job status is only one part of confirming the copy.

Informatica TDM fits an enterprise that already operates its integration and data management environment or needs repeatable masking plans across sources. Verify the SQL Server connector and masking runtime versions together.

Decide how the run records column policy and exception approvals. A lab should include at least one relationship and one failed or incomplete refresh so the team can see what reaches the developer database.

Informatica Test Data Management guide for Kerberos connections to SQL Server
Informatica publishes a separate guide for Kerberos-authenticated SQL Server connections in TDM. Documentation screenshot
Compatibility
Informatica documents masking plans and SQL Server connections. Supported TDM, connector and integration runtime versions matter.
License and trial
Commercial enterprise product. Entitlement and support depend on the intended deployment and product lifecycle.

SQL Server masking tools by refresh workflow

What you needTools to shortlistWhat to verify
Keep a SQL Server developer refresh repeatableRefresh twice and verify joins, unique values and whether stable fixture identifiers remain consistent.
Run managed masking and profiling jobsCheck connector support and allow developer access only after job completion and SQL checks.
Write a sanitized destination with controlled mappingsVerify source and destination isolation, value formats, unmatched rows and where intermediate data is stored.
Use an existing enterprise data integration stackRun an existing or representative plan on SQL Server. Verify the connector, runtime, access separation and masked target.

Choose between masking a copy and masking query output

Static masking changes values in a test dataset. SQL Server Dynamic Data Masking applies to returned values according to the caller's permissions and the database configuration. A copied environment needs a test of the values it actually stores.

What is the developer environment allowed to contain?
  • The source must stay private

    Prepare a separate copy

    Mask the copy before providing access, and account for intermediate files and snapshots.

  • Several tables share the same values

    Use consistent mappings

    Verify repeated fields, unique values and joins with a real SQL Server check.

  • A live report needs selective display

    Evaluate query-level masking

    Confirm who can see original values and use database authorization with the chosen masking.

Check that the masked SQL Server copy still works

Test which data must remain unique, which repeated values must stay equal and which attributes must change. Run checks as the lab reviewer and test the access granted to a developer before a copy is distributed.

Expected SQL Server static masking results
CheckInitial stateResult for the masked copy
Original email valuesTwo stored customer addresses and three order contact rows.Zero matches for the original test addresses in both tables.
Customer-to-order mappingTwo customers with three intended orders.No orphan orders. Join returns three rows.
Repeated email valuesCustomer 101 appears on two orders.The replacement email matches the same customer's orders.
UniquenessThe two customer addresses are distinct.The replacement addresses still satisfy the unique constraint.
Another refreshAdd one sensitive field to the test schema.The existing policy is reviewed and the new field is covered before reuse.

How to compare these tools

Check the data stored in the copy with an ordinary login. Confirm that parent and child values still match, sensitive values are gone, and a second refresh applies the same rules. Include any exports in the check. Sources checked .

Refresh a masked copy and validate it from a developer account

Prepare an empty disposable database named MaskingEvidenceLab. Preserve the synthetic source values so they can be checked after a refresh. Apply the vendor's static masking to a lab copy, then run check to verify counts, repeated addresses and original values.

SQL

SQL Server fixture for consistent static masking

T-SQL · 54 lines

SET NOCOUNT ON;SET XACT_ABORT ON; DECLARE @step nvarchar(10) = N'check'; IF DB_NAME() <> N'MaskingEvidenceLab'    THROW 50001, 'Use the disposable MaskingEvidenceLab database only.', 1; IF @step NOT IN (N'prepare', N'check')    THROW 50002, 'Choose prepare or check.', 1; IF @step = N'prepare'BEGIN    BEGIN TRANSACTION;     CREATE TABLE dbo.CustomerMaskLab    (        CustomerId int NOT NULL PRIMARY KEY,        Email nvarchar(128) NOT NULL UNIQUE    );     CREATE TABLE dbo.OrderMaskLab    (        OrderId int NOT NULL PRIMARY KEY,        CustomerId int NOT NULL REFERENCES dbo.CustomerMaskLab (CustomerId),        ContactEmail nvarchar(128) NOT NULL    );     INSERT dbo.CustomerMaskLab (CustomerId, Email)    VALUES (101, N'one@sample.example'), (102, N'two@sample.example');     INSERT dbo.OrderMaskLab (OrderId, CustomerId, ContactEmail)    VALUES (1, 101, N'one@sample.example'),           (2, 101, N'one@sample.example'),           (3, 102, N'two@sample.example');     COMMIT TRANSACTION;END; SELECT COUNT(*) AS CustomerCount,       COUNT(DISTINCT Email) AS DistinctCustomerEmailsFROM dbo.CustomerMaskLab; SELECT COUNT(*) AS OrderCount,       SUM(CASE WHEN c.CustomerId IS NULL THEN 1 ELSE 0 END) AS OrphanOrderCount,       SUM(CASE WHEN o.ContactEmail <> c.Email THEN 1 ELSE 0 END) AS InconsistentEmailCountFROM dbo.OrderMaskLab AS oLEFT JOIN dbo.CustomerMaskLab AS c ON c.CustomerId = o.CustomerId; SELECT    (SELECT COUNT(*) FROM dbo.CustomerMaskLab     WHERE Email IN (N'one@sample.example', N'two@sample.example')) AS OriginalCustomerEmails,    (SELECT COUNT(*) FROM dbo.OrderMaskLab     WHERE ContactEmail IN (N'one@sample.example', N'two@sample.example')) AS OriginalOrderEmails;
Review before runningT-SQLUTF-854 lines
  1. Run prepare, then save the original counts and test values. Use a separate lab source and target if the product copies data between databases.
  2. Choose deterministic or coordinated rules that give each test customer consistent replacements across both tables. Preserve the keys that application tests depend on.
  3. Run the masking job and use check on the masked target. Expect two distinct customer emails, three orders, zero orphans and mismatches, and zero original customer or order emails.
  4. Add a synthetic sensitive field to a fresh source schema and repeat the refresh. Verify automated and manually reviewed coverage separately.
  5. Check access as the intended developer role and record the output and job logs that can be shared safely.

Conclusion

Use the tool that can produce a verified test copy every time the source changes. Protect the original inputs and any reusable mappings. Give developers access when joins and application tests still work and the sensitive values have been transformed where expected.

Frequently asked questions

Is SQL Server Dynamic Data Masking enough for a developer copy?

Dynamic Data Masking changes what selected users see in query results. The original values remain stored in the database. Use static masking or generated test data when the developer copy itself needs transformed values.

Can I mask a primary key and preserve SQL Server relationships?

Keep the existing key when its value is safe to retain. When it needs transforming, map the parent key and each reference consistently. Verify uniqueness, foreign keys and join results after masking.

Why check the masked output twice?

A second refresh shows whether deterministic values stay consistent where intended and whether new rows and schema changes are handled. Keep a known input and an expected masked relationship for the test.

Can masked test data still reveal sensitive information?

Yes. Free text, exports, rare combinations of values and reusable mappings may still expose information. Include those locations and patterns in the validation before using the copy.

Should masking run directly on production?

For a dev or test refresh, prefer a protected source and an isolated copy or destination. Restrict access until the masking job succeeds and the target passes the checks required by the application and data owners.

Does SQL Server Dynamic Data Masking change the stored copy?

Dynamic Data Masking modifies returned values for permitted query contexts. A static masking job rewrites values in a separate test dataset. Check the stored test values, permissions and related rows before distributing a copy.

Related guides

Guide~13 min readUpdated 15 Nov 2026
LinkedInXEmail