Developers love the Aspire dashboard for
collecting and visualizing telemetry from their apps. Structured logs help
explain what happened, traces show how a request moved between services, and
metrics reveal changes over time. Alongside telemetry, the dashboard displays
resources, their configuration and health, and console output.
Previously, the dashboard stored data in memory, so stopping it meant losing
that data. Because the dashboard starts and stops along with your AppHost,
restarting your app also cleared the evidence you might still need to debug it.
Aspire 13.6 adds persistence to the dashboard. You can restart your app, return
to an earlier run, and inspect its saved data using the same pages and filters
you already know. The change also lets us raise telemetry limits and reduce
memory usage.
This post looks at the new experience and the engineering behind it:
SQLite storage
Dapper queries
Keeping the dashboard responsive under load on a busy development machine
Benefits
Revisit a previous run
Imagine your app fails to start correctly. You change its configuration and
restart. Everything now looks healthy, but you want to check the original
failure to understand what happened.
The dashboard now has a run selector in its header. Open it to switch from
Live run to an earlier run of the same application:
This behavior is enabled by default when an AppHost launches the dashboard.
Each time the dashboard starts, it creates a new run with its own SQLite
database. Selecting an earlier run lets you inspect its saved resource state,
logs, traces, and metrics. You don’t need to reproduce the failure just to see
its telemetry again.
Keeping telemetry in memory required conservative limits. A busy app can
produce a lot of logs, and the dashboard shares your machine with an editor,
agents, builds, containers, and the app you’re developing.
Storing that history in SQLite instead of keeping it all in memory lets us
raise default telemetry limits:
Data type
Previous default
Aspire 13.6 default
Console log entries
10,000
100,000
Structured logs
10,000
100,000
Traces
10,000
100,000
You can increase these limits further through
configuration.
Our testing during development showed that the dashboard remained usable and
responsive with millions of rows of telemetry.
Reduced memory usage
SQLite lets the dashboard retrieve telemetry as needed instead of keeping
the entire history as .NET objects.
In a benchmark that loaded the same large volume of logs, traces, and metrics
into both versions, private memory usage fell from 1,007 MB in Aspire 13.5 to
241 MB in Aspire 13.6, a 76% reduction.
SQLite and Dapper under the hood
Persistence needed to fit the dashboard’s role as a development tool. We
didn’t want to ask developers to install and manage another database server
just to inspect their applications. We also needed to keep filtering and
paging responsive as the amount of stored telemetry grew.
SQLite fits that workload well. It’s a fast, embedded
database that runs inside the dashboard process. There is no separate server
to configure or network connection between the dashboard and its database.
The dashboard ships the dependencies it needs.
High-performance SQL
We use Dapper to execute tuned SQL
and map query results to .NET objects.
We considered Entity Framework Core, but for this data layer we wanted direct
control over the SQL and how Dapper materializes results. A dashboard query
might filter by resource, severity, text, and attributes, count the matches,
and then retrieve one page in a particular order. Those queries are central
to the experience, and we wanted to tune them directly.
For example, the
structured-log query
filters, counts, sorts, and pages results in SQLite before materializing the
requested logs. Looking at a page of results doesn’t require loading all
retained logs and filtering them in .NET.
Dapper.AOT also generates query and mapping code
at build time instead of relying on runtime code generation. We use that
support in the Native AOT dashboard in Aspire 13.6.
Fun fact: we used the Aspire dashboard to profile its own SQL queries during
development.
Protecting persisted data
Resource configuration and telemetry can contain secrets. Saving them to disk
means we need to think about who can read that disk, not just who can sign in
to the dashboard.
By default, persistent data lives under the dashboard directory in the
current user’s .aspire directory. Setting ASPIRE_HOME changes that base
location, and the dashboard also supports an explicit data-directory setting.
Keeping the default under the user profile avoids writing sensitive data
into a source directory you might commit or share.
The dashboard is also useful
without an AppHost, including for
applications written in other languages. Persistence has three modes to
support those different workflows:
Mode
What the dashboard does on restart
Run selector
None
Creates a new temporary database; doesn’t retain previous data
No
Run
Creates a new database and retains previous runs
Yes
Resume
Reopens the same application database
No
An AppHost sets the mode to Run automatically. The standalone dashboard
defaults to None, so keeping its data is an explicit choice. For a standalone
dashboard that retains its history across restarts, use:
aspire dashboard run --application-name my-app --persistence Resume
Keep data outside a container
A popular way to use the Aspire dashboard is to run its standalone container.
A database inside a disposable container doesn’t help when that container is
removed. The solution is to mount persistent storage and configure the dashboard
inside the container to use it.
A skill became an artifact that the pipeline generates, archives and consults on its own. This is automation with supervision at the right points.
Image generated with Gemini
In Part 1, I wrote about building skills so the AI understands your project. In Part 2, the harder problem: writing a skill so the AI understands you.
Part 3 is different. It picks up where Part 2 left off, with the infrastructure needed to catch up with the partnership, and it ends at a point that exceeded my own expectations: the pipeline learning to fix its own errors and document what it learned.
August: The Month of Volume
Source Genesys (SG) is a technology that creates vertical SaaS platforms. It’s fully automated with Cursor and we have already several platforms in production. SG has a CLI command that automates the process of programing with a custom pipeline CI/CD. August was the time to test and design the skills for Cursor and Claude.AI. There was a lot of documentation to analyze the quality and security of the code.
The August report logged 507 executions across 833 sessions, with a success rate of 85.4%. That is 10 active platforms, 10 generators running in parallel. All the data comes from my own work sessions.
The number that matters most isn’t the total. It is in the distribution. AAA (the main tenant system controller) led in publications with 47, followed by MDS with 39. Together, the two platforms accounted for more than half of the month’s total volume. That is no accident; it reflects where development was concentrated.
The peak activity hour is 2 p.m., with 72 executions. But real behavior shows up when you look at the full curve: there is significant activity at 10 p.m., midnight, and 1 a.m. Work does not stop when the day ends. The pipeline is available for as long as you are awake, and that changes how you distribute your attention throughout the day.
How Activity Spreads Across the Day
The chart below shows SG CLI automated command executions per hour in August. The 2 p.m. peak (72 executions) coexists with consistent late-night activity, making it clear that the pipeline operates as an extension of the work rhythm, not a replacement for business hours.
Daily Activity by Hour
The Price of Volume: Failures and What They Reveal
High volume brings failures. 74 executions ended in error during the month. The overall rate landed at 85.4%, technically within the limit, but what matters is the daily variation, not the average. The daily success rate chart swings between 100% and 25% throughout the month, with perfect peaks followed by rough days. This is not progressive degradation. Episodic instability is harder to diagnose than steady decline.
The failure heatmap by platform and command reveals the pattern clearly. For ActivateObservability, a command to self-publish observability on Grafana Cloud without human intervention, MDS holds the highest absolute number of failures: 12 occurrences. That is because it is the base system and template for all the other platforms. The number does not come from a difficult platform; it comes from a command with inconsistent behavior. The failure happened during activation, not in the platform itself. When the same command fails in [PIX]BOL, CRMW, AAA and Entity, the hypothesis of an isolated issue becomes unsustainable.
ActivateObservability ended August with a 48.6% failure rate. TestAPI came in at 66.7%. Together, those two numbers point to where the pipeline still has work ahead: observability activation and API testing, which are customized per platform, are the highest-pressure points in the system.
Failure Rate by Platform: Where the Pipeline Still Has Work to Do
The chart below shows the failure rate of my project by platform in August. MDS leads with 25.7%, the highest value in the ecosystem, and it is the base template that feeds all the other platforms.
Fail (%) by Platform
MDS’s 25.7% failure rate demands attention for two reasons. The first is volume: 39 publications in the month means each failure has a real-time cost. The second is the MDS platform’s template nature. Problems here can propagate to every generated platform.
But the number doesn’t show the full picture. MDS is also the platform where development is most intense, where new patterns are tested first, and where the pipeline receives the most significant changes before they are propagated. A high failure rate on a platform under active development is not the same as one on a stable platform.
What Skills Changed in the Pipeline
Part 1 of this series described how skills were built by hand: one Markdown file per domain, loaded in the right context, teaching the AI what it could not learn from generic training. In August, that architecture evolved in two directions.
The first direction was scale. With more than 500 active skills covering everything from system identity to password patterns, CI/CD, observability and Cursor behavior, the volume of context available per session grew. That directly affects the quality of generated prompts: when the AI knows the canonical pattern, the prescriptive prompt gets shorter. Less room for Cursor to improvise.
The second direction was unexpected.
Auto Fix: When the Pipeline Learns to Write Its Own Skills
On August 15, the pipeline log showed something different in AutoFix, an AI module using Cursor and several skills. AutoFix had run, corrected a TypeScript error in AAA, and automatically generated the skill 31-sg-ts2307-module-not-found.mdc. No manual intervention. No additional prompt.
The name that came out of it was SG AUTO FIX.
The mechanism worked like this: when AutoFix resolved an error with no prior record, it generated a skill with the problem pattern, the affected platform context and the solution applied. The skill was saved with a 15-day TTL, a sequential number, and made automatically available for future sessions.
Then the pipeline gained a distinction that, in practice, is the most important of all: before applying any fix, AutoFix had to classify the file with the error. If the file was generated by SG and had a corresponding template mapped in SG code, the fix had to go into the template, not the generated file. Fixing the output without fixing the source would mean that the next time the generator ran, the error would come back.
That changed the nature of AutoFix, from remediation to source-level correction.
To make sure no template fix went through without review, SG AUTO FIX was configured to fire a notification whenever it changed an SG template, with the full diff of what it was and what it became. The learning loop gained a mandatory point of human supervision at exactly the spot where the risk is highest.
What High Volume Revealed About the Pipeline
With the high volumes of August’s data consolidated, the dynamic had shifted: Cursor was generating its own fix instructions, and Claude had become the second opinion, the one I’d check before approving what the pipeline had decided on its own.
PublishDirect (the CI/CD that publishes artifacts fully automated) accumulated 924 minutes in the month, more than 15 hours of build time, over 10 times the next most expensive command. It consumes the most time because it does the most work. The point is not to reduce that number, but to understand what is inside it: every minute of a successful PublishDirect is a platform running without manual intervention.
Average build time per platform ranges from 0.37 minutes for ADV to 4.2 minutes for CRMR. That 11x variation between the extremes is not necessarily a problem; more complex platforms have longer builds. What matters is the P90: CRMR and MDS have the highest P90 in the ecosystem, which means a significant fraction of builds on those platforms is much slower than the median. When P90 is much higher than P50, the pipeline is unstable, not slow.
Put it this way: if P50 = 8 min and P90 = 22 min, there is a 14-minute gap.
That means every time something leaves the happy path, the build takes nearly 3x longer. The pipeline is not slow; it is unpredictable.
A slow pipeline would have P50 and P90 both high.
An unstable pipeline has P90 much higher than P50; in this case, CRMR and MDS.
The build minutes consumed per day chart shows that July 31 burned nearly 160 minutes, followed by a sharp drop. Cross-referencing with session volume, it was the highest-activity day of the period. There were three rounds of complete rebuilds across multiple platforms, in sequence, to investigate and consolidate template errors. Each round produced a block of logs that AI automatically analyzed, generated a targeted prompt and applied the fix, with manual, interactive work alongside Cursor, case by case.
What Is Still Human Work
With an automated pipeline, active observability, AutoFix generating skills and template notifications, the obvious question is: what still requires a human in the loop?
The honest answer is more than it seems, and at exactly the most important points.
A green build is not validation. AutoFix applies, compiles and reports. End-to-end testing on each platform is still done manually, and that step has not been automated. A build that passes with broken code is worse than a build that fails with correct code, because the failure is visible and the bug is not.
Template fixes require review. When SG AUTO FIX changes a template file, the notification is sent with full diff. Accepting that change without reviewing it would mean delegating to the agent a decision that affects every generated platform.
Conclusion
When I wrote Part 1, a skill was context. In Part 2, it was posture calibration. In August, it became an artifact that the pipeline generates, archives and consults on its own.
This is not full automation. It is automation with supervision at the right points: template fixes, validation testing and prompt scope. The AI executes more and decides less; the developer reviews less routine work and makes more decisions.
The number that sums up August is 85.4% success across 507 executions. But what that number represents is different from what it would have represented six months ago. In January, 85% success would have meant 85% of a small task completed.
In August, it means 85% of 10 platforms running with no manual deployment and no manual observability setup, and, for the first time, a pipeline that knows how to document its own fixes.
Automate with AI. But do not give up reviewing the points that matter. That part is still your job.
TL;DR: Building collaboration, review, and automation into document solutions can require significant custom development. Syncfusion Essential Studio 2026 Volume 3 adds real-time collaboration, PDF comparison, AI-assisted document operations, form recognition, enhanced review tools, and spreadsheet capabilities across the PDF Viewer, DOCX Editor, and Spreadsheet Editor.
Need more than basic document functionality?
Document solutions often require capabilities that go beyond viewing and editing. Collaboration, document comparison, form recognition, automation, and spreadsheet validation can all become part of the same process.
Supporting all these capabilities can require multiple layers of custom development.
From real-time collaboration and PDF comparison to AI-assisted document operations, form recognition, and spreadsheet validation, this release adds capabilities for building more complete document solutions.
Let’s explore what’s new and how these capabilities can help you build document solutions faster.
What’s new in Essential Studio 2026 Volume 3
This release brings new capabilities for collaboration, document review, automation, and spreadsheet data management.
PDF Viewer: Real-time collaboration, link annotations, document comparison, AI-assisted document operations, form recognition, digital signatures, thumbnail navigation, and document modification tracking.
DOCX Editor: Author-based comment highlighting, customizable colors for tracked changes and revision types, and AI-assisted document operations.
Spreadsheet Editor: Rich text formatting, text overflow, real-time collaboration, AI-assisted spreadsheet operations, data validation, find and replace, charts, expanded APIs, and worksheet tab controls.
Together, these updates support key document scenarios such as collaboration, review, automation, and data management.
PDF Viewer: Simplify collaboration, review, and document processing
Displaying a PDF is often just the beginning of a broader document process. Once users need to review, approve, annotate, compare, or process documents, additional capabilities become essential.
Web PDF Viewer
Collaborate on PDFs in real time
Contract reviews and approval processes often involve multiple users working with the same document. Managing separate copies can lead to duplicate annotations, conflicting changes, and outdated versions.
The Web PDF Viewer now supports real-time collaboration for annotations, form fields, and page organization. Multiple users can work on the same PDF simultaneously, while changes made by one participant are automatically synchronized with others.
This provides a shared document experience that helps teams review and edit PDFs without managing separate document copies.
Real-time collaborative editing in Web PDF Viewer
Add links for easier PDF navigation
Long PDFs can be difficult to navigate when users need to move between sections or access related resources.
The PDF Viewer now supports web-link and document-link annotations. Users can create, edit, and delete interactive links that open external websites or navigate to specific pages and locations within the same PDF.
This can be useful for technical documentation, manuals, compliance records, and other lengthy documents.
Adding navigation and reference links in PDF Viewer
Add custom text stamps to document reviews
Document approval processes often need clear status markers such as Approved, Rejected, or Needs Revision.
With custom text stamps, users can create personalized stamp annotations using custom text instead of static images. They can configure the stamp title, font, text color, background color, and optional author, date, and time information, with a live preview during creation.
For example, a compliance reviewer can apply a review-status label directly to a policy document while preserving the review context for future reference.
Adding custom text stamps in PDF Viewer
Compare PDF versions and identify changes
Comparing lengthy versions of contracts or policies manually can make it difficult to identify the changes that matter.
The PDF Viewer now supports semantic text comparison between two PDF documents. It identifies added, deleted, and modified text and provides detailed difference information through a dedicated API.
Instead of manually reviewing both documents page by page, users can focus on the content that changed.
This can be especially useful for legal agreements, HR policies, regulatory documents, and other documents that go through frequent revisions.
Automate PDF tasks with AI agents
PDF-related tasks often involve repetitive operations such as content extraction, page navigation, annotation management, form processing, and data redaction.
With WebMCP tools, AI agents can interact with PDF documents and automate operations such as:
Document navigation
Content extraction
Annotation management
Form field operations
Redaction
Document actions
These capabilities also support document analysis, summarization, and automated form processing.
Developers and users remain in control through review, approval, customization, and undo/redo support. This makes it possible to automate routine PDF operations while keeping important decisions with the user.
Blazor Smart PDF Viewer
Turn scanned forms into interactive documents
Scanned forms often require users or developers to manually recreate fields before the documents can be used digitally.
The Blazor Smart PDF Viewer now supports form recognition for scanned or image-based PDF documents. It can detect text boxes, check boxes, radio buttons, and signature fields and convert them into interactive PDF form fields while preserving their positions.
For registration, onboarding, customer-intake, or application-processing solutions, this can help turn scanned forms into usable digital documents.
Scanning form elements in Blazor PDF Viewer
.NET MAUI Smart PDF Viewer
Simplify PDF processing with AI
Processing PDFs often involves repetitive tasks such as filling forms, identifying sensitive information, and extracting insights from lengthy documents.
The .NET MAUI Smart PDF Viewer, available in preview, introduces AI-powered capabilities for Smart Form Fill, Smart Redaction, and Document Summarization. These features can help users populate form fields, identify and redact sensitive information, and generate concise summaries directly within their applications.
This can simplify document processing while helping users work with PDF content more efficiently.
Adding and validating digital signatures in .NET MAUI PDF Viewer
Navigate PDFs with thumbnail previews
Large PDFs can be difficult to navigate on smaller screens.
The .NET MAUI PDF Viewer now supports thumbnail previews of PDF pages. Users can open a thumbnail pane on desktop and tablet devices or a dedicated thumbnail view on mobile devices, then select a thumbnail to jump directly to a page.
This provides a more visual way to browse and navigate lengthy documents.
Page navigation with thumbnail preview option
Track document modifications with a unified property
Document-based applications often need to know whether a PDF has changed before allowing users to save, close, or submit it.
The .NET MAUI PDF Viewer now provides the centralized IsDocumentModified property to indicate whether the loaded PDF has been modified since it was loaded or last saved.
The property tracks supported changes such as annotation updates, form field edits, signature changes, comments, redactions, and import actions. This removes the need to subscribe to multiple feature-specific events when checking whether a document has changed.
DOCX Editor: Improve document review
Managing PDFs is often just one requirement within a larger document solution. DOCX-based applications also need clear review tools when multiple contributors edit and comment on the same document.
Web and Blazor DOCX Editors
The DOCX Editor updates in this release focus on author visibility, tracked changes, revision types, and AI-assisted document operations across Web and Blazor platforms.
Highlight comments by author
When several people review a document, identifying each person’s comments can become difficult.
The DOCX Editor now supports avatar-based colors for comments. Comment markers and pane borders use the author’s avatar color, while the corresponding commented text is highlighted with the same color when a comment is selected.
This makes it easier to distinguish and track comments from multiple authors during collaborative review.
Avatar-based comment highlighting in DOCX Editor
Customize colors for tracked changes
Documents with many revisions can become difficult to review when every change looks the same.
The DOCX Editor now lets you specify custom colors for tracked changes. Each user’s revisions can be displayed using colors selected from a defined set, providing clearer visual separation between changes made by different authors.
This can make collaborative review easier to follow in contracts, proposals, policies, and technical documentation.
Custom colors for tracked changes in DOCX Editor
Distinguish different revision types
Not all document changes have the same meaning. Insertions, deletions, and table-row changes may need to be identified separately during review.
The DOCX Editor supports separate colors for insertion and deletion revisions and for inserted and deleted table rows. Each revision type can use a specific color or author-based coloring.
This provides a clearer way to distinguish the types of edits made during collaborative document review.
Web DOCX Editor
Automate DOCX tasks with AI agents
Many document processes involve repetitive editing tasks such as inserting content, replacing text, updating formatting, managing bookmarks, protecting documents, and exporting files.
With WebMCP tools, AI agents can interact with the DOCX Editor to automate these operations:
Content insertion
Find and replace
Formatting
Bookmark management
Document protection
File exporting
Users can then review the changes before they are finalized.
For example, an HR application could use approved templates to update employee agreements while allowing a reviewer to verify the final document before distribution.
Document management often extend beyond PDFs and DOCX files. Spreadsheets are equally important in applications that manage business data, reporting, budgeting, and operational processes.
The Spreadsheet Editor introduces updates across Web, Blazor, and WinForms for formatting, collaboration, AI-assisted operations, validation, visualization, customization, and worksheet presentation.
Web Spreadsheet Editor
Create richer spreadsheet content
A single spreadsheet cell may need to contain text with multiple formatting styles.
The Web Spreadsheet Editor now supports rich text formatting, allowing users to apply bold, italic, underline, strikethrough, font family, font size, and font color to selected portions of text.
Multiple formatting styles can coexist within the same cell, along with existing subscript and superscript support.
Display overflowing cell content
Long cell content can be difficult to read when it is limited by the cell boundary.
The Web Spreadsheet Editor now supports text overflow, allowing content to extend beyond cell boundaries when adjacent cells are empty. The feature supports plain text, rich text, hyperlinks, and merged cells.
When neighboring cells contain data, the overflowing content is automatically clipped to maintain a clean worksheet layout.
Text overflow support in Spreadsheet Editor
Collaborate on spreadsheets in real time
When multiple users work with the same workbook, keeping everyone synchronized is essential.
The Web Spreadsheet Editor now supports collaborative editing, allowing multiple users to view and edit the same spreadsheet while seeing real-time updates, user presence, remote selections, and editing indicators.
The collaboration support also handles synchronization of workbook actions, late-join synchronization, missing-action recovery, and conflict resolution for concurrent spreadsheet operations.
Real-time collaboration in Spreadsheet Editor
Automate spreadsheet operations with AI agents
Beyond data entry, spreadsheet processing often involves repetitive analysis, formatting, calculations, and data transformations.
With WebMCP tools, AI agents can interact with the Spreadsheet Editor and automate these operations across workbooks. Developers and users can retain control through review, approval, customization, and undo support.
This provides a way to automate structured spreadsheet processes while keeping AI-assisted changes under user control.
Blazor Spreadsheet Editor
Improve spreadsheet data accuracy with validation
A small data-entry mistake can affect calculations and reports across an entire spreadsheet.
The Blazor Spreadsheet Editor now supports data validation for whole numbers, decimals, dates, times, text length, lists, and custom formulas. These rules can be applied to selected ranges to help ensure that users enter valid data.
For HR, finance, and operations applications, this allows data rules to be enforced directly within the spreadsheet.
Data validation in Blazor Spreadsheet Editor
Find and replace data across worksheets and workbooks
Large workbooks can make it difficult to locate and update specific values manually.
The Blazor Spreadsheet Editor now supports find and replace feature, allowing users to search within a worksheet or across an entire workbook, navigate to matching cells, and replace individual or all occurrences.
The feature also supports case-sensitive, exact-match, and row- or column-based searches.
Find and replace in Blazor Spreadsheet Editor
Visualize spreadsheet data with charts
Spreadsheet data is often easier to understand when it is presented visually.
The Blazor Spreadsheet Editor now supports creating charts from selected data ranges to highlight trends, comparisons, and relationships. Users can create column, bar, area, pie, line, and scatter charts and customize chart elements, row and column orientation, and themes.
Charts also update dynamically when the source data changes, helping users keep visualizations aligned with their underlying data.
Charts in Blazor Spreadsheet Editor
Customize spreadsheet behavior with expanded APIs
Standard spreadsheet behavior may not always match an application’s requirements.
The Blazor Spreadsheet Editor now provides expanded event support for spreadsheet lifecycle changes, user actions, menu interactions, and formatting operations. These events allow applications to validate or customize actions, track operation outcomes, and tailor spreadsheet behavior.
This provides greater control when building interactive spreadsheet experiences for planning, operations, and reporting applications.
WinForms Spreadsheet Editor
Create a more focused spreadsheet workspace
Not every application needs users to move between multiple worksheets.
The WinForms Spreadsheet Editor now lets you show or hide worksheet tabs. The sheet tab visibility can be controlled through the UI or API, helping reduce visual clutter when users only need to work with a specific sheet.
For focused data-entry applications, this provides a cleaner workspace with more room for worksheet content.
Controlling worksheet tabs in WinForms Spreadsheet Editor
Frequently Asked Questions
How are comments from different reviewers identified in a DOCX document?
The DOCX Editor uses author-specific avatar colors to highlight comments and related text, making feedback easier to track during reviews.
What are the benefits of rich text formatting within spreadsheet cells in the Web Spreadsheet Editor?
Rich text formatting lets you apply bold, italic, underline, colors, and different font sizes within a single cell. This improves readability and highlights key information without using multiple cells.
How does the Web PDF Viewer simplify navigation and document reviews in PDF files?
The Web PDF Viewer supports web links, document links, and PDF comparison, enabling easier navigation and quick identification of document changes.
Can different versions of PDF documents be compared in the Web PDF Viewer?
Yes. Semantic PDF comparison highlights meaningful changes between documents, helping reviewers quickly identify updates.
What AI-powered document processing features are available in the .NET MAUI PDF Viewer?
The .NET MAUI Smart PDF Viewer supports AI-powered form field detection, data extraction, and document understanding to help automate PDF processing with less manual effort.
How is real-time collaborative editing supported for PDF documents and spreadsheets?
Syncfusion supports simultaneous editing with real-time updates, user presence indicators, and synchronized collaboration for PDFs and spreadsheets.
Build complete document solutions with less custom infrastructure
Consider a contract management platform where a scanned agreement needs to become an interactive PDF form. Multiple reviewers need to collaborate on the document, legal teams need to track revisions in DOCX files, and business teams need to manage related information in spreadsheets.
Supporting these requirements independently can quickly increase development effort.
Syncfusion Essential Studio 2026 Volume 3 brings capabilities across the PDF Viewer, DOCX Editor, and Spreadsheet Editor for collaboration, review, AI-assisted automation, document processing, data validation, and visualization.
These capabilities help reduce custom development so you can focus on building the application-specific features your users need.
Explore what’s new in Syncfusion Essential Studio 2026 Volume 3
The 2026 Volume 3 release adds capabilities for building richer document experiences across web, desktop, and mobile applications.
Explore the complete release to see how the latest PDF Viewer, DOCX Editor, and Spreadsheet Editor features can fit into your applications.
New to Syncfusion? Start a free 30-day trial to evaluate the latest Essential Studio capabilities in your applications.
If you have done any amount of DACPAC-based deployment, you have almost certainly hit this wall: you need to make a change that the automatic schema comparison cannot safely do on its own - adding a new non-nullable column to a table that already has data, or migrating data out of a column/table that is about to be dropped. The natural instinct is "I'll put that in a pre-deployment script." And then it fails, and you lose an afternoon figuring out why.
The reason is subtle but important, and it was the subject of a long-standing DacFx feature request (microsoft/DacFx#482): pre-deployment scripts run after the schema comparison, not before it. The good news is that preplan script support has now shipped. This post explains the problem it solves, how to use it, and how I use preplan scripts for deliberate destructive actions too - including sample pipeline steps for GitHub Actions and Azure DevOps.
This applies to both of the modern SDK-style SQL project options:
Both build a .dacpac and both deploy with sqlpackage, so everything below applies regardless of which one you use.
The deployment pipeline inside sqlpackage
When sqlpackage publishes a dacpac, it runs a fixed sequence of steps:
Compare the source dacpac against the target database and generate the deployment script.
Run the pre-deployment script.
Run the generated deployment script.
Run the post-deployment script.
Notice the ordering: the comparison happens first, and only then does the pre-deployment script run. That single detail is the root of a confusion that has existed for at least 15 years.
Why "just use a pre-deployment script" doesn't work
Say you want to add a new NOT NULL column to an existing table that already has rows. You want to:
Add the column as nullable (or with a temporary default).
Backfill the data.
Make it NOT NULL.
So you write a pre-deployment script to backfill the data... but it runs after the comparison has already decided to add the column as NOT NULL, and after the generated deployment script tries (and fails) to apply it. The script that was supposed to prepare the data never gets the chance, because the deployment blew up first.
The same applies to data migrations before a destructive change - moving data out of a column or table that is being dropped. By the time your pre-deployment script runs, the comparison has already planned the drop.
Every existing workaround involves manually writing a change script that runs outside the normal publish process - managing it separately in Visual Studio, running it as a separate pipeline step, or splitting the change across multiple check-ins and deploying in stages. They all technically work, but they are convoluted and easy to get wrong.
The fix: a preplan script
The feature requested in DacFx #482 has now shipped (DacFx/SqlPackage 170.5.96): a preplan script that runs before the schema comparison. The publish workflow is now:
Run preplan script ← the new step
Compare and generate deployment script
Run pre-deployment script
Run deployment script
Run post-deployment script
With a preplan step, you prepare the target database before the diff is calculated - back-fill data, stage a migration, or otherwise shape the schema/data so the subsequent comparison produces a safe, correct deployment script. Best of all, it lives inside the project and is handled automatically as part of a normal publish, instead of being a bolt-on script you have to remember to run.
Adding a preplan script to your project
Add a preplan script to the project so sqlpackage runs it automatically before the comparison. Include the file in your project with the PrePlan item:
Keep the preplan script idempotent (guard every change with existence checks) so re-runs and retries are safe.
-- pre-plan.sql : backfill before the comparison adds a NOT NULL columnIFCOL_LENGTH('dbo.Customer','Region')ISNULLBEGINALTERTABLEdbo.CustomerADDRegionnvarchar(50)NULL;ENDGOUPDATEdbo.CustomerSETRegion='Unknown'WHERERegionISNULL;GO
Preplan for deliberate destructive actions
The preplan step is also where I like to handle intentional destructive changes - dropping a column or a table. By default BlockOnPossibleDataLoss=true will (correctly) stop a publish that would drop a populated column. Rather than blanket-disabling that guard, I use a preplan script to deliberately and visibly perform the drop (or migrate the data out first), so that:
The destructive action is an explicit, reviewed line of SQL in source control - not a silent side effect of a schema diff.
By the time the comparison runs, the object is already gone, so the generated deployment script has nothing dangerous left to do and the data-loss guard stays on for everything else.
-- pre-plan.sql : deliberately drop a column that is being retired-- (optionally archive the data first)IFCOL_LENGTH('dbo.Customer','LegacyNotes')ISNOTNULLBEGININSERTINTOarchive.CustomerLegacyNotes(CustomerId,LegacyNotes)SELECTId,LegacyNotesFROMdbo.CustomerWHERELegacyNotesISNOTNULL;ALTERTABLEdbo.CustomerDROPCOLUMNLegacyNotes;ENDGO
This gives destructive changes the same explicit visibility that the old refactorlog never really provided - the drop is right there in a reviewed script instead of hidden in a diff.
⚠️ Beware: you need the latest sqlpackage
One gotcha that bites people regardless of this feature: the sqlpackage version matters a lot.
Newer SqlServerVersion targets (e.g. Sql160, Sql170) and newer DacFx behaviours require a recent sqlpackage.
An old globally-installed sqlpackage on a build agent will throw confusing errors or silently produce wrong results.
The native preplan support only exists in recent sqlpackage (170.5.96 or later), so using the latest is essential if you want to use it.
So always install/update the latest sqlpackage in your pipeline and locally rather than relying on whatever is pre-installed on the agent:
dotnet tool install-g microsoft.sqlpackage
Sample pipeline: GitHub Actions
With the preplan script included in the project, publishing is a single sqlpackage step - the preplan runs automatically before the comparison.
name:databaseon:push:branches:[main]jobs:deploy:runs-on:ubuntu-latestenvironment:production# add a manual approval gate heresteps:-uses:actions/checkout@v4-name:Setup .NETuses:actions/setup-dotnet@v4with:dotnet-version:8.0.x# Always get the latest sqlpackage!-name:Install sqlpackagerun:dotnet tool install -g microsoft.sqlpackage-name:Build dacpacrun:dotnet build ./src/MyDatabase/MyDatabase.sqlproj -c Release# Publish - the preplan script runs automatically before the comparison-name:Publishrun:|sqlpackage /Action:Publish \/SourceFile:"./src/MyDatabase/bin/Release/MyDatabase.dacpac" \/TargetConnectionString:"$" \/p:BlockOnPossibleDataLoss=true
A couple of notes:
The preplan script travels inside the dacpac/project, so there is no separate step to forget.
BlockOnPossibleDataLoss=true (the default for publish) still guards you against unexpected destructive operations - your deliberate drops already happened in the preplan.
The GitHub Environment gives you an approval gate before the deployment runs.
Sample pipeline: Azure DevOps
The same flow translates cleanly to Azure DevOps YAML.
trigger:branches:include:-mainstages:-stage:Deployjobs:-deployment:DeployDatabaseenvironment:production# add approvals/checks on this environmentpool:vmImage:ubuntu-lateststrategy:runOnce:deploy:steps:-task:UseDotNet@2inputs:packageType:sdkversion:8.0.x# Always get the latest sqlpackage!-script:dotnet tool install -g microsoft.sqlpackagedisplayName:Install sqlpackage-script:dotnet build ./src/MyDatabase/MyDatabase.sqlproj -c ReleasedisplayName:Build dacpac# Publish - the preplan script runs automatically before the comparison-script:|sqlpackage /Action:Publish \/SourceFile:"$(Pipeline.Workspace)/MyDatabase.dacpac" \/TargetConnectionString:"$(SqlConnectionString)" \/p:BlockOnPossibleDataLoss=truedisplayName:Publish
Azure DevOps Environments support approvals and checks, which is the natural place to require a sign-off before the deployment runs.
Tip: There is also the built-in SqlAzureDacpacDeployment@1 task for the publish itself, but calling sqlpackage directly gives you full control over the version, which matters when you are depending on newer DacFx behaviour. Work is in progress to modernize/replace this task with a more flexible and modern approach.
One script, in the right place
It took at least 15 years and a long-standing feature request, but the gap is closed: there is now one place in the publish pipeline where you can prepare the target database before the comparison locks in its plan. No more splitting changes across check-ins, no more separate scripts to remember to run, no more fighting a diff that already decided what it's going to do.
Drop pre-plan.sql into the project, keep it idempotent, and let it carry both the data backfills and the deliberate drops - as ordinary, reviewed SQL sitting right next to the rest of the schema. Just make sure the build agent is running sqlpackage 170.5.96 or later, or none of this is available yet.
Erik Darling here with Darling Data, and in today’s video, we, by we I mean me and Batsmaru here, are going to talk about my free database. And I have to say database now, it’s not just SQL Server, since it gained the capability to monitor Postgres and Aurora Postgres as well. The thing is, titling this stuff is like, Free SQL Server and Postgres is it Aurora Postgres, it doesn’t roll off the tongue. So, free database performance monitoring. I can’t see a world where I start bridging into, like, Postgres or, I mean, it’s a bridge into Postgres, MySQL or Oracle, or, you know, some other obtuse, obscure database. But, you know, I think SQL Server and Postgres are probably good enough for me for now. Don’t ask about MongoDB monitoring. I, I, even I have morals and standards. Don’t, don’t give me that. But, uh, I’m going to do this a little bit backwards. Uh, and because, uh, doing a video of an install, uh, turns out not very interesting. Doing a video, doing videos about the stuff you get after you do the sort of, like, boring run of PowerShell command install, much more interesting. So, today we’re going to look at the web viewer for this. Um, If you, if you recall, uh, maybe the earlier versions of the, the, the light and the old full dashboard thing, they only had the WPF viewer, which was very Windows-centric. Uh, moving beyond a Windows-centric view of the world, uh, it turns out web viewers, wonderful for a lot of people. And you can do a lot of stuff in a web viewer that you can’t do, uh, well in, like, a WPF app. So, anyway, down in the video description, you will find all sorts of helpful links to interface and interact with me.
Uh, where you can, uh, hire me for consulting, purchase my training, become a supporting member of this fine YouTube channel. Uh, ask me office hours questions. I do those every Tuesday. If this is your first time here, I do those every Tuesday. Answer five community-submitted questions. Uh, and of course, please do like, subscribe, and tell a friend. Uh, all of the, the helpful links are down in the, your video description. If you would like to take a look at this free SQL, free SQL Server and Postgres monitoring tool, uh, I, I half fixed this slide. The, the headline is fixed, the, the byline is still not fixed, or whatever that’s called. Uh, uh, again, totally free, totally open source, no email signup, no phone home. I don’t try to keep in touch with you for any reason. Uh, unless you want to pay me, that’s different. Uh, but it gets all the stuff that you would care about from, uh, for, from, your servers in order to, uh, monitor, uh, monitor and even troubleshoot, uh, performance issues. Uh, if you are a particularly robot-y type person, as many people are these days, uh, there are built-in MCP servers that, uh, allow you to interface and interact with your monitoring data, much in the same way that you could interface and interact with me, uh, but they can’t hug you. Uh, and you can just, you know, have the robots sort of look at that collected data and, uh, tell you the wrong things.
It’s fun. Anyway, uh, I am speaking at Pass Summit West. I should make this more colorful. I need to get some stuff in here. Uh, I started to mess with this slide and then I got bored. Uh, November 9th through 11th, I have a pre-con there and I have a regular session there. It’s going to be a good time. Uh, this slide is going to be much better in the next video, uh, now that I’ve realized that I forgot to finish working on it. Anyway, let’s go talk about, apparently reaping time has come. We got our beer, we got our size and pitchforks. We got, we got our crows flying. We got, yeah, we’re having a nice time. Anyway, uh, over to the web viewer, right? This is, uh, what you see when you get into it. Now, uh, when, when you say the words web viewer, a lot of people will be like, ah, man, and this, that it does refresh. It blinks when it refreshes. It’s not, it’s not you. You’re not having a brain episode. It refreshes and blinks itself. Uh, when you say the words web viewer, uh, security people tend to get a little worked up, right? Cause they’re like, well, who, who can view it?
So this, the, the way that this works, um, um, the, the, I’m implementing OIDC for this thing, but, uh, you, you also get a bearer token with this and the bearer token, uh, controls, uh, not only, uh, what, like, you know, who gets to see it, but the level of access that they have. Uh, there is like an admin, uh, uh, set, uh, admin token where you can get in and do whatever you want. And then there’s a read only token. Uh, read only is a little bit loose because you can still create custom views with the, the read only token. Uh, but you can’t change like monitoring settings and stuff. You can’t like mess with other stuff, but this is kind of what you get, uh, out of the box. Uh, you get a fleet overview. So this shows you, all right, boinky. This shows you kind of what’s going on. Uh, you, you, you might notice here that I have not only, um, uh, my, my SQL boxes, but I also have, uh, these Postgres boxes being monitored. Uh, these, uh, things are not very active at the moment. Uh, cause I don’t, I don’t generate a lot of Postgres workload here.
All of the Postgres monitoring was done by sort of, um, dog fooding at client sites. So they were just like, yeah, go ahead. Uh, want to monitor Postgres? Yeah. And build, use ours. Take a look, see what you can get. So that’s what I did. Uh, so, uh, get that. Uh, this is the, the, the thing is, is, is, is you see it when you first walk in. Uh, you’ll see SQL Server 2025 needs some attention. I’ve got HammerDB running on SQL Server 2025 at the moment. So there’s some stuff going on. Uh, but the rest of the things are kind of quiet. Uh, there is also, uh, reasonably good availability group monitoring.
Um, if you have one of those crazy, uh, you know, uh, you know, distributed AGs, uh, life gets a little trickier. So, uh, not quite there yet, but here, uh, you, if you have a normal-ish AG, uh, I can tell you all sorts of things about it. Uh, this fleet sweeps thing, uh, this sort of goes through and gives you, um, it, that, uh, whatever cadence you desire, uh, a sort of overview of what’s going on with your entire, uh, fleet at once. So, like, how this changes throughout the day. It’s like, you know, reports and it says, hey, things got weird since the last time we looked.
Uh, there are all sorts of, there’s all sorts of alerting that you can do with the monitoring tool. Generally, it can go to Slack, it can go to Teams, it can go to PagerDuty, uh, all those, the normal things that DBAs sort of rely on to get alerted for stuff. Um, and then, uh, let’s see, let’s just go down to the server that is currently in the red. And we can, we take a look at this and we will see that we have some spikes. Uh, we have our overview here with all this stuff going on.
We can sort of get a, get a sense of what the server is under the covers. Uh, maybe I need to install a CU or something. Um, and then, you know, sort of like, you know, what’s going on in the server? We’ve got some IO latency, we’ve got some blocking, we’ve got some other stuff happening. Uh, you know, from the web view, I can’t do as many interesting things with the web view as I can, uh, with the WPF viewer as far as, like, interactivity goes, but the web viewer does give you a great way to view what’s happening.
So we get wait stats, we get CPU, we get memory, uh, we get blocking file IO, you know, the queries that we’re running, how the server is configured, if anyone’s changing stuff, um, you know, perfmon sort of activity on the server. Um, uh, system events from the, uh, from various, uh, views within the server to look at CPU and other sort of overall server health stuff, system health event type stuff. Uh, and then, you know, something that sort of tells you about the collector health in general, because what good is a monitoring tool if it doesn’t monitor itself a little bit and tell you if things are spitting up, right?
Because, you know, like, ah, everything looks fine. Oh, wait, it’s not collecting anything. That’s not right. That’s not a good time. So, uh, that’s what you get sort of from the web viewer experience. Um, down here are the, a couple of custom views that I have. Uh, this one is, uh, that I put together. This one is showing me how much resources that HammerDB, uh, queries are using and what they are specifically responsible for. And down here, uh, here’s another fun one, uh, the HammerDB TPCC workload stuff going on. Oh, look at all these deadlocks. You can see all the things going on in here. Then these, these are custom views that I created, uh, just within the web viewer itself, putting those things together. Uh, there’s a sort of server health one in general that just sort of, um, you know, puts together a, um, you know, it’s like sort of whatever, whatever metrics you want to mish mash together. Like I put together like the, the sort of bigger dashboard, the grand overview of everything up there. If there’s a bunch of stuff that you make sense to you, for you to look at together at once for a server, go ahead and mish mash it in together here. When you want to create a new view, just go into the new view, choose whatever stuff you want to put in there. Uh, you know, you can add panels, you know, you can do all this fun stuff, right? And you can measure all the cool, all the stuff you want in your SQL Server, highly configurable. Um, I tried to, tried to make this as sort of open-ended as possible, uh, to allow you to, uh, create whatever views make sense for you to keep track of what’s happening on your servers. But, uh, you know, if, again, this is, this is an open source tool. If there’s code you want to contribute, you’re welcome to do so. If you’re, if you’re one of those people who’s like, but I don’t know how to code, you, you can have your robot friends help you with stuff. Um, it’s, it’s fine with me. Uh, you know, if you have, if you find a problem, GitHub, port a bug, I’ll fix it, right? It’s a, it’s a beautiful thing, right? And again, totally free, totally open source, costs you nothing. I don’t want to bother you with stuff. Uh, but yeah, it’s, it’s, it’s been fun working on this, uh, highly gratifying experience. And, uh, uh, everyone who uses it loves it. That’s why it’s called Darling. All right.
Thank you for watching. I hope you enjoyed yourselves. I hope you learned something. I’ll see you in tomorrow’s video where we will, uh, talk about some boring time zone stuff. But then, uh, next week, I’m going to do some more walkthrough videos of, uh, what’s been going on and what’s been, uh, happening with, uh, the, the, uh, development of the monitoring tool stuff lately. All right. Thank you.
Going Further
If this is the kind of SQL Server stuff you love learning about, you’ll love my training. Blog readers get 25% off the Everything Bundle — over 100 hours of performance tuning content. Need hands-on help? I offer consulting engagements from targeted investigations to ongoing retainers. Want a quick sanity check before committing to a full engagement? Schedule a call — no commitment required.
Log in
