DEV Community: Jollen Moyani

Choosing the Right PDF Library in 2026: A Developer’s Checklist

Jollen Moyani — Wed, 18 Mar 2026 14:15:57 +0000

TL;DR: Choosing a PDF library in 2026 goes beyond basic rendering. Developers must evaluate ISO compliance, OCR and data extraction capabilities, cloud and serverless compatibility, security features, and performance optimizations like linearization and incremental updates. This guide provides a practical checklist, decision matrix, and real-world scenarios to help you select the right solution for modern applications.

Many teams learn the hard way that a quick win PDF helper breaks the moment it hits real workloads—failing compliance checks, choking on large files, or stalling inside serverless functions. Then comes the rewrite. Your best move is to avoid that path entirely by evaluating libraries against today’s real requirements: PDF/UA-2 accessibility, PAdES/LTV signatures, true redaction, cloud and WASM deployment, and AI-ready extraction.

This comprehensive guide helps developers across JavaScript, Python, Java, PHP, and .NET select a library that supports all ISO-standard PDF types, integrates with AI and cloud-native workflows, and delivers military-grade security, all while remaining performant and developer-friendly.

Essential basics you should validate first

Before you explore new trends, ground yourself in the basics. Our Resource Center emphasizes five pillars for PDF library selection:

Functionalities: From basic creation to advanced editing (e.g., merging, annotations, digital signatures).
Performance: Handling large-scale operations without choking on memory or CPU.
Integration ease: Integration with your development environment, a clean and intuitive API that minimizes the learning curve, and quick start tutorials.
Cost and licensing: Open source vs. commercial, with distribution rights and usage limitations.
Support and community: Clear and up-to-date documentation, with enterprise-grade maintenance. Regular updates with bug fixes, new features, security updates, and compatibility enhancements.

Why your PDF library choice matters now

The following table highlights five transformative forces shaping PDF processing today.

Trend	Impact on PDF Processing
AI-driven workflows	Extract meaning, not just text. AI software will summarize, classify, and detect anomalies from the PDF content.
Cloud & serverless	Run in AWS Lambda, Azure Functions, Vercel, with the latest infrastructure.
Regulatory compliance	PDF/UA (accessibility), PDF/A (archiving), ZUGFeRD (e-invoicing).
Security threats	Quantum risks, deepfakes, supply chain attacks.
User expectations	Instant load, searchable scans, biometric sign-off.

ISO-Standard PDF types: Your library must support all

A robust PDF library does more than just open files; it preserves the original intent across various specialized formats. PDFs come in many types, each tailored for specific scenarios. The following table outlines these types and highlights their unique characteristics in context.

PDF Type	ISO Standard	Use Case	Required Library Capabilities
PDF/A-1a/2u/3/4/4e/4f	ISO 19005	Long-term digital preservation (including engineering content in 4e).	Font embedding, metadata, no JS, validation, U3D/PRC support (for 4e).
PDF/X-1a/4/6	ISO 15930	Print-ready graphics.	CMYK support, bleed boxes, ICC profiles, preflight checks.
PDF/VT-1/2	ISO 16612	Personalized transactional print.	Data merging, high volume output, and color management.
PDF/UA-1/2	ISO 14289	Accessibility (WCAG 2.2, ADA, EU EAA).	Semantic tagging, reading order, alt text, and logical structure maps.
PDF/E-1	ISO 24517	Engineering & 3D CAD documentation.	U3D/PRC models, measurements, annotations.
PDF/R-1	ISO 19936 (2024)	Raster image archiving.	Multi-page TIFF-like (Raster) structure, OCR-ready, compression.

Game-changing technologies in modern PDF libraries

Modern PDF libraries have moved far beyond simple file generation. As digital documents now power global e‑invoicing, AI-driven automation, and real-time analytics, PDF SDKs are evolving into platforms for intelligence, security, and scale.

Below are four technologies redefining what PDF processing means today.

AI-powered document intelligence

AI is transforming PDFs from static files into structured, machine‑readable data sources. Instead of just extracting text, modern libraries combine machine learning and computer vision to interpret layout, detect tables, infer semantics, and feed downstream automation pipelines in finance, legal, and healthcare.

Today’s ecosystem supports advanced capabilities such as:

OCR with neural networks (e.g., LSTM‑based engines).
Layout-aware parsing with bounding boxes, reading order, and table grids.
Semantic extraction for classification, summarization, or risk/fraud checks.
Integration with AI frameworks like ML.NET or Azure Cognitive Services.

Example: OCR extraction from a scanned PDF

// Syncfusion .NET Example: Extraction from PDF/R (scanned)
using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

using (OCRProcessor processor = new OCRProcessor())
{
    PdfLoadedDocument doc = new PdfLoadedDocument("scanned-invoice.pdf"); 
    processor.Settings.Language = Languages.English;
    string text = processor.PerformOCR(doc);
}

Cloud-native and serverless-ready

Cloud native PDF libraries are optimized for distributed, event-driven environments. They support streaming from cloud storage, handle burst workloads, and scale without manual provisioning. Serverless functions such as AWS Lambda, Azure Functions, and Google Cloud enable cost-efficient, on-demand PDF generation and processing.

Cloud optimized features commonly include:

Zero allocation, stream first APIs.
Direct processing from S3, Blob Storage, or CDN URLs.
AOT compilation for .NET Native or GraalVM.

This architecture makes it easy to support high-volume workflows, like generating thousands of invoices per second or processing documents in parallel during peak load.

For the full version of this article, please visit Syncfusion.com.

Large PDFs and Spreadsheets Slowing You Down? See What’s New in Syncfusion 2026 Volume 1

Jollen Moyani — Tue, 17 Mar 2026 14:01:37 +0000

TL;DR: The Syncfusion 2026 Volume 1 release brings major performance and usability upgrades to the PDF Viewer, DOCX Editor, and Spreadsheet Editor SDKs. Key improvements include faster PDF page organization on the web; quicker Blazor text search; zoom persistence and custom stamp access in .NET MAUI; discontinuous chart ranges in the Spreadsheet Editor; full dashed/dotted border preservation in the DOCX Editor, and more. New Visual Studio extensions also streamline Blazor development.

Working with large PDFs, complex spreadsheets, or heavily formatted Word documents can quickly become slow and frustrating. When page organization lags, search takes too long, or formatting gets lost, productivity drops across teams that rely on document-heavy workflows.

The Syncfusion 2026 Volume 1 release addresses these challenges with targeted performance and usability improvements across the PDF Viewer, DOCX Editor, and Spreadsheet Editor SDKs.

These updates deliver:

Faster PDF page organization on the web
Significantly improved text search performance in Blazor
Better usability in the .NET MAUI PDF Viewer
More flexible charting in the Spreadsheet Editor
Accurate border style preservation in the DOCX Editor

The result is a smoother and more reliable editing experience across Web, Blazor, and .NET MAUI applications.

Let’s explore these improvements in detail

PDF Viewer SDK

The PDF Viewer SDK receives several high-impact improvements across Web, Blazor, and .NET MAUI platforms. These updates focus on performance, usability, and workflow efficiency.

Web PDF Viewer: Faster page organization for large documents

Industries that work with large PDFs often experience slowdowns when organizing pages.

For example:

Legal teams reviewing lengthy contracts
Engineering teams managing technical manuals
Finance departments working with large consolidated reports

As documents grow in size, opening the Organize Pages window can become slow or unresponsive, making page reordering or deletion tedious.

The Syncfusion Web PDF Viewer now opens and closes the Organize Pages window significantly faster, even when working with very large documents. These improvements eliminate UI lag and temporary freezes, giving users a smoother and more responsive page-management experience.

The following table shows the improvement in opening and closing times:

Document size	Opening improvement	Closing improvement
500 pages	51.3%	93.8%
1,000 pages	62.3%	93.2%
5,000 pages	85.7%	Fully responsive
10,000 pages	76.2%	Fully responsive

Blazor PDF Viewer: Performance improvements in text search

Fast and accurate text search is essential in many industries that handle large PDFs, including:

Legal teams navigating case files.
Research organizations analyze lengthy technical reports.
Engineering teams reviewing extensive specifications.

In these workflows, slow or inconsistent search performance can disrupt productivity, delay decision‑making, and make it difficult for users to quickly locate critical information across hundreds or even thousands of pages.

To ensure a smoother and more dependable search experience, the Syncfusion Blazor PDF Viewer now delivers significantly faster, more reliable text search, thanks to targeted engine optimizations and refined indexing. You can now locate words and phrases far more quickly and with consistent accuracy, even when working with very large PDF files.

The following metrics show reduced search times for documents of different sizes.

Document size	Performance improvement (%)
60 pages	95.4%
114 pages	95.8%
500 pages	97.1%
1,000 pages	96.8%
5,000 pages	94.3%

.NET MAUI PDF Viewer improvements

The .NET MAUI PDF Viewer also introduces several usability improvements that make document navigation easier on mobile and tablet devices.

Maintain zoom level in single-page view

Field teams often review large documents on tablets, including:

Construction inspection reports
Clinical documentation
Engineering diagrams

Constantly re-zooming when switching pages can slow down review workflows.

The .NET MAUI PDF Viewer now preserves the zoom level while navigating between pages in single-page view mode.

Once you set your preferred zoom level, it stays consistent across the entire document, allowing users to read detailed diagrams or text without repeated adjustments.

Refer to the following images.

Before enabling Zoom persistence:

After enabling Zoom persistence:

Access custom stamp annotation views

Many industries rely on status stamps such as Approved, Rejected, and Pending during document reviews. These are commonly used in:

Manufacturing inspections
Compliance reviews
Legal approvals
Healthcare verification workflows

All these require updating the status stamps after review and extracting who‑did‑what information for audit reporting. Once applied, custom stamp annotations were difficult to modify or automate, slowing down bulk updates and downstream reporting.

The .NET MAUI PDF Viewer now allows you to retrieve and manage the visual elements of custom stamp annotations after placement, enabling dynamic updates during review and approval workflows.

You can now:

Access stamp properties
Modify stamp appearance
Extract stamp information for reporting

This makes approval workflows easier to automate and track.

Custom stamp annotation views in .NET MAUI PDF Viewer

Blazor Smart PDF Viewer

The Blazor Smart PDF Viewer has now reached production readiness and includes several AI-powered capabilities.

These include:

Document summarizer: Provides AI-generated summaries and answers to user queries, enabling quick understanding of document content.
Smart redaction: Automatically detects and redacts sensitive information, ensuring accurate and secure content protection.
Smart fill: Automatically identifies and fills PDF form fields using AI, minimizing manual input and speeding up form completion.

Spreadsheet Editor SDK

The Spreadsheet Editor SDK also receives major improvements across Web and Blazor platforms.

Web Spreadsheet Editor improvements

Discontinuous chart range support

Teams in finance, research, project management, academics, and inventory operations often need to compare data series that live in completely different parts of a worksheet.

For example :

Revenue and expense metrics may sit in separate columns,
Regional performance data may be stored in different sections,
Project phase metrics may be spread across multiple tables, and
Experiment/control datasets may exist far apart due to differing collection workflows.

Until now, creating a comparison chart required copying data into a single block, building multiple charts, or restructuring worksheets, all of which break live data flow and add maintenance overhead.

With the new discontinuous chart range support in the Syncfusion web Spreadsheet Editor, you can create a single chart from multiple nonadjacent rows, columns, or cell blocks. Each selection becomes its own series; charts stay live and are linked to the source data.

The supported major chart types are:

Column
Bar
Area
Pie
Donut
Line
Scatter

We can use Ctrl (Windows/Linux) or Cmd (Mac) keys to select multiple ranges.

Read the full article on Syncfusion’s official website.

Turn Static Word Docs into Interactive Forms: Create and Manage DOCX Form Fields in ASP.NET Core

Jollen Moyani — Wed, 04 Mar 2026 14:05:32 +0000

TL;DR: DOCX can do far more than store text. Turn plain Word files into interactive, fillable forms by inserting, updating, exporting, resetting, and protecting form fields in ASP.NET Core using Syncfusion’s UI and APIs.

What if your Word documents could collect data like a web form? They can, transforming ordinary documents into interactive tools.

DOCX form fields turn static documents into dynamic templates that users can fill out effortlessly. Whether you’re creating contracts, onboarding forms, surveys, or business workflows, they provide structure, consistency, and a smoother user experience.

For developers, the ability to manage DOCX form fields programmatically unlocks even bigger advantages:

Automating repetitive document tasks.
Generating and prefilling templates from external data sources.
Maintaining accuracy and compliance in business‑critical forms ( legal, HR, finance ).

In this tutorial, we’ll learn how to insert, update, import, export, reset, and protect DOCX form fields in ASP.NET Core using the Syncfusion DOCX Editor.

What are DOCX form fields?

DOCX form fields are interactive elements embedded directly inside a Word document. They allow users to enter data directly within the file, turning a simple document into a structured, fillable form. When you design templates with form fields, you can ensure consistent, organized data collection, which is especially useful in workflows where accuracy and uniformity are essential.

These interactive fields fit naturally into many real-world scenarios, including:

Onboarding forms and HR templates.
Sales contracts and legal agreements.
Surveys, questionnaires, and checklists.

To support these workflows, DOCX files allow several types of form fields, each serving a different purpose:

Text: Free-form input used for names, addresses, and notes.
Checkbox: Binary selections such as Yes/No or True/False.
Dropdown: Predefined options like departments, categories, or status values.

Together, these field types make DOCX templates more dynamic and help streamline both data entry and document automation.

Managing form fields with Syncfusion DOCX Editor

The Syncfusion DOCX Editor is built to simplify and streamline form field management, offering an intuitive interface for efficient document editing.

It provides:

Built-in toolbar for quickly adding interactive fields.
Properties pane for customizing their attributes, such as names, default values, and formatting, without writing extra code.

This integrated UI supports all essential form field types.

Creating form fields with Syncfusion DOCX Editor

Let’s explore both UI-based tools and API-driven methods to build fully interactive, automated document workflows with minimal effort.

Getting started with DOCX Editor in ASP.NET Core

To get started, we’ll need to set up the Syncfusion DOCX Editor in our ASP.NET Core application. The steps below guide us through the initial configuration.

Step 1: Create a .NET Core web app

Begin by using Visual Studio to create a new ASP.NET Core project with Razor pages.

Step 2: Install the NuGet package

Next, install the Syncfusion.EJ2.AspNet.Core NuGet package to your project using the NuGet Package Manager or the following command.

BASH

Install-Package Syncfusion.EJ2.AspNet.Core -Version 32.1.19

Step 3: Add Syncfusion tag helper

After installing the package, open the ViewImports.cshtml file and add the following line to enable the Syncfusion tag helper.

BASH

@addTagHelper *, Syncfusion.EJ2

Step 4: Include the required styles and scripts

To ensure proper rendering, add the Syncfusion CSS and JavaScript CDN links inside your _Layout.cshtmlfile.

XAML

<head>
    ...
    <!-- Syncfusion ASP.NET Core controls styles -->
    <link rel="stylesheet" href="https://cdn.syncfusion.com/ej2/32.1.19/fluent.css" />
    <!-- Syncfusion ASP.NET Core controls scripts -->
    <script src="https://cdn.syncfusion.com/ej2/32.1.19/dist/ej2.min.js"></script>
</head>

Step 5: Register Script Manager

Before closing the <body> tag, include the Syncfusion Script Manager to ensure proper component initialization.

XAML

<body>
    ...
    <!-- Syncfusion ASP.NET Core Script Manager -->
    <ejs-scripts></ejs-scripts>
</body>

Step 6: Add Syncfusion DOCX Editor in ASP.NET Core app

Finally, add the DOCX Editor to the Index.cshtml file.

XAML

<ejs-documenteditorcontainer id="container"></ejs-documenteditorcontainer>

This renders the full editor with its default toolbar and environment.

Once these steps are complete, your Syncfusion DOCX Editor is fully configured and ready to start working with DOCX form fields, as shown below.

Creating an ASP.NET Core app with Syncfusion DOCX Editor

Manage form fields in DOCX files

Working with form fields in DOCX files is not just about reading values; it’s about creating dynamic, interactive documents. With the Syncfusion Document Editor, you can insert new form fields, update their properties, reset them, and even protect the document, so users can only edit designated fields.

Below is a quick overview of the key operations you can perform.

Insert form fields

Form fields make it easy to build interactive documents such as feedback forms, contracts, and questionnaires. They ensure users enter structured responses digitally, protect legal text, and make surveys interactive and easy to analyze programmatically.

Insert form fields via UI

We can insert form fields by selecting form fields from the built-in toolbar and choosing the desired field type, such as text, checkbox, or dropdown.

Creating form fields using the built-in toolbar in the DOCX Editor

Note: Explore our live demo and start adding form fields effortlessly!

Insert form fields programmatically

We can also generate form fields dynamically using the insertFormField API. This is ideal for generating interactive documents that require fields to be inserted on demand.

Just a few lines of code are all it takes:

JavaScript

//Insert Text form field
documentEditor.editor.insertFormField('Text');

//Insert Checkbox form field
documentEditor.editor.insertFormField('CheckBox');

//Insert Drop down form field
documentEditor.editor.insertFormField('Dropdown');

Get form field names and properties

Validating form fields before submission is essential for accuracy, consistency, and compliance. Retrieving field names and properties helps ensure all required fields are present, enables dynamic customization based on user roles or conditions, and supports auditing and reporting for compliance purposes.

We can retrieve all form field names and fetch detailed properties using the getFormFieldNames and getFormFieldInfo APIs.

JavaScript

// Get all form field names
var formFieldsNames = documentEditor.getFormFieldNames();

//Text form field
var textfieldInfo = documentEditor.getFormFieldInfo('Text1');

Update form field properties

Updating form field properties is essential for creating accurate and user-friendly documents. This feature allows you to pre-fill forms, enforce input formats, and maintain data consistency, commonly used in HR onboarding, tax forms, and compliance-driven templates.

Update via UI

You can update form field values directly using the built-in toolbar and properties pane in the editor.

Updating form fields via the built-in toolbar in DOCX Editor

Note: Try it yourself in our live demo and see how quickly you can update form fields without writing any code!

Update programmatically

Use the setFormFieldInfo API to dynamically update properties:

JavaScript

// Set text form field properties
var textfieldInfo = documentEditor.getFormFieldInfo('Text1');
textfieldInfo.defaultValue = "Hello";
textfieldInfo.format = "Uppercase";
textfieldInfo.type = "Text";
documentEditor.setFormFieldInfo('Text1', textfieldInfo);

Reset form fields

Resetting form fields is useful when users need to start over, such as re-filling a form on a shared device. It prevents accidental reuse of previous responses and ensures clean data collection. It is ideal for surveys, questionnaires, and repeated forms of submissions.

You can reset all form fields to their default values using the resetFormFields API:

JavaScript

documentEditor.resetFormFields();

Import and export form field data of DOCX files

Exporting and importing form fields data makes it easy to reuse information across documents. This feature helps you save user input, generate reports, or create pre-filled forms to speed up workflows.

You can export all form field values from the loaded document using the exportFormData method. Similarly, you can prefill form fields by importing data with the importFormData method.

Here’s how you can export form field data from the DOCX files with Syncfusion DOCX Editor:

JavaScript

var formFieldDate = documentEditor.exportFormData();

And here’s how you can import the saved data back into the DOCX files with Syncfusion:

JavaScript

var textformField = { fieldName: 'Text1', value: 'Hello World' };
var checkformField = { fieldName: 'Check1', value: true };
var dropdownformField = { fieldName: 'Drop1', value: 1 };

// Import form field data
documentEditor.importFormData([
    textformField,
    checkformField,
    dropdownformField
]);

Note: For more details about importing and exporting form fields, read the full documentation.

Protect the document for form filling

Enable protection so that users can only fill out form fields while the rest of the document remains read-only. We can use this feature for legal documents, contracts, templates, and any scenario where the primary text must stay unchanged.

Enable protection via UI

To enable protection using the built-in interface:

Go to the Review tab.
Select Restrict Editing from the toolbar.
Choose the option to allow editing only in form fields.

This ensures that users can interact with designated fields while preventing modifications to the rest of the document.

Enabling only form-filling mode in a Word document using the DOCX Editor

Enable protection programmatically

You can also control document protection through code. Use enforceProtection to enable form-filling-only mode, and stopProtection to remove existing protection.

JavaScript

var documenteditorElement = document.getElementById('container');
container = documenteditorElement.ej2_instances[0];
documenteditor = container.documentEditor;

// Enable protection for form fields only
container.documentEditor.editor.enforceProtection('123', 'FormFieldsOnly');

// Stop the document protection
container.documentEditor.editor.stopProtection('123');

Frequently Asked Questions

1. Can a DOCX file use form fields?

Yes. DOCX supports text, checkbox, and dropdown fields for interactive documents.

Can I update or reset fields?

Yes. Use the setFormFieldInfo method to update properties and resetFormFields() to clear values.

2. What types of form fields are supported?

The DOCX file supports a variety of form fields, including text fields for general text entry, numbers, and dates, checkbox fields for binary selections, and dropdown fields that allow users to choose from a predefined list of strings.

3. Does the Syncfusion editor support form fields?

Yes, the Docx Editor supports legacy form fields (text, checkbox, and dropdown lists) to create fillable forms. It also supports content controls.

4. Can I create form fields using the UI?

Yes, the Document Editor control provides an intuitive UI for inserting and managing form fields through its toolbar.

5. How can I retrieve form field data?

You can get all field names using getFormFieldNames() and retrieve specific properties (like default values, formats, or type ) using getFormFieldInfo('FieldName'). Data can also be programmatically exported from the entire document.

6. How do I protect the document so that only form fields are editable?

The document can be protected using the “Restrict Editing” feature, which locks the document layout while allowing users to fill in form fields.

Conclusion

Thank you for reading! Managing form fields in DOCX files offers powerful advantages for web applications, enabling interactive documents, streamlined data collection, and fully automated workflows. With the Syncfusion DOCX Editor, developers can effortlessly insert, customize, and manage form fields, and import or export their data to support dynamic templates and system integrations. These capabilities significantly reduce manual effort and make it easier to build fast, efficient, and user‑friendly document solutions.

If you’re an existing customer, the latest version is available on the License and Downloads page. New to Syncfusion? Try our 30-day free trial and experience all the newest features firsthand.

We’re here to support you every step of the way! Reach out through our support forums, support portal, or feedback portal. We’re always happy to assist.

Building a 10 Faster, Cloud-Ready Document Pipeline Without Office or Adobe

Jollen Moyani — Wed, 25 Feb 2026 13:42:58 +0000

TL;DR: Traditional document automation built on Microsoft Office Interop and Adobe dependencies often fails in server and cloud environments due to instability, threading issues, and platform limitations. By switching to server-safe, managed .NET document libraries, we built a cloud-ready pipeline that renders, converts, and processes documents up to 10× faster, without crashes, unpredictable behavior, or OS-level dependencies.

The moment our document pipeline started crashing

When routine document tasks started taking minutes instead of seconds, and our automated workflows began failing at the worst possible moments, we knew something was seriously wrong.

As we scaled, relying on Adobe and Microsoft Office became a bottleneck we could no longer ignore. These tools were built for desktops, not the cloud. And once Docker, Linux, and Kubernetes entered the picture, the cracks widened fast: random crashes, slow rendering, mysterious file locks, broken conversions… everything was becoming unpredictable.

That’s when we shifted to a new category of technology: server‑safe, code‑first document SDKs.

And the solution that transformed our entire workflow? Syncfusion Document Processing SDK. It offers consistent processing, seamless scaling, and reliability for automation. Our pipeline now delivers consistent speed across OSes and workloads.

Why Adobe & Office broke our automated pipelines

As our automation footprint grew, so did the cracks. The more we scaled, the more Adobe and Microsoft Office exposed their limits. Here’s what we found when we tried to run them inside modern server environments:

Not built for server-side execution: Both Adobe and Office were designed for interactive desktop use, not for background automation. When forced into server roles, they frequently hang, stall, or fail unpredictably.
Slow, resource-intensive rendering: Document rendering consumes excessive CPU and memory. Under real-world load, these apps become bottlenecks, slowing jobs down and dragging entire pipelines to a crawl.
Unpredictable automation failures: We constantly encountered COM exceptions, random crashes, and mysterious file locks. Even minor tasks felt like rolling the dice every time the script ran.
Not suitable for Docker, Linux, or Kubernetes: Modern infrastructure demands portability, but these tools require full desktop environments. Containers reject them outright, making cloud deployment nearly impossible.
Complex, expensive licensing at scale: Licensing for Adobe and Office gets complicated and costly very quickly. Every additional server, instance, or workflow adds both expense and compliance overhead.

The deeper we went, the clearer it became: using Adobe and Office in automated pipelines injects fragility where you need reliability. These issues aren’t rare edge cases; they’re systemic. And they’re exactly what Syncfusion’s Document SDK was built to solve with a server-safe, code-first approach purpose-built for modern automation.

What we needed: A cloud‑ready, failure‑proof document pipeline

After understanding where our old system failed, we mapped out exactly what a modern document pipeline should look like. Every goal is focused on building a solution that stays reliable, scalable, and cloud-friendly from day one.

100% server-safe: We wanted a pipeline that runs entirely in headless environments, with no UI dependencies. No more desktop apps pretending to be server tools, just clean, predictable execution.
No external installations: The new system shouldn’t rely on Adobe, Office, or any third-party apps installed on machines. Everything needed to run directly within our codebase and deployment environment.
Fast, multi-threaded, scalable: Speed had to be a core requirement, not an afterthought. The redesigned workflow needed to support parallel tasks and handle spikes in document volume without choking.
Consistent rendering across environments: A document generated on one server should look identical everywhere else. We aimed for stable, deterministic rendering across Windows, Linux, containers, and cloud clusters.
Built entirely on .NET: To streamline development and maintenance, we chose to unify everything under .NET. This allowed us to leverage familiar tooling, strong performance, and clean integration with our existing services.

Why Syncfusion Document SDK became the clear winner

Throughout our evaluation of leading document SDKs, Syncfusion proved to be the clear choice, offering robust PDF, Word, Excel, and PowerPoint libraries that have matured over 20 years of continuous development. It satisfied all the architectural requirements we had defined and resolved several underlying issues we hadn’t identified until we dug deeper.

Full document creation without Adobe/Office: Syncfusion lets us generate PDFs, Word files, Excel sheets, and PowerPoint entirely through code. We no longer depend on heavyweight desktop apps or background installations.
Cross-platform support: The libraries run flawlessly on Windows, Linux, Docker, and Kubernetes. This gave us the freedom to deploy anywhere without worrying about OS-level restrictions.
High-performance rendering engine: Documents now render faster and more consistently, even under heavy load. Its optimized engine handles complex layouts without draining server resources.
Flexible conversion workflows: Whether it’s DOCX to PDF , HTML to PDF , or Excel to CSV , everything happens inside a clean .NET workflow. We automated conversions that were previously unreliable or impossible.
Unified licensing model: Instead of paying per seat or per server, we benefit from a single, predictable license. Unlike Adobe or Office, there are no hidden automation fees or usage-based charges.

Rebuilding our document processing pipeline with Syncfusion

Migrating the document pipeline to Syncfusion allowed us to redesign our workflow with performance and stability at the forefront. As a result, Syncfusion delivered faster processing, cleaner rendering, and more predictable automation, while eliminating the desktop-bound dependencies that limited our previous setup.

Moreover, the Syncfusion Document SDK AI Coding Assistant MCP Server further strengthens this workflow by providing intelligent, context-aware code suggestions for PDF , Word , Excel , and PowerPoint development. It streamlines implementation by generating accurate, library-specific guidance and examples, reducing the need for manual documentation lookup. This results in faster development, fewer integration issues, and a more efficient document automation pipeline overall.

PDF automation: Faster, cleaner, more reliable

Syncfusion PDF Library transforms how our pipeline generates, processes, and optimizes PDFs. It gave us a stable, API-driven system that handles complex operations with precision, without relying on external tools or desktop automation.

Unified PDF manipulation (Merge/Split/Stamp/Encrypt): All common PDF operations now run through a single, reliable engine. We can combine, split, watermark, and secure documents programmatically with minimal code.
Compliance-ready signatures and forms: The library supports digital signatures, form filling, validation, and PDF/A generation out of the box. This helped us automate secure and compliance-driven workflows with zero external plugins.
High-performance rendering engine: Syncfusion processes PDFs faster while using significantly less memory. This optimization keeps our pipeline stable under load and improves throughput across high-volume operations.
Advanced HTML-to-PDF rendering: Syncfusion converts modern web pages into pixel-perfect PDFs with full CSS and JavaScript execution. Charts, animations, and responsive layouts render exactly as they appear in the browser.

Want to dive deeper into how these PDF features work? Check out the live demos, explore real examples, and review the full technical overview to see everything in action.

Key automation features of .NET PDF Library

Word automation: High‑volume DOCX at scale

Syncfusion .NET Word Library allows us to rebuild our Word generation pipeline with far greater precision and performance. It handles complex layouts, large datasets, and high-volume document generation without the instability of Office automation.

Complex DOCX composition (Fields, images, tables): The Word library dynamically constructs DOCX files with structured fields, embedded images, nested tables, and rich formatting. It reliably processes complex layouts, even as templates grow in size or complexity.
High-throughput mail merge engine: Syncfusion Mail Merge handles thousands of records per second with minimal overhead, making it ideal for real-time scenarios such as bulk invoice, report, or contract generation, or personalized document delivery at scale. It maps data fields, generates personalized documents, and scales horizontally without blocking threads.
Accurate rendering with faster processing at scale: It consistently renders documents the same way across different environments and servers. Its optimized processing pipeline reduces CPU usage and accelerates bulk operations, making large-scale automation far more stable.
Multiformat conversion (DOCX → PDF/HTML/Text/MD/Images/RTF): The conversion engine converts DOCX files into PDF, HTML, Markdown, images, plain text, or RTF with high fidelity, preserving layout, styles, and media-rich content, without requiring Microsoft Word.

Looking to implement these Word features in your own workflow? Start with the live demo, then dive into the DocIO docs and example code to see how to bring it all together.

Key automation features of .NET Word Library

Excel automation: Full spreadsheet generation without Excel

Syncfusion Excel Library enables us to build a fully automated Excel pipeline without relying on Microsoft Excel. It generates, formats, calculates, and converts spreadsheets across any server environment with consistent output and high performance.

Environment-independent XLSX generation: Syncfusion creates native XLSX files through pure .NET APIs, no Excel installation required. This makes our automation fully compatible with Windows, Linux, Docker, and Kubernetes.
Automated financial sheets with formulas and styles: We generate complex financial models with formulas, conditional formatting, cell styles, and dynamic ranges. The engine calculates values accurately, making it ideal for reports, audits, and analytics workflows.
Data-driven charts and pivot tables: The library builds charts and pivot tables directly from live data sources. Our dashboards update automatically, producing clear visual summaries without any manual post-processing.
Excel-to-PDF conversion with layout accuracy: Syncfusion converts spreadsheets into high-fidelity PDFs while preserving styles, grids, fonts, and page layout. This gave us a seamless way to produce polished reports directly from raw Excel data.

Want to see these Excel automation features in action? Try the live demo, browse the XlsIO documentation, and explore the GitHub examples to understand how easily you can generate and manipulate Excel files programmatically.

Key automation features of .NET Excel Library

PowerPoint automation: Fully automated presentations

Syncfusion PowerPoint Library lets us automate end-to-end presentation workflows without opening PowerPoint. We now create, populate, standardize, and export decks programmatically across any environment with consistent results.

Autogenerated recurring presentations: We schedule and build recurring decks (weekly reports, monthly metrics, QBRs) through .NET APIs. The pipeline assembles slides from live data, ensuring every run uses the latest numbers.
Data-bound slides with visuals and branding: Slides automatically populate with charts, images, icons, and brand-consistent themes. We enforce fonts, palettes, and layouts so every presentation matches our design system.
Template reuse and smart slide editing: The engine loads existing PPTX templates, clones slides, and replaces placeholders with dynamic content. We modify shapes, text boxes, tables, and charts in place, with no manual tweaking.
Multiformat export (PPTX → PDF/Images): We export final decks to PDF or per-slide images for sharing and archiving. The output preserves layout fidelity, making distribution simple across email, portals, and slide libraries.

Discover how simple automated presentations can be, check out the live demo, and the quick-start guide to get a closer look.

Key automation features of PowerPoint Library

Want a no‑code setup instead?

If you don’t want to spend time setting up servers, writing backend code, or configuring libraries, Syncfusion’s ready-to-deploy Document Processing Web APIs allow you to automate document processing workflows quickly and effortlessly. No extra license is required, as your existing Document SDK license already includes full access to these Web APIs. For more details, check out the documentation.

The final outcome: A faster, cheaper, office-free document workflow

Rebuilding our document pipeline with Syncfusion transformed daily operations, tasks that once felt fragile now run consistently fast and reliably across all environments.

What began as a fix for recurring Adobe/Office bottlenecks turned into a long‑term upgrade for the entire platform.

Key improvements

Faster performance
- Rendering time dropped dramatically.
- Tasks that took minutes now finish in seconds.
- AI Coding Assistant speeds up complex document operations.
Lower operational costs
- No Adobe/Office installations or licensing overhead.
- Reduced CPU and memory usage.
- Lightweight Web API Docker images make scaling cost‑efficient.
Greater stability at scale
- No more COM errors, file locks, or random crashes.
- High‑volume processing runs smoothly.
- Parallel jobs stay consistent across distributed systems.
Stronger security & compliance
- Fewer attack surfaces thanks to removing desktop apps.
- Built‑in encryption, compliance formats, and safe rendering.
- Self‑hosted Web API Docker images ensure full policy control.
Higher developer productivity
- Fewer automation issues to troubleshoot.
- Easier to maintain, purely .NET‑based pipeline.
- AI Coding Assistant reduces repetitive coding.
Ready for future growth
- Scales effortlessly across Windows, Linux, Docker, and Kubernetes.
- Stable foundation for adding new formats and workloads.
- Designed for long‑term cloud‑native expansion.

Frequently Asked Questions

Will migration to Syncfusion Document SDK require rewriting all my templates?

Not necessarily. Most templates ( DOCX , XLSX , PPTX , HTML , PDF ) can be reused as-is. Syncfusion’s libraries support fields, bookmarks, placeholders, mail merge, structured editing, and template-based document generation without requiring major layout changes.

Are Syncfusion Document SDKs secure enough for regulated industries?

Yes. The SDKs provide built-in support for encryption, redaction, digital signatures, secure PDF/A, form security, and isolated execution without external applications. These features align well with compliance requirements in finance, healthcare, legal, and government workflows.

Does migrating to Syncfusion Document SDK improve long-term maintainability and CI/CD stability?

Yes. Migrating eliminates fragile COM automation, reduces breakages caused by desktop updates, and removes dependencies on Office installations. With a pure .NET codebase, build pipelines become easier to maintain and more predictable, improving long-term stability and reducing technical hurdles.

Do Syncfusion Document SDKs provide advanced formatting or rendering quality?

Yes. Syncfusion Document SDKs include independent, high-fidelity rendering engines for PDF , Word , Excel , and PowerPoint. They ensure consistent, accurate output across environments and are designed to match or exceed desktop application rendering, even for complex layouts, without requiring Adobe or Office.

Do Syncfusion SDKs use a lot of CPU or memory?

No. Syncfusion libraries are optimized for multi-threaded processing, lazy loading, and high-volume workloads. They run purely in code without UI components, resulting in lower CPU and memory usage.

Can SDK-based workflows create dynamic, data-driven documents?

Yes. You can easily generate documents from database values, making it simple to create invoices, reports, dashboards, mail-merged files, and other dynamically populated documents.

Ready to transform your document pipeline?

Thank you for taking the time to follow our journey. For us, the Syncfusion Document Processing SDK has become the most reliable and future‑ready foundation for modern document automation, especially when traditional Adobe/Office‑based workflows could no longer keep up.

If your document pipeline is running into the same limitations we faced, you don’t have to keep patching temporary fixes. Switching to Syncfusion gave us:

A noticeably faster pipeline
Predictable, stable automation across environments
Lower operational costs without desktop dependencies
A cleaner, maintainable architecture
And a future‑proof platform built for cloud scale

Existing customers can download the latest version directly from their license and downloads page. New users can explore everything with a free 30-day trial and experience the full capabilities firsthand.

If you ever need help getting started or want guidance on your workflow, our team is here for you through the support forum, support portal, or feedback portal. We’re always happy to assist!

Automating PDF Workflows in C#: Merge, Split, Convert, and Secure Documents

Jollen Moyani — Mon, 23 Feb 2026 09:57:35 +0000

TL;DR: The fastest way to automate PDFs

Syncfusion .NET PDF Library lets developers merge, split, convert, and secure PDFs in minutes with clean C# APIs, no heavy setup, and no external dependencies. Prefer zero backend work? Their ready‑to‑deploy Docker‑based Document Processing Web APIs give you instant PDF automation through simple REST endpoints. From conversions to enterprise‑grade security, Syncfusion delivers a fast, scalable, end‑to‑end document workflow solution.

PDF automation is no longer optional: It’s essential

Modern applications rely on fast, reliable, and fully automated document workflows. Whether you’re generating invoices, processing forms, or producing reports, businesses expect these tasks to run seamlessly in the background, with no manual steps, no delays. As organizations move beyond traditional, manual PDF handling, automation has become essential. It minimizes human error, accelerates internal operations, and ensures documents are processed consistently and accurately at scale.

But developers often lose critical time wrestling with infrastructure instead of building features. That’s where Syncfusion^® changes the game.

Get a complete PDF workflow in 20 minutes

Syncfusion .NET PDF Library makes this possible with straightforward APIs, true cross‑platform support, and high‑performance components designed for real‑world business needs.

Not familiar with .NET? No problem. Syncfusion also provides a ready‑to‑deploy Docker image for its Document Processing Web APIs, enabling you to launch PDF-automation services without configuring servers or managing runtime environments. With Docker, you benefit from simple deployment, easy scaling, and a consistent environment across platforms. With zero configuration, you gain instant access to essential PDF operations, including:

Merge
Split
Compress
Rotate
Protect

Plus full Office‑to‑PDF conversion, all through simple HTTP endpoints.

For enterprise teams seeking PDF automation with minimal setup and complexity, the Syncfusion Document Processing Web APIs provide a streamlined pathway to deployment, accelerating time-to-value.

The real problem: Merging, splitting, converting & securing PDFs takes way too long

While PDF management may appear straightforward, most traditional approaches introduce unnecessary complexity for development teams. Time spent on environment preparation delays feature delivery, increases project overhead, and ultimately affects business outcomes. Common enterprise challenges include:

Performance issues: Large PDFs or batch operations often slow down or fail unexpectedly.
Inconsistent accuracy: Text extraction, formatting, or layout detection often produces incorrect or unpredictable results.
High resource usage: Memory and CPU consumption spike during heavy PDF processing, affecting overall app performance.
Lack of a unified workflow: Developers must combine multiple tools just to merge, split, convert, and secure documents.

With these constraints, delivering consistent and scalable PDF automation becomes resource-intensive, an inefficiency modern organizations cannot afford in a competitive market.

Syncfusion .NET PDF Library: Your all‑in‑one PDF power tool

Syncfusion .NET PDF Libraryremoves operational complexity by providing the speed, reliability, and flexibility required for enterprise document workflows. Programmatic PDF operations from generation to conversion enable teams to rapidly deliver business outcomes. This solution stands out because:

Lightweight and dependency-free: Ready to use without requiring any external components.
Cross-platform support: Runs seamlessly on Windows , Linux , macOS , Docker , Azure Functions , and AWS Lambda.
Scales effortlessly: Suitable for small apps all the way up to enterprise-grade workloads.

This methodology reduces complexity across the workflow, enabling enterprises to implement scalable, reliable PDF automation aligned with operational goals.

Looking beyond document processing, what if you need interactive PDF capabilities?

Syncfusion offers a powerful PDF Viewer SDK that allows you to view, annotate, select, organize, and design forms directly in your apps. The PDF Viewer SDK requires a separate license, which doesn’t include document processing libraries. This makes it easy to choose only the viewing capabilities you need while keeping your PDF workflow flexible.

Note: Want to see it in action? Try out our PDF Viewer SDK live demo.

Setting up: What you need before you start

Before you try any PDF operations, you’ll need to install the required Syncfusion NuGet packages. This ensures your project has everything it needs to work with the .NET PDF Library. Use the following command to add it to your project:

BASH

dotnet add package Syncfusion.Pdf.Net.Core

Note: Looking for more details on PDF Creation? Explore the full user guide on how to create or generate a PDF file in C# and VB.NET.

Merge PDFs with a few lines of code

Merging documents is a common requirement across many domains, such as combining invoices, assembling contract bundles, or grouping analysis reports. With Syncfusion PDF Library, merging PDFs is extremely straightforward, and these capabilities make it truly simple to use:

Clean and intuitive APIs: Simple method calls like PdfDocumentBase.Merge() handles merging without extra steps.
No external dependencies: Works out of the box, no plug‑ins, no special system requirements.
Fast and optimized processing: Built to handle large files and batches efficiently.
Consistent output: Ensures reliable results across platforms without manual adjustments.

Here’s how simple the merging process looks in code:

using (PdfDocument finalDocument = new PdfDocument())
{
    // Get the stream from existing PDF documents 
    using (FileStream firstStream = new FileStream("data/file1.pdf", FileMode.Open, FileAccess.Read))
    using (FileStream secondStream = new FileStream("data/file2.pdf", FileMode.Open, FileAccess.Read))
    {
        // Create a stream array for merging 
        Stream[] streams = { firstStream, secondStream };

        // Merge PDF documents 
        PdfDocumentBase.Merge(finalDocument, streams);

        // Save the document 
        finalDocument.Save("Output.pdf");
    }
}

This merges documents in seconds, no temporary files, no complex pipelines.

Merging PDFs using .NET PDF Library

Split PDFs into multiple files

Large PDFs often need to be split for indexing, archiving, or use in cloud‑based systems, and our .NET PDF Library makes this process incredibly simple by allowing developers to extract exactly the pages they need with minimal code and zero configuration.

Here’s how it makes PDF splitting easy and efficient:

Select specific pages or page ranges using clean, intuitive APIs.
Handle large documents with optimized performance, even during batch operations.
Generate separate PDFs instantly, without complex logic or external tools.

Below is the code snippet for extracting a single page:

// Load the PDF document
PdfLoadedDocument loadedDocument = new PdfLoadedDocument("PDF_Succinctly.pdf");

// Create new PDF document
PdfDocument document = new PdfDocument();

// Import the particular page from the existing PDF
document.ImportPage(loadedDocument, 8);

// Save the new PDF document
document.Save("PDF_Succinctly8.pdf");

// Close the PDF documents
document.Close(true);
loadedDocument.Close(true);

Refer to the following image.

Extracting a single page from a PDF

Instead of extracting a single page, we can also split the document by selecting a page range, as shown below:

// Create the page range values.
int[,] values = new int[,] { { 1, 5 }, { 3, 9 } };

// Load the PDF document
PdfLoadedDocument loadedDocument = new PdfLoadedDocument("../../../../Data/PDF_Succinctly.pdf");

// Split the pages into fixed number
loadedDocument.SplitByRanges("Output-{0}.pdf", values);

// Close the PDF document
loadedDocument.Close(true);

See the image below for clarification.

Extracting a range of pages into a separate PDF

Convert Word/Excel/HTML/Image files to PDF perfectly

Syncfusion .NET PDF Library makes PDF conversion effortless and dependable. Whether you’re working with Word, Excel, HTML, or images, the library ensures high accuracy and layout fidelity across all document formats.

Let’s see how to convert Word to PDF, images to PDF, and HTML to PDF using our .NET libraries.

Convert Word to PDF (DOCX to PDF)

Syncfusion .NET Word Library makes it easy to convert Word documents into clean, accurate PDFs without losing formatting or layout. This is especially useful for workflows that rely on document templates or automated report generation.

Here’s why converting Word to PDF with Syncfusion is valuable:

Preserves formatting and layout: Even with complex styles, tables, and headers/footers.
Delivers consistent output: Essential for automated document generation.
Handles large documents: Processes dynamic content without performance issues.
Produces professional PDFs: Ideal for reports, contracts, letters, and mail merge outputs.

Here’s the code to convert a Word document to PDF:

// Open the Word document file stream.
using (FileStream inputStream = new FileStream("Template.docx", FileMode.Open, FileAccess.Read))
{
    // Loads an existing Word document.
    using (WordDocument wordDocument = new WordDocument(inputStream, FormatType.Automatic))
    {
        // Creates an instance of DocIORenderer.
        using (DocIORenderer renderer = new DocIORenderer())
        {
            // Converts Word document into PDF document.
            using (PdfDocument pdfDocument = renderer.ConvertToPDF(wordDocument))
            {
                // Saves the PDF file to the file system.
                using (FileStream outputStream = new FileStream("Output.pdf", FileMode.Create, FileAccess.ReadWrite))
                {
                    pdfDocument.Save(outputStream);
                }
            }
        }
    }
}

The image that follows details this process.

Converting Word to PDF using .NET PDF Library

Convert HTML-to-PDF

The HTML-to-PDF converter transforms webpages and dynamic HTML content into accurate PDFs, preserving the original appearance. This is perfect for apps that generate invoices, receipts, or form submissions.

Here’s what makes our HTML to PDF conversion effective:

Preserves full layout fidelity: Including CSS, fonts, tables, and positioning.
Handles dynamic content: Supports JavaScript-rendered dashboards, forms, and templates.
Ensures pixel-perfect rendering: Ideal for branded or style-heavy documents.
Versatile export options: Perfect for web pages, invoices, tickets, certificates, and reports.

Use the following code snippet for HTML‑to‑PDF conversion:

// Initialize HTML to PDF converter.
HtmlToPdfConverter htmlConverter = new HtmlToPdfConverter();
BlinkConverterSettings blinkConverterSettings = new BlinkConverterSettings();

// Set Blink viewport size.
blinkConverterSettings.ViewPortSize = new Syncfusion.Drawing.Size(1280, 0);

// Assign Blink converter settings to HTML converter.
htmlConverter.ConverterSettings = blinkConverterSettings;

// Convert URL to PDF document.
PdfDocument document = htmlConverter.Convert("https://www.syncfusion.com");

// Create a filestream.
FileStream fileStream = new FileStream("HTML-to-PDF.pdf", FileMode.CreateNew, FileAccess.ReadWrite);

// Save and close the PDF document.
document.Save(fileStream);
document.Close(true);

Converting a HTML page to PDF using .NET PDF Library

Convert images to PDF

For scanning apps, mobile uploads, or workflows that handle photos as documents, our image-to-PDF conversion feature enables smooth and accurate conversion of images into high‑quality, standards‑compliant PDFs.

Here’s why image-to-PDF conversion with Syncfusion is valuable:

Preserves image quality: Maintains clarity and resolution without distortion or compression loss.
Supports multi-image conversion: Easily creates multi-page PDFs from multiple scans.
Automatic formatting: Handles scaling and alignment for clean, consistent output.
Versatile use cases: Perfect for scanned documents, ID proofs, receipts, and photo archiving.

Refer to the code snippet for image‑to‑PDF conversion:

// Your existing code starts here
ImageToPdfConverter imageToPdfConverter = new ImageToPdfConverter();
imageToPdfConverter.PageSize = PdfPageSize.A4;
imageToPdfConverter.ImagePosition = PdfImagePosition.TopLeftCornerOfPage;

using (FileStream imageStream = new FileStream(
    Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Data", "Autumn Leaves.jpg"),
    FileMode.Open, FileAccess.Read))
{
    using (PdfDocument pdfDocument = imageToPdfConverter.Convert(imageStream))
    {
        pdfDocument.Save(Path.Combine(
            AppDomain.CurrentDomain.BaseDirectory,
            "Output",
            "Output.pdf"));
    }
}

Review the image below for a visual overview.

Converting image to PDF using .NET PDF Library

Secure PDFs with enterprise‑grade features

The .NET PDF library delivers robust, enterprise-grade PDF security designed to protect sensitive data across industries. It includes reliable password protection to restrict access, precise permission controls to limit actions like printing or copying, and trusted digital signatures to verify authenticity and detect tampering. Together, these features ensure your PDFs remain secure, compliant, and safe for sharing in critical workflows.

Password protection

Our comprehensive PDF Library allows you to encrypt PDFs with user and owner passwords, preventing unauthorized access. User passwords restrict opening the document, while owner passwords control editing permissions.

Use the following code snippet to secure your PDF with password protection:

// Reading security settings of the document
PdfSecurity security = pdf.Security;

// Set the document's permission settings
security.UserPassword = "password123";
security.OwnerPassword = "adminaccess

See the accompanying image for more context.

Adding password protection to a PDF

Digital signatures

It also enables us to digitally sign PDFs with X.509 certificates, ensuring document authenticity, integrity, and non-repudiation. Digital signatures provide compliance with legal standards and create reliable audit trails for sensitive documents.

Use the following code snippet to digitally sign your PDF:

PdfSignature signature = new PdfSignature(pdf, page, certificate, "Signature");

Review the image below for a visual overview.

Adding digital signature to a PDF

Prefer JavaScript?

Syncfusion also offers the JavaScript PDF Library for secure, client‑side document processing with built‑in protection features and flexible browser‑based workflows.

Want to give it a try? Explore the JavaScript PDF Library live demo.

Tired of building from scratch? Try our ready‑to‑deploy Document Processing Web APIs

If you don’t want to spend time setting up servers, writing backend code, or configuring libraries, Syncfusion’s ready-to-deploy Document Processing Web APIs allow you to automate PDFs quickly and effortlessly. You can deploy the Docker image to your environment and instantly access powerful document features via simple REST endpoints.

Below are the things you get right away to deploy Document Processing Web APIs:

A ready‑to‑deploy Docker image packed with built‑in PDF APIs.
Ideal for quick deployment and fast PDF automation in any project without needing to be familiar with .NET.
Developer‑friendly with zero .NET learning curve.
Reduce infrastructure costs by deploying in your own cloud environment.
Enhanced security with your own cloud infrastructure.
Zero coding or backend setup required to start using it.
Support for merge, split, convert, compress, and secure operations.
Works with any frontend or backend via straightforward REST calls.

If you’re interested in hosting the ready‑to‑deploy Docker image for Syncfusion’s Document Processing Web APIs, refer to our Docker image hosting guide.

Frequently Asked Questions

Do I need a PDF viewer to perform PDF operations?

No. Syncfusion lets you merge, split, convert, and secure PDFs programmatically without any viewer component.

Which platforms support the PDF Library?

It runs seamlessly on Windows, Linux, macOS, Docker containers, Azure Functions, and AWS Lambda.

Can Syncfusion handle large or complex PDFs?

Yes. The library is optimized for performance. It can efficiently handle large documents and batch operations.

Is it possible to combine multiple operations in one workflow?

Absolutely, merge, split, convert, and secure operations can be chained effortlessly in a single pipeline.

How do I get started without writing backend code?

Use the ready‑to‑deploy Document Processing Web APIs, which expose PDF operations through simple REST endpoints.

Does the library maintain layout accuracy during conversions?

Yes. Conversions from Word, HTML, and images preserve fonts, formatting, tables, and visual structure.

Can I restrict actions like printing or copying while securing a PDF?

Yes. You can set a user password, an owner password, and fine‑tune specific permissions.

Does Syncfusion support multiple digital signatures?

Yes. You can apply multiple signatures, including sequential and certifying signatures, in one document.

Is Syncfusion suitable for enterprise workloads?

Definitely, the library is built for high performance, scalability, and reliable automation across enterprise systems.

Final thoughts: A complete PDF automation system in 20 minutes

Thank you for taking the time to read this blog. Building PDF workflows doesn’t have to take days, and Syncfusion proves it. With our .NET PDF library and ready‑to‑use APIs, we can move from setup to production in as little as 20 minutes. The platform is fast, stable, and built to handle real‑world document workloads.

Here are the key takeaways:

Supports complete PDF workflows, including creation, conversion, merging, splitting, and automation.
Provides enterprise‑grade security with password protection, permission controls, and digital signatures.
Offers high‑performance APIs optimized for modern apps and large‑scale processing.
Ensures consistent behavior across platforms, enabling seamless integration with any tech stack.

To get started, try the Syncfusion .NET PDF Library SDK to generate, modify, and automate PDFs effortlessly. If you’re a Syncfusion user, you can download the setup from the license and downloads page. Otherwise, you can download a free 30-day trial.

You can also contact us through our support forum, support portal, or feedback portal for queries. We are always happy to assist you!

.NET 11 Preview for .NET MAUI: Simplify XAML with Inline C# Expressions

Jollen Moyani — Fri, 20 Feb 2026 11:21:37 +0000

TL;DR: What if your MAUI UI logic didn’t need converters or extra ViewModel properties at all? .NET 11 preview C# expressions let you embed tiny, safe, strongly typed C# snippets directly in XAML, cleaning up formatting, UI only math, and conditionals with source generated speed. Still experimental, but perfect for demos and early exploration.

Why this .NET 11 Preview feature is blowing up in the MAUI community

Designing clean UI in .NET MAUI sounds easy, but formatting text, combining values, or doing simple UI calculations often forces us to:

Create one‑off converters,
Spin up extra ViewModel properties, or
Use clunky StringFormat hacks.

It all feels like too much work for something as small as showing a price. But .NET 11 fixes this with the new feature called *C# Expressions in XAML. * A small change with a huge, exciting impact!

With this preview feature, you can finally write short, safe C# expressions directly in XAML, no converter, no boilerplate, no ceremony.

What exactly are “C# Expressions in XAML”?

C# expressions in XAML let us embed short snippets directly into our bindings. Instead of pairing a binding with a converter, we can express the final display value directly in markup.

The feature is powered by the XAML Source Generator, which validates and generates strongly typed code from those expressions at build time. This keeps everything safe, fast, and readable, while making XAML feel much more natural.

Why this feature matters a lot

Here are the key benefits of using C# expressions in XAML:

Faster onboarding: Beginners don’t need to learn converters or extra patterns just to display formatted values.
Less boilerplate: Small, view-only transformations don’t force extra ViewModel properties or one-off converters.
Stronger tooling: Source generation brings lightning-fast compile-time validation and a performance boost over older methods.

Together, these superpowers make our UI code feel as intuitive and lively as what we imagine on the screen.

When to use it (and when not to)

Like any tool, C# expressions in XAML shine in the right scenarios.

Use it for small, presentational logic:
- Formatting values (Currency, date, etc.)
- Simple math
- String composition
- Toggling visuals based on a boolean
Avoid it for complex, reusable, business-critical logic, including:
- Pricing rules
- Tax calculations
- Logic that needs unit tests or reuse across multiple screens

Rule of thumb: If the logic isn’t obvious in one quick read, move it to the ViewModel or domain layer.

Getting comfortable with the syntax

Here are a few small examples that reflect everyday UI scenarios where developers often fall back on converters or extra ViewModel properties today.

1) Currency formatting without a converter

We can format currency using standard C# formatting. It displays localized currency according to the device or app culture.

XAML


<Label Text="{$'{Price:C2}'}" />

2) Show a computed total directly in the UI

For basic totals, we can keep the logic right next to the label.

XAML


<Label Text="{$'Total: {Price * Quantity:C2}'}" />

3) Build user-friendly text with string interpolation

Instead of creating separate property in the ViewModel , we can directly perform string interpolation in XAML.

XAML


<Label Text="{$'{Quantity} × {ProductName}'}" />

4) Use a conditional expression for status

For the simple UI state, there is no need for converters anymore.

XAML


<Label Text="Active" IsVisible="{IsActive}" />
<Label Text="Inactive" IsVisible="{!IsActive}" />

5) Conditional styling stays clean too

We can also switch colors based on the state.

XAML


<Label Text="{IsActive ? 'Active' : 'Inactive'}"
       TextColor="{IsActive ? Colors.Green : Colors.Gray}" />

Mini page walkthrough: Before vs. after

Want to see the magic? Nothing beats comparing a classic page with one upgraded to C# expressions in XAML for .NET MAUI.

Before: Works, but adds extra steps

A typical XAML page might start with bindings like these:

XAML


<Label Text="{Binding Price, StringFormat='{}{0:C2}'}" />
<Label Text="{Binding Total}" />
<Label Text="{Binding DisplayText}" />

To support this, we often introduce ViewModel properties that exist purely for formatting the UI.


public string DisplayText => $"{Quantity} × {ProductName}";

public decimal Total => Price * Quantity;

After: The UI reads like the UI

With C# expressions in XAML, the page instantly feels more direct and readable. Instead of hiding display logic in the ViewModel , you can now express it right where it belongs—front and center in the UI!

Our XAML transforms, looking cleaner, more expressive, and aligning perfectly with our original creative vision!

XAML


<ContentPage x:DataType="local:ProductViewModel">
 <VerticalStackLayout Spacing="6" Padding="16">
   <Label Text="{ProductName}"
          FontAttributes="Bold"
          FontSize="18" />
   <Label Text="{$'{Price:C2}'}" />
   <Label Text="{$'{Quantity} × {ProductName}'}" />
   <Label Text="{$'Total: {Price * Quantity:C2}'}" />
   <Label Text="Active"
          IsVisible="{IsActive}"
          TextColor="Green" />
   <Label Text="Inactive"
          IsVisible="{!IsActive}"
          TextColor="Gray" />
 </VerticalStackLayout>
</ContentPage>

Note: For more details, refer to the example for XAML C# expressions in .NET MAUI (.NET 11) GitHub.

How this fits into MVVM

It is important to emphasize that C# expressions in XAML are a presentation convenience, not a replacement for MVVM or ViewModels. Use expressions for short, UI-focused transformations. Keep business logic, calculations that affect behavior, and shared rules in the ViewModel or domain layer where they can be tested and reused.

Is it production-ready?

At this stage, the feature is not production ready. It is experimental and tied to the .NET 11 preview and XamlSourceGen.

This makes it excellent for learning, prototyping, and internal demos. However, for customer-facing releases, it is better to wait for stable support unless you control the full deployment environment and are comfortable with preview dependencies.

How to try it (Beginner-friendly setup)

If you want to experiment safely, start small and follow these steps:

Step 1: Enable preview features

Use the .NET 11 preview and enable the preview tag.

XAML


<EnablePreviewFeatures>true</EnablePreviewFeatures>

Step 2: Turn on XAML source generation

Next, make sure XAML source generation is enabled. This feature works only with active XamlSourceGen.

XAML


<MauiXamlInflator>SourceGen</MauiXamlInflator>

Step 3: Use x:DataType for your page

Prefer compiled bindings with x:DataType so expressions are strongly typed and tool support is better.

 x:DataType="local:MainViewModel"

Step 4: Start with simple expressions

Finally, add one expression at a time. Formatting values (like prices or labels) are usually the easiest and safest place to begin.

The future of .NET MAUI

C# expression in XAML nudges MAUI toward more natural, C#-centric markup workflows. By reducing boilerplate and enabling compile-time checks via source generation, the developer experience becomes clearer and less error-prone.

As .NET 11 progresses, you can expect this feature to evolve and stabilize, potentially becoming a standard part of how developers write XAML in .NET MAUI.

Refer to the following image.

.NET 11 preview update: Using C# expression in XAML for .NET MAUI framework

Frequently Asked Questions

Can I use C# expressions in XAML without enabling XamlSourceGen?

No. This feature works only when XamlSourceGen is enabled because the expressions are processed and compiled through a source generator. Without it, the XAML tooling/parser won’t understand or translate the expressions.

Is this feature stable enough for production apps?

Not yet. C# expressions in XAML are currently experimental and tied to .NET 11 preview builds. It’s great for learning, demos, and prototypes, but for customer-facing production apps it’s safer to wait until it becomes officially supported and stable.

Do C# expressions replace converters or MVVM patterns?

No. They’re meant for small UI transformations like formatting, string interpolation, or basic calculations. Converters and MVVM are still important for reusable transformations, complex logic, and business rules that should be tested and shared across screens.

Can I call methods inside a C# expression in XAML?

Only simple and safe expressions are intended to work well. We should avoid async calls and multi-step operations. The purpose is to keep UI logic lightweight and readable, not to move app logic into XAML.

Will these expressions slow down my app?

Typically, no. Because expressions are compiled via the source generator. They’re strongly typed and avoid some reflection-heavy behavior common in classic bindings. In most cases, performance should be equal or better, depending on the page and scenario.

Does this work with x:DataType (compiled bindings)?

Yes. Using x:DataType is recommended because it improves type safety, enables better compile-time checking, and usually provides better IntelliSense while authoring XAML.

Looking ahead

Thanks so much for reading! If you’re diving into .NET MAUI, this is truly one of the most thrilling improvements ahead. C# expressions in XAML bring excitement, clarity, and an incredibly intuitive way to shape UI logic. As .NET 11 evolves, this tool will only become more powerful and transformative!

Whether it’s your first MAUI project or you’re perfecting your UI architecture, this addition is set to supercharge your workflow, making development fast, clean, and genuinely rewarding!

If you’re using Syncfusion .NET MAUI controls, the latest version of Essential Studio is available from your license and downloads page. New to Syncfusion? You can try the full suite with a 30‑day free trial and experience a production‑ready collection of high‑performance MAUI controls that pair perfectly with the .NET 11 workflow.

If you have questions or need help, feel free to reach out through our support forum, feedback portal, or support portal. Our team is always happy to assist you!

How to Build a Blazor HeatMap Chart to Visualize Global Temperature Anomalies

Jollen Moyani — Tue, 12 Aug 2025 15:26:51 +0000

TL;DR: Curious how to turn climate data into compelling visuals? This tutorial guides developers through building a Blazor HeatMap chart to showcase global temperature anomalies. You’ll learn how to enhance interactivity with custom tooltips, gradient color mapping, and legend configuration, making your charts both informative and visually impactful.

Welcome to our Weekly Data Visualization blog series!

Visualizing complex climate data can be challenging, but with the right tools, it becomes a powerful way to uncover trends and tell compelling stories. Whether building dashboards for environmental analytics or experimenting with Blazor’s charting capabilities, this hands-on guide offers a practical, code-driven solution to a real-world data challenge.

In this tutorial, you’ll learn how to build a Syncfusion^® Blazor HeatMap that tracks global temperature anomalies from 2004 to 2024. Using interactive features like custom tooltips, gradient-based color mapping, and legend configuration, you’ll transform raw data into a dynamic, developer-friendly visualization.

What exactly is a temperature anomaly?

A temperature anomaly is the difference between the observed temperature and a reference or average temperature for a specific location and time period. Instead of showing the absolute temperature (like 30°C), it shows how much warmer or cooler it was compared to a baseline. This approach helps highlight deviations and trends more effectively, making it easier to compare climate patterns across different regions and decades.

Why choose Syncfusion^® Blazor HeatMap?

The Syncfusion^® Blazor HeatMap is a versatile data visualization component designed to represent values across a two-dimensional grid using color gradients. It’s ideal for highlighting patterns, trends, and deviations in large datasets, making it a valuable tool for dashboards, analytics platforms, and scientific applications.

Seamless integration with Blazor: Explicitly built for Blazor, the HeatMap component integrates effortlessly into your application with minimal configuration.
Rich customization options: You can customize everything from color palettes and labels to cell formatting and legends to suit your data and design needs.
Interactive features: Enhance user interaction with dynamic tooltips, zooming, and responsive updates.
Accessibility and responsiveness: Fully responsive and compliant with accessibility standards for a consistent experience across devices.

Note: To implement the Blazor HeatMap component, refer to the official documentation.

Customizing the Blazor HeatMap to visualize temperature anomalies

Follow the steps below to visualize global temperature anomalies from 2004 to 2024 using the Syncfusion^® Blazor HeatMap component and learn how to customize it for a more insightful user experience.

Step 1: Gathering the data

Before visualizing data in a Blazor HeatMap, it’s important to gather accurate and meaningful statistics. This example uses global land and ocean temperature anomaly (in °C) records from 2004 to 2024, sourced from NCEI.

Step 2: Creating the data model

To effectively visualize temperature anomalies in the HeatMap, a HeatMapCell class must be defined to represent monthly temperature data. This class includes three essential properties: Month, Year, and Anomaly, which together capture the temporal and statistical dimensions of the dataset.

public class HeatMapCell
{
    public string Month { get; set; }
    public string Year { get; set; }
    public double Anomaly { get; set; }
}

The data will be stored in a list named HeatMapData. Two string arrays should also be created to represent the axis labels: XAxisLabels for the months and YAxisLabels for the years. The HeatMapData list should be initialized using the OnInitialized lifecycle method of the Blazor component to ensure it is ready for data binding when the component is rendered.

public string[] XAxisLabels = new string[] 
{ 
    "January", "February", "March", "April", "May", "June", 
    "July", "August", "September", "October", "November", "December" 
};

public string[] YAxisLabels = new string[] 
{ 
    "2004", "2005", "2006", "2007", "2008", "2009", "2010", 
    "2011", "2012", "2013", "2014", "2015", "2016", "2017", 
    "2018", "2019", "2020", "2021", "2022", "2023", "2024" 
};

public List<HeatMapCell> HeatMapData { get; set; }

protected override void OnInitialized()
{
    HeatMapData = new List<HeatMapCell>
    {
        new HeatMapCell { Month = "January", Year = "2004", Anomaly = 0.62 },
        new HeatMapCell { Month = "February", Year = "2004", Anomaly = 0.66 },
        new HeatMapCell { Month = "March", Year = "2004", Anomaly = 0.66 },
        new HeatMapCell { Month = "April", Year = "2004", Anomaly = 0.65 },
        new HeatMapCell { Month = "May", Year = "2004", Anomaly = 0.6 },
       …..,
    }
}

Step 3: Initializing the Syncfusion^®Heat Map Chart

With the data and labels prepared, the next step is to render the HeatMap component in your Blazor application. Syncfusion’s SfHeatMap component makes this process straightforward by binding your data source and axis labels directly in the component.

In the example below:

The dataset containing temperature anomalies is assigned to the DataSource property of the HeatMap component.
The arrays created for axis labels are bound to the Labels properties of the HeatMapXAxis and HeatMapYAxis components.

This setup ensures that each cell in the HeatMap corresponds to a specific month and year, with its color intensity reflecting the temperature anomaly value. The result is a clear, color-coded visualization of climate trends over two decades.

<SfHeatMap DataSource="@HeatMapData" >

    <HeatMapXAxis Labels="@XAxisLabels" OpposedPosition="true">
    </HeatMapXAxis>

    <HeatMapYAxis Labels="@YAxisLabels">
    </HeatMapYAxis>

<SfHeatMap>

Step 4: Customizing HeatMap Chart appearance

Customizing the Chart title

It’s important to include a clear and descriptive title for the HeatMap to provide context and enhance readability. The HeatMapTitleSettings component in Syncfusion^® Blazor makes it easy to add and style the chart title.

<HeatMapTitleSettings Text="Global Land and Ocean Temperature Anomalies (2004–2024)">

    <HeatMapTitleTextStyle Size="18" FontWeight="Bold" Color="Black">
    </HeatMapTitleTextStyle>

</HeatMapTitleSettings>

Color mapping

To make the HeatMap visually intuitive and informative, a gradient color palette is applied using the HeatMapPaletteSettings component. This palette maps temperature anomaly values to a continuous range of colors, allowing users to easily distinguish between cooler and warmer periods.

In the example below, lower anomaly values are represented by shades of blue, while higher values transition through yellow and orange to warmer shades of red. This natural color progression mirrors common visual associations with temperature, making the visualization more accessible and meaningful.

<HeatMapPaletteSettings Type="PaletteType.Gradient">

    <HeatMapPalettes>
        <HeatMapPalette Value="0.0" Color="#313695"></HeatMapPalette>
        <HeatMapPalette Value="0.3" Color="#4575b4"></HeatMapPalette>
        <HeatMapPalette Value="0.5" Color="#91bfdb"></HeatMapPalette>
        <HeatMapPalette Value="0.7" Color="#e0f3f8"></HeatMapPalette>
        <HeatMapPalette Value="1.0" Color="#fee090"></HeatMapPalette>
        <HeatMapPalette Value="1.3" Color="#fdae61"></HeatMapPalette>
        <HeatMapPalette Value="1.5" Color="#d73027"></HeatMapPalette>
        <HeatMapPalette Value="2" Color="#d73027"></HeatMapPalette>
    </HeatMapPalettes>

</HeatMapPaletteSettings>

Customizing the tooltip

To provide users with detailed insights at a glance, you can customize the tooltip in the Blazor HeatMap using the HeatMapTooltipSettings component. This allows you to display contextual information, such as the month, year, and temperature anomaly, when hovering over a specific cell.

In the example below, the tooltip is styled with a dark background and white text for better contrast and readability. The content is dynamically populated using the HeatMapCell model:

<HeatMapTooltipSettings Fill="#000000" Enable="true">
    <Template>
        @{
            var TooltipTemplate = context as HeatMapCell;
        }
        <div style="background-color:black; color:white; font-size:12px; padding:8px; border-radius:4px;">
            <div style="text-align:center; font-weight:bold;">
                @TooltipTemplate.Month
            </div>
            <div style="display:flex; justify-content:center; gap:4px;">
                <span>@TooltipTemplate.Year</span>
                <span>:</span>
                <span>@($"{TooltipTemplate.Anomaly} °C")</span>
            </div>
        </div>
    </Template>
</HeatMapTooltipSettings>

Configuring a legend

To help users interpret the color gradient used in the HeatMap, you can enable and customize the legend using the HeatMapLegendSettings component. The legend provides a visual reference for the range of temperature anomaly values and their corresponding colors.

In the example below, the legend is positioned at the bottom of the chart and assigned a specific width to maintain a consistent and balanced layout:

<HeatMapLegendSettings Position="Syncfusion.Blazor.HeatMap.LegendPosition.Bottom" Visible="true" Width="80%">
</HeatMapLegendSettings>

After executing these code examples, you will see the chart displayed as shown below.

Blazor HeatMap Chart displaying global land and ocean temperature anomalies

Sample reference

For more details, refer to the complete sample on the Blazor Playground demo.

Conclusion

Thank you for reading! By building a Blazor HeatMap Chart, you’ve unlocked a powerful way to visualize complex climate data and uncover meaningful patterns in global temperature anomalies from 2004 to 2024. With features like custom tooltips, gradient color mapping, and legend configuration, you now have the tools to create interactive, data-rich visualizations that go beyond static charts.

With just a few lines of code, you can transform raw data into compelling visual stories.

The flexibility of Syncfusion’s HeatMap component makes it ideal for scientific and business applications. Start building your own interactive HeatMap today, unlock deeper insights from your data, and share your comments!

If you’re an existing Syncfusion^® customer, you can download the latest version of Essential Studio^® from the license and downloads page. If you are not a Syncfusion^® customer, try our 30-day free trial to check it out.

You can also contact us through our support forums, support portal, or feedback portal. We are always happy to assist you!

Related blogs

Create Visually Rich Content Easily with Blazor Rich Text Editor! No HTML

Jollen Moyani — Tue, 03 Jun 2025 17:14:35 +0000

Are you looking to offer your users an intuitive way to create and manage content in your Blazor app without writing a single line of HTML?

The Syncfusion^® Rich Text Editor for Blazor transforms content creation with a seamless, WYSIWYG editing experience. Whether you’re building CMS tools, knowledge bases, or collaborative apps, this editor empowers users and saves development time.

What is a WYSIWYG HTML editor?

A WYSIWYG HTML editor allows users to create and edit content through a visual interface. This approach provides a live preview of how the content will appear when published, eliminating the need for manual HTML coding and making content creation more intuitive.

Core features of WYSIWYG HTML editor

Visual editing interface: It offers a real-time preview of content changes, facilitating intuitive formatting.
Rich formatting tools: It includes various options for font styles, text alignment, colors, and more through a user-friendly toolbar.
Media integration: It allows the insertion of images, videos, and audio elements.
Linking and anchoring: It simplifies the addition of hyperlinks and anchors.
Templates and styles: It provides pre-designed templates and style options for professional document creation.

What is an Advanced WYSIWYG HTML editor?

Advanced WYSIWYG HTML editor extends their basic functionalities to offer more comprehensive features tailored for complex web development needs.

Features of Advanced WYSIWYG HTML editor

Extended formatting options: Incorporates advanced styling features like custom CSS and interactive elements.
Customizable toolbar: Allows extensive customization of toolbars to suit specific workflows.
Advanced media handling: Offers sophisticated media management, including image editing and video embedding.
Paste cleanup: Ensures that pasted content conforms to the document’s style and structure.
List features: Supports various list types with customization options.
Table support: Provides tools for creating and formatting tables, including row, column, and cell adjustments.
Slash menu: Offers quick access to commands and content insertion through a slash (“/”) menu.
@Mention functionality: It enables tagging or mentioning of users within the content.
Third-party integration: It extends functionality with tools like CodeMirror for advanced code editing and WebSpellChecker for spell checking and grammar correction.
Form validation: Includes features for forms embedded within the editor, ensuring user inputs are correctly validated before submission.
Localization: It supports multiple languages and regional settings, allowing the editor to adapt to different locales and improve usability for a global audience.
Accessibility: Ensures screen reader compatibility, utilizes semantic HTML for enhanced content structure, and allows customization of accessibility features.
Keyboard support: It provides a comprehensive set of keyboard shortcuts for common actions and ensures effective focus management for users navigating with the keyboard.
Mobile support: Optimizes the editor for mobile devices, providing a responsive design that ensures a seamless editing experience on smartphones and tablets.

Use cases where the editor shines

Real-world scenarios where the Syncfusion^® WYSIWYG editor adds instant value.

Internal CMS platforms for managing website content.
Dynamic email template builders.
Knowledge base and documentation tools.
Online learning and publishing platforms.
Customer support portals with editable responses or FAQs.

Differences between Advanced WYSIWYG HTML Editor and Rich Text Editor

While both Advanced WYSIWYG HTML editors and Rich Text editors provide visual content editing, they differ in several ways.

Scope of features: Advanced WYSIWYG editors offer a broader range of functionalities, including advanced formatting and extensive customization options. In contrast, Rich Text Editors generally focus on basic text formatting and simple media insertion.
Customization and extensibility: Advanced editors offer more options for customization and integration with other tools, while Rich Text Editors are typically less extensible and provide fewer customization options.
Use cases: Advanced WYSIWYG editors are ideal for complex scenarios that require detailed control, whereas Rich Text Editors are often sufficient for simpler content creation tasks.

Integrating the Syncfusion^® Blazor Rich Text Editor

The Syncfusion^® Blazor Rich Text Editor makes it incredibly easy to add visual editing capabilities to your app.

Here’s a quick example to get you started.

@page "/rich-text-editor"
@using Syncfusion.Blazor.RichTextEditor

<SfRichTextEditor @bind-Value="richTextContent">
</SfRichTextEditor>

@code {
    private string richTextContent = "<p>Welcome to Syncfusion Blazor Rich Text Editor!</p>";
}

With just a few lines of code, you get a fully functional WYSIWYG editor ready for rich content creation, mentions, toolbar customization, and more.

Documentation and resources

For more details on integrating and configuring the Syncfusion^® Blazor Rich Text Editor, refer to the documentation.

Conclusion

Thanks for reading! Modern content creation demands intuitive, powerful tools, and the Syncfusion^® Blazor Rich Text Editor delivers just that. With features like accessibility, keyboard support, responsive design, and deep customization, it’s the ideal solution for developers building user-friendly, scalable web content editors.

Existing customers can download the new version of Essential Studio^®on the license and downloads page. If you are not a Syncfusion^® customer, try our 30-day free trial to experience our incredible features.

You can also contact us through our support forum, support portal, or feedback portal. We are always happy to assist you!

Related Blogs

This article was originally published at Syncfusion.com.

Visualize Financial Insights Instantly with Blazor Waterfall Charts

Jollen Moyani — Tue, 03 Jun 2025 14:07:29 +0000

TL;DR: Discover how to create a Waterfall Chart in Blazor to visualize financial data effectively. This guide explains the chart’s use in analyzing revenue, expenses, and profit, and offers a step-by-step approach covering data gathering, chart configuration, and interactive features for insightful visualizations.

Welcome to our Weekly Data Visualization blog series.

What is a Waterfall Chart?

Waterfall Charts are powerful tools for visualizing step-by-step variations in financial or business data. They are widely used to illustrate how sequential values contribute to a final total in revenue breakdowns, expense tracking, and profit analysis.

In this blog post, we’ll explore how to create a Waterfall Chart using Syncfusion^® Blazor Charts to represent financial data effectively. We’ll dive into key features, data binding, and customization options to enhance your visualizations’ clarity and insight.

This guide will provide a structured approach to integrating Waterfall Charts into your Blazor applications, ensuring accurate and insightful financial analysis.

Common use cases for Waterfall Charts include:

Financial statements: Analyzing revenue breakdowns, profit margins, and expense tracking.
Business performance metrics: Visualizing how different factors contribute to overall growth or decline.
Budget variance analysis: Tracking increases and decreases in expenses or revenues over time.
Project cost analysis: Evaluating cost distributions and identifying key expense drivers.
Sales and market analysis: Understanding the impact of promotions, discounts, and returns on net sales.

Waterfall Charts are invaluable for highlighting intermediate values while emphasizing the overall trend, making them ideal for decision-making and reporting.

Implementing Waterfall Charts in Blazor

Waterfall Charts offer a clear and concise way to visualize financial movements such as profits, losses, and net performance. This section will walk you through implementing one in a Blazor application using Syncfusion^® components.

Let’s dive in!

Step 1: Gathering the financial data

Before you visualize any data, the first step is to gather the data. For this example, we collected annual financial data from the Profit and Loss Report for DLF. This report provides a detailed view of the company’s revenue, costs, profits, and other key financial indicators.

We selected a few critical values to keep our example simple and focused:

Revenue
Cost of Revenue
SG&A Expenses (Selling, General, and Administrative Expenses)
Depreciation
Interest Income

These categories illustrate how individual components contribute to the overall net profit. This makes them ideal for a Waterfall Chart, which visually breaks down the contributions to a final value.

Step 2: Define the data model

With the financial data sourced, we will structure it in a format compatible with your Blazor chart.

We’ll define a class called WaterfallChartData with the following properties:

X: The financial category (e.g., “Revenue” or “Depreciation”).
Y: The corresponding value. Positive values represent gains; negative values indicate expenses or losses.

Refer to the following code example.

public class WaterfallChartData
{
    public string X { get; set; }
    public double Y { get; set; }
}
public List<WaterfallChartData> ChartPoints { get; set; } = new List<WaterfallChartData>
{
    new WaterfallChartData { X = "Revenue", Y = 6254.58 },
    new WaterfallChartData { X = "Cost of Revenue", Y = -2536.31 },
    new WaterfallChartData { X = "Gross Profit" }, // Intermediate Sum
    new WaterfallChartData { X = "SG&A Expenses", Y = -1722.80 },
    new WaterfallChartData { X = "Depreciation", Y = -105.75 },
    new WaterfallChartData { X = "Interest Income", Y = 130.22 },
    new WaterfallChartData { X = "Net Profit" } // Final Sum
}

Notice how Gross Profit and Net Profit are defined without a Y value. They represent Sum points, which the chart calculates automatically.

private Double[] IntermediateSumIndexes { get; set; } = new Double[] { 2 };
private Double[] SumIndexes { get; set; } = new Double[] { 6 };

To achieve this, we use index arrays to specify which categories should be treated as calculated sums.

IntermediateSumIndexes: Marks the third item, Gross Profit, as an intermediate sum.
SumIndexes: Marks the seventh item, Net Profit, as the final total.

This approach provides a clear, intuitive way to break down your financial performance step by step, making it significantly easier for users to follow the flow of gains and losses in business data.

Step 3: Configure the Waterfall Charts

With your data model prepared, you can now visualize your data effectively. A Waterfall Chart in Blazor is ideal for showing how values progress across financial categories, from revenue to net profit. It highlights both gains and losses along the way.

If you’re new to Syncfusion^® Blazor Charts, follow the official user guide to set up your project. This guide will walk you through installing the required NuGet packages, registering Syncfusion services, and configuring your project to use Blazor Charts components.

After completing the setup, you can define the Waterfall Charts using the SfChart component

Refer to the code example below:

<SfChart>
     <ChartSeries DataSource="@ChartPoints"
             Name="DLF FY2024"
             XName="X"
             YName="Y"
             Type="ChartSeriesType.Waterfall"> 
</SfChart>

Breakdown of the Chart configuration

The ChartSeries section connects the chart to the data. The DataSource property binds the chart to the ChartPoints list you defined earlier.
The properties XName and YName map the fields in your WaterfallChartData model to the chart’s X and Y axes, respectively.

Step 4: Define the Series with subtotals and totals

This step focuses on binding the financial data and configuring the logic required for the Waterfall Chart.

Refer to the following code snippet for implementation details.

<ChartSeriesCollection>
    <ChartSeries ColumnWidth="0.5"
                 NegativeFillColor="#e56590"
                 DataSource="@ChartPoints"
                 Name="DLF FY2024"
                 XName="X"
                 YName="Y"
                 Width="2"
                 IntermediateSumIndexes="@IntermediateSumIndexes"
                 SumIndexes="@SumIndexes"
                 Type="ChartSeriesType.Waterfall">
        ….

    </ChartSeries>
</ChartSeriesCollection>

The following configurations make the Waterfall chart function as expected:

The NegativeFillColor property highlights losses using a distinct pink shade.
The IntermediateSumIndexes (e.g., for “Gross Profit”) and SumIndexes (e.g., for “Net Profit”) properties indicate where the chart should calculate running and final totals, respectively.
Data is retrieved from the ChartPoints collection, and each point is rendered dynamically based on its configuration.

Step 5: Add styling, tooltips, and markers

To make the chart more interactive and visually appealing, enable animations, labels, and tooltips.

<SfChart ID="waterfall" Title="DLF Ltd. Financial Overview (FY 2024)" Width="@Width" Theme="Theme.Bootstrap4">
    <ChartTitleStyle TextOverflow="TextOverflow.Wrap" />

    <ChartTooltipSettings Enable="true" Header="" 
        Format="<b>${point.x}</b><br>Value: <b>${point.y} Cr</b>" />

    <ChartSeries>
        <!-- Series configuration (data source, x/y mapping) should go here -->

        <ChartSeriesAnimation Enable="true" />

        <ChartMarker>
            <ChartDataLabel Visible="true" Position="LabelPosition.Outer">
                <ChartDataLabelFont Size="@Size" />
            </ChartDataLabel>
        </ChartMarker>

        <ChartSeriesConnector Color="#5F6A6A" Width="0.8" DashArray="1,2" />
        <ChartSeriesBorder Width="0.2" Color="black" />
    </ChartSeries>

    <!-- Other chart settings -->
</SfChart>

Use the Title property of the SfChart to set a clear and informative chart title that communicates the financial context of the data.
Set the chart’s width using the Width property of the SfChart to ensure responsiveness across devices.
Configure ChartTooltipSettings to display values dynamically when hovering over each bar, improving user interaction.
Add ChartDataLabel to display values directly on the bars, enhancing readability at a glance.
Use ChartSeriesConnector, which visually connects each bar to the next, to guide the viewer’s eye through the data.
Apply ChartSeriesBorder to define the edges of each bar for a cleaner look, and enable ChartSeriesAnimation to add smooth transitions and visual flair.

Final output

GitHub reference

For more details, refer to the GitHub demo.

Conclusion

Thanks for reading! In this blog post, we’ve explored how to build insightful Blazor Waterfall Charts for Financial and Business Analysis using Syncfusion Charts. Try them out and share your feedback in the comments section below!

You can explore our ⁠Blazor Chart Example to learn more about the supported chart types and how easy it is to configure them for stunning visual effects.

The latest version of the Blazor Chart component is available for current customers from the license and downloads page. If you are not a Syncfusion^® customer, try our 30-day free trial.

You can also contact us through our support forums, support portal, orfeedback portal. We’re always happy to assist you!

Related Blogs

This article was originally published at Syncfusion.com.

Introducing Syncfusion Cody: AI Code Editor for Enterprise App Development

Jollen Moyani — Mon, 19 May 2025 14:52:32 +0000

TL;DR: Syncfusion^® Cody is a blazing-fast, AI-powered code editor built for enterprise developers. With four intelligent modes, Chat, Edit, Agent, and Autocomplete, it helps teams write, refactor, and generate UI code in seconds. Cody works out of the box, supports any LLM, lets you bring your docs as context, and extends seamlessly with your MCP. No Syncfusion license required.

Tired of AI coding tools with fragile integrations, vague licensing terms, or poor scalability across large codebases? We’re excited to introduce Syncfusion^® Cody, a purpose-built AI code editor designed to bring safe, efficient, and scalable AI development to the enterprise world. Cody is our answer to the real challenges teams face, built for reliability, clarity, and growth.

Syncfusion Cody agent mode

Why We Built Cody

Over the past year, our internal development teams have adopted AI-assisted development across projects large and small. In doing so, we’ve encountered many real-world challenges that come with using generic AI assistants, ranging from accidental regressions to IP and privacy concerns.

That experience helped us shape Cody into a truly enterprise-grade AI coding assistant. It now helps us generate over 30% of our new code, and we’re ready to share it with the world.

Meet Syncfusion^® Cody

Syncfusion^® Cody is more than just another AI coding assistant. It’s designed to be:

A productivity companion for everyday development tasks.
A safe, scalable platform for enterprise adoption of AI.
A tool that works with your existing workflows and models, without locking you in.

No special IDEs or tools are required. Just install Cody, configure your preferred model, and download it here to get started

Cody offers four modes tailored to your workflow:

Chat Mode

Ask questions, generate snippets, or plan logic using natural language without editing your files.

Syncfusion Cody chat mode

Edit Mode

Select any code, press a shortcut, and rewrite or optimize it instantly using AI.

Syncfusion Cody edit mode

Agent Mode

Describe a fix or feature in plain English. Cody applies the change across your codebase autonomously.

Syncfusion Cody agent mode

Autocomplete Mode

Get smart inline suggestions while typing. Just press Tab to complete your thought instantly.

Syncfusion Cody autocomplete mode

Core features

Beyond its four powerful modes, Cody includes several built-in tools that enhance your development workflow:

Smart Apply: Applies AI-generated code in the right context.
Contextual shortcuts: Right-click options like Fix this issue or Write documentation.
Prompt Enhancer: Clarifies user inputs for better model results.
Codebase Search: AI-assisted search across files, functions, and logic.
Test & Doc Generation: Instantly generate unit tests or documentation.
Image Input: Share screenshots to describe bugs or UI requirements.
Built-in Agent Tools: Read/write files, run terminal commands, perform web searches, and more.
Custom Prompts & Workflows: Define reusable instructions and coding rules.

Engineered for Scalable Enterprise Needs

Cody is engineered to meet enterprise needs at scale:

Clean IP: Leverages Syncfusion’s 1,800+ pre-tested components instead of risky OSS packages.
Large Codebase Support: Understands and operates across your full project context.
Data Privacy: Bring your API keys or use local models for full control.
Security & Compliance (coming soon): SSO, admin console, usage analytics, and audit controls included.
Centralized Knowledge (coming soon): Consolidate org-wide dev knowledge directly into Cody’s context.

UI Builder Powered by Syncfusion Components

Frontend work shouldn’t take up most of your sprint. Cody can generate full UIs by simply describing what you need. It uses our 1,800+ enterprise-grade components to output production-ready UI code with minimal input.

Syncfusion Cody with built-in UI builder

Freedom to Choose Your Model

Cody supports all major LLM providers, OpenAI, Azure, Anthropic, Mistral, and even lets you connect to local models using Ollama or LM Studio. You’re in control of cost, performance, and compliance.

Syncfusion Cody chat model list

Cody Is Open to All. No Syncfusion License Needed.

You can use Cody without a Syncfusion UI license. You’ll still get:

Chat, Edit, Agent, and Autocomplete Modes
Code generation, refactoring, test creation, and debugging support

The only thing you’re missing is UI generation powered by our components.

Try Cody free today

Ready to code smarter, faster, and at scale? Syncfusion^® Cody isn’t just another AI tool, it’s your development partner built for real-world enterprise challenges. Whether you’re refactoring legacy code, building modern UIs, or streamlining workflows, Cody helps you do it better and with confidence.

Try Syncfusion^® Cody today and let us know what you think. We’re just getting started.

Related Blogs

This Blog was originally published on the Syncfusion site.

How to Generate ZUGFeRD-Compliant Invoices from Word or HTML in .NET

Jollen Moyani — Wed, 07 May 2025 16:21:07 +0000

TL;DR: This blog post walks you through generating ZUGFeRD-compliant e-invoices in a .NET application using the Syncfusion^® PDF Library. It begins by explaining the purpose of hybrid standards, which merge PDF/A-3 with embedded XML for readability and automation. You’ll learn how to convert Word or HTML templates into compliant PDFs, embed machine-readable XML, and validate invoices to meet international standards like EN 16931.

In today’s rapidly evolving business environment, efficiency and compliance are paramount. Electronic invoicing has become an essential component, transitioning from luxury to necessity for seamless global trade.

The ZUGFeRD standard, short for Zentraler User Guide des Forums elektronische Rechnung Deutschland, which integrates a PDF/A-3 document with embedded XML data, has revolutionized the industry. By adopting ZUGFeRD invoices, businesses can streamline processes, minimize errors, and adhere to international standards such as EN 16931, the European e-invoicing standard set to take effect on January 1^st, 2025. These standards ensure that business invoices meet the highest levels of accuracy and legal acceptability, allowing them to operate confidently.

The blog post will delve into how developers can use the Syncfusion^® .NET PDF Library to generate ZUGFeRD invoices from Word and HTML. Whether you’re unfamiliar with ZUGFeRD or seeking a reliable .NET PDF library, this guide will lead you through each step and show how seamlessly these tools can be integrated into your current workflow.

The history of ZUGFeRD and Factur-X
How ZUGFeRD and Factur-X Hybrid Invoices work
Creating ZUGFeRD invoices with the Syncfusion^® PDF Library

Let’s get started!

The history of ZUGFeRD and Factur-X

ZUGFeRD, an acronym for “Zentraler User Guide Forum elektronische Rechnung Deutschland,” or “Central User Guide of the German Electronic Invoice Forum” in English. Factur-X is derived from the French word “ facture,” meaning invoice. The “X” symbolizes the standard’s cross-border applicability, indicating its functionality across various countries and systems.

Since version 2.1, the ZUGFeRD and Factur-X standards have been fully compatible. Both countries have collaborated to advance the standard further, and although it is officially unified under the Factur-X name, it is still commonly referred to as ZUGFeRD.

Version	Release Date	Key Features	Profiles
1.0	June 2014	Hybrid invoice format (PDF/A-3 + XML). Not EN 16931 compliant.	BASIC, COMFORT, EXTENDED
2.0	March 2019	UN/CEFACT CII schema. Enhanced interoperability. EN 16931 compliant.	MINIMUM, BASIC WL
2.1	March 2020	Compatible with Factur-X 1.0.05. Supports German CIUS "XRechnung."	EXTENDED
2.2	February 2022	Aligned with Factur-X 1.0.06. Added profiles for France and Germany, including EXTENDED_B2B_FR.	EXTENDED, EXTENDED_B2B_FR
2.3	September 2024	Uses CII D22B schema. Improved compliance with French B2B requirements. Updated EXTENDED profile.	EXTENDED

How ZUGFeRD and Factur-X hybrid invoices work

ZUGFeRD and Factur-X hybrid invoices uniquely integrate visual and machine-readable data, making them suitable for human users and automated systems. Here’s how they function:

PDF/A-3 format: These invoices are built on the PDF/A-3 standard, a variant of the PDF format designed for long-term archiving. The PDF contains the human-readable version of the invoice, which can be easily printed or viewed.
Embedded XML data: Within the PDF, an XML file is embedded. This XML follows specific schemas like UN/CEFACT CII to include all invoice data in a structured, machine-readable format. This enables seamless integration with accounting and ERP systems.
Attachments and the /AF key: The embedding of XML is facilitated using the /AF (Associated Files) key in the PDF document catalog. This feature, introduced in PDF/A-2 and extended in PDF/A-3, allows any file type, including XML, to be attached to the PDF.
Fixed XML file names by version: Each ZUGFeRD and Factur-X version specifies a standard file name for the XML attachment:
1. ZUGFeRD 1.0: ZUGFeRD-invoice.xml
2. ZUGFeRD 2.0: zugferd-invoice.xml
3. ZUGFeRD 2.1+ and Factur-X: factur-x.xml
Hybrid nature: The dual format ensures compliance with legal requirements for human-readable documents while supporting automation. This hybrid approach eliminates the need for separate systems to handle paper and electronic invoices.
Profiles: The standards offer profiles like BASIC, COMFORT, and EXTENDED to cater to business needs, from simple to complex invoicing scenarios. Profiles define the level of information included in the invoice, allowing businesses to choose the one that best suits their requirements.
Automation and interoperability: Hybrid invoices streamline workflows by enabling automation. They also ensure interoperability across systems, making them ideal for cross-border transactions.

By utilizing the .NET PDF Library, developers can effortlessly generate these hybrid invoices by embedding XML into a PDF during its generation. This ensures that businesses adhere to international standards and fully capitalize on the benefits of ZUGFeRD and Factur-X.

Creating ZUGFeRD invoices with the .NET PDF Library

The .NET PDF library offers robust features for working with PDFs, including creating ZUGFeRD-compliant invoices. Let’s break down the process into two parts:

Generating an invoice from a Word document
Generating an invoice from an HTML template. With these methods, you can quickly create and embed data-rich invoices that are both user-friendly and legally compliant.

1. Generate a ZUGFeRD invoice from Word documents

If your invoices are designed in Word, the Syncfusion^® library simplifies the conversion to ZUGFeRD invoices, making it easy to incorporate existing templates into your workflow.

Step 1. Create a new console application and install the following NuGet packages

# Convert Word to PDF in .NET applications.
Install-Package Syncfusion.DocIORenderer.Net.Core

# Supports handling ZUGFeRD e-invoice format in .NET.
Install-Package ZUGFeRD-csharp

# Library for parsing and serializing JSON in .NET.
Install-Package Newtonsoft.Json

Step 2. Prepare your Word template

Design an invoice template in Word with merge fields for dynamic data. These fields allow you to automate the inclusion of details like customer name, invoice number, and itemized lists.

We have used the mail merge fields to design the Word template. For more details about mail merge, refer to our documentation.

Refer to the following image.

Step 3. Deserialize the invoice data into the invoice class object

Invoice invoice = JsonConvert.DeserializeObject<Invoice>(File.ReadAllText("../../../Data/InvoiceData.json"));
//Create zugferd xml file
MemoryStream stream = invoice.CreateXml();

Step 4. Bind the data to the mail merge fields in the Word template

Using the mail merge feature of the Syncfusion Word library, bind the data to the Word template as follows:

using (WordDocument document = new WordDocument(fileStream, FormatType.Automatic))
{
    //Gets the invoice details as an “IEnumerable” collection.
    List<Invoice> invoiceCollection = new List<Invoice>();
    invoiceCollection.Add(invoice);
    //Creates an instance of “MailMergeDataTable” by specifying the mail merge group name and “IEnumerable” collection.
    MailMergeDataTable dataTable = new MailMergeDataTable("Invoice", invoiceCollection);
    //Enables the flag to start each record on a new page.
    document.MailMerge.StartAtNewPage = true;
    //Performs Mail merge.
    document.MailMerge.ExecuteNestedGroup(dataTable);
}

Step 5. Convert Word to PDF and attach the ZUGFeRD XML

Use Syncfusion’s Word-to-PDF converter to create a PDF representation of your Word invoice and attach ZUGFeRD XML. The XML file ensures that your PDF includes machine-readable invoice data.

Refer to the following example code.

using (DocIORenderer renderer = new DocIORenderer())
{   
    //Set conformance level to Pdf_A3B
    renderer.Settings.PdfConformanceLevel = PdfConformanceLevel.Pdf_A3B;
    //Embed all fonts
    renderer.Settings.EmbedFonts = true;

    //Converts Word document into a PDF document.
    using (PdfDocument pdfDocument = renderer.ConvertToPDF(document))
    { 
        //Set Zugferd conformance level to Extended
        pdfDocument.ZugferdConformanceLevel = ZugferdConformanceLevel.Extended;
        //Attach the zugferd xml file to PDF document
        PdfAttachment attachment = new PdfAttachment("factur-x.xml", stream);
        attachment.Relationship = PdfAttachmentRelationship.Alternative;
        attachment.ModificationDate = DateTime.Now;
        attachment.Description = "factur-x";
        attachment.MimeType = "application/xml";
        //Add attachment to PDF document
        pdfDocument.Attachments.Add(attachment);

        //Saves the PDF file to the file system.    
        using (FileStream outputStream = new FileStream("Zugferd.pdf", FileMode.Create, FileAccess.ReadWrite))
        {
            pdfDocument.Save(outputStream);
        }
    }
}

With these steps, you can transform your Word invoices into fully compliant ZUGFeRD documents, enabling your business to align with modern e-invoicing practices.

Refer to the following image.

2. Generating a ZUGFeRD invoice from HTML

HTML is a versatile format for designing templates, and the PDF library makes it easy to convert HTML content into ZUGFeRD-compliant invoices. Follow these steps:

Step 1. Install the following NuGet package

# Converts HTML to PDF in .NET applications for Windows.
Install-Package Syncfusion.HtmlToPdfConverter.Net.Windows

# Provides imaging functionalities for the Syncfusion PDF library.
Install-Package Syncfusion.Pdf.Imaging.Net.Core

# Supports handling ZUGFeRD e-invoice format in .NET.
Install-Package ZUGFeRD-csharp

# High-performance template engine for generating text-based outputs.
Install-Package Scriban

# Library for parsing and serializing JSON in .NET.
Install-Package Newtonsoft.Json

Step 2. Create an HTML template

An HTML template contains placeholders with {{mustache}} syntax. It is used to bind the actual data to the HTML template. For this example, we’ll use the Scriban scripting language to create the placeholders. It’s a lightweight scripting language and engine for .NET.

The following code example shows the data model for the invoice.

public class Invoice
{
    public string Number { get; set; }
    public DateTime InvoiceDate { get; set; }
    public CurrencyCodes CurrencyCode { get; set; } = CurrencyCodes.USD;
    public InvoiceType Type { get; set; }
    public TradeParty Buyer { get; set; }
    public TradeParty Seller { get; set; }
    public Profile Profile { get; set; } = Profile.Extended;

    public List<LineItem> LineItems = new List<LineItem>();
    public DateTime DueDate { get; set; }
    public float ApplicableTax { get; set; }

    public Invoice(string invoiceNumber, DateTime invoiceDate, CurrencyCodes currencyCode)
    {
        Number = invoiceNumber;
        InvoiceDate = invoiceDate;
        CurrencyCode = currencyCode;
    }

    public decimal LineTotalAmount
    {
        get
        {
            return (decimal)LineItems.Sum(x => x.Price * x.Quantity);
        }
    }

    public float TaxTotalAmount
    {
        get
        {
            return (float)LineTotalAmount * (ApplicableTax / 100);
        }
    }

    public float GrandTotalAmount
    {
        get
        {
            return (float)LineTotalAmount + TaxTotalAmount;
        }
    }
}

Based on this model, we design the template as follows. By default, the properties and methods of .NET objects are automatically exposed with lowercase and _names. This means that a property like Invoice.Seller.Name will be exposed as invoice.seller.name. This is the default convention.

<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Invoice</title>
    <link rel="stylesheet" href="style.css" media="all" />
  </head>
  <body>
    <header class="clearfix">
      <div id="logo">
        <img src="logo.png">
      </div>
      <div id="company">
        <h2 class="name">{{invoice.seller.name}}</h2>
        <div>{{invoice.seller.street}}</div>
        <div>{{invoice.seller.city}}</div>
        <div>{{invoice.seller.post_code}}</div>
        <div>{{invoice.seller.country}}</div>
      </div>
    </header>
    <main>
      <div id="details" class="clearfix">
        <div id="client">
          <div class="to">INVOICE TO:</div>
          <h2 class="name">{{invoice.buyer.name}}</h2>
          <div class="address">{{invoice.buyer.street}}</div>
          <div class="email">{{invoice.buyer.city}}</div>
          <div class="email">{{invoice.buyer.post_code}}</div>
          <div class="email">{{invoice.buyer.country}}</div>
        </div>
        <div id="invoice">
          <h1>{{invoice.invoice_number}}</h1>
          <div class="date">Date of Invoice: {{invoice.invoice_date}}</div>
          <div class="date">Due Date: {{invoice.due_date}}</div>
        </div>
      </div>
      <table border="0" cellspacing="0" cellpadding="0">
        <thead>
          <tr>
            <th class="no">#</th>
            <th class="desc">DESCRIPTION</th>
            <th class="unit">UNIT PRICE</th>
            <th class="qty">QUANTITY</th>
            <th class="total">TOTAL</th>
          </tr>
        </thead>
        <tbody id="invoiceItems">
          {{- index = 1 -}}
          {{ for item in invoice.line_items }}
          <tr>
            <td class="no">{{index}}</td>
            <td class="desc"><h3>{{item.name}}</h3>{{item.description}}</td>
            <td class="unit">${{item.price}}</td>
            <td class="qty">{{item.quantity}}</td>
            <td class="total">${{item.total_price}}</td>
          </tr>
          {{index = index + 1}}
          {{end}}
        </tbody>
        <tfoot>
          <tr>
            <td colspan="2"></td>
            <td colspan="2">SUBTOTAL</td>
            <td>${{invoice.line_total_amount}}</td>
          </tr>
          <tr>
            <td colspan="2"></td>
            <td colspan="2">TAX 25%</td>
            <td>${{invoice.tax_total_amount}}</td>
          </tr>
          <tr>
            <td colspan="2"></td>
            <td colspan="2">GRAND TOTAL</td>
            <td>${{invoice.grand_total_amount}}</td>
          </tr>
        </tfoot>
      </table>
      <div id="thanks">Thank you!</div>
      <div id="notices">
        <div>NOTICE:</div>
        <div class="notice">A finance charge of 1.5% will be made on unpaid balances after 30 days.</div>
      </div>
    </main>
  </body>
</html>

Step 3. Access the data and bind it with the HTML template

To simplify this article, we have used a custom JSON file to store and retrieve the data. The following code snippet is used to create the invoice model.

//Bind data to invoice model.
Invoice invoice = JsonConvert.DeserializeObject<Invoice>(File.ReadAllText("../../../Data/InvoiceData.json"));

//Create zugferd xml file.
MemoryStream stream = invoice.CreateXml();

Now, we use Scriban to bind the data from the model to the HTML template, as explained in the following code example.

var invoiceTemplate = File.ReadAllText("../../../Template/index.html");
var template = Template.Parse(invoiceTemplate);
var templateData = new { invoice };

//Fill out the template with real invoice data.
var pageContent = template.Render(templateData);

Step 4. Convert HTML string to PDF and create a ZUGFeRD invoice PDF

Generate invoice PDF from the bound HTML created in the previous section, convert the generated PDF document to PDF/A-3, and attach the factur-x.xml.

//Initialize HTML to PDF converter with Blink rendering engine.
HtmlToPdfConverter htmlConverter = new HtmlToPdfConverter(HtmlRenderingEngine.Blink);

BlinkConverterSettings blinkConverterSettings = new BlinkConverterSettings();
blinkConverterSettings.ViewPortSize = new Size(1024, 768);
//Convert HTML string to PDF. 
PdfDocument document = htmlConverter.Convert(pageContent, Path.GetFullPath("Template"));
document.ZugferdConformanceLevel = ZugferdConformanceLevel.Extended;

using (MemoryStream fs = new MemoryStream())
{
    //Save and close the PDF document.
    document.Save(fs);
    document.Close(true);
    //Convert a normal PDF document to a Zugferd PDF document.
    ZugferdPDFConverter converter = new ZugferdPDFConverter();
    var pdfStream = converter.ConvetToZugFerdPDF(fs, stream);
    pdfStream.Position = 0;
    //Save the Zugferd PDF document.
    FileStream fileStream = new FileStream("Invoice.pdf", FileMode.Create, FileAccess.Write);
    pdfStream.CopyTo(fileStream);
    fileStream.Close();
    stream.Close();
}

After the conversion, you will get a PDF document like the screenshot below.

Validating ZUGFeRD and Factur-X invoices

You can validate the ZUGFeRD invoice using the Mustang command line tool, an officially approved validator that ensures the data complies with EN 16931 standards.

java -jar Mustang-CLI-2.16.0.jar --action validate --source invoice.pdf

Conclusion

Thank you for reading! In this blog, we explored how to create ZUGFeRD invoices from a Word document and HTML with the .NET PDF Library. By integrating these steps into your workflow, you can:

Ensure compliance: Meet global e-invoicing standards like EN 16931 and stay ahead of regulatory requirements.
Boost efficiency: Reduce manual tasks and streamline processes, enabling faster invoice generation and payment cycles.
Enhance accuracy: Minimize errors with automated invoice generation and embedded machine-readable data.

The .NET PDF library’s robust features, such as HTML-to-PDF conversion, make it a reliable choice for developers. Whether you are using .NET or seeking an HTML-to-PDF solution, Syncfusion offers the necessary tools to streamline ZUGFeRD invoice creation. These tools enable businesses to update their invoicing processes, enhance efficiency in cross-border trade, and maintain full legal compliance.

Are you ready to integrate ZUGFeRD invoices into your system? Begin today with the .NET PDF library and enjoy the benefits of seamless e-invoicing. Download our free trialor explore the library’s documentation today. If you have any questions or need assistance with these features, please feel free to comment below or contact us through our support forum, support portal, or feedback portal. We are always here to assist you!

Related blogs

This article was originally published at Syncfusion.com.

Bar Chart vs. Pie Chart: The Ultimate Guide to Choosing the Right Chart for Your Data

Jollen Moyani — Wed, 07 May 2025 14:18:17 +0000

TL;DR: Bar charts and pie charts serve different purposes. Bar charts are best for comparisons, while pie charts are ideal for visualizing proportions. This blog post walks you through the decision-making process, complete with .NET MAUI code samples, tips for interactivity, and design enhancements using Syncfusion^® Toolkit.

Welcome to our Chart of the Week blog series!

Choosing the right chart can make or break how your audience understands your data. In this blog, we’ll break down the key differences between bar charts and pie charts—and show you how to build them using the powerful Syncfusion .NET MAUI Toolkit.

Data visualization transforms complex numbers into clear, impactful insights. But selecting the wrong chart type can blur your message. Bar charts and pie charts are both popular yet serve different roles. We’ll explore when to use each, highlight their strengths and limitations, and walk you through practical examples to help you visualize smarter.

Let’s get started!

Understanding the Basics

Bar chart

A bar chart represents data using rectangular bars, where the length of each bar corresponds to its value. It is ideal for comparing different categories or tracking changes over time.

Pie chart

A pie chart divides a circular area into proportional slices, each representing a percentage of the total. It is best suited for displaying data distributions and proportions.

When to Use a Bar Chart?

Bar charts are highly effective when dealing with:

Comparing multiple categories (e.g., revenue across different regions)
Tracking trends over time (using grouped or stacked bars)
Handling large datasets with multiple values
Visualizing negative and positive values side by side

Example use case

A company wants to compare its monthly sales across different regions. A bar chart clearly shows how each region performs, making it easy to analyze trends and disparities.

When to Use a Pie Chart?

Pie charts work best when:

Showing the percentage distribution of a single dataset
Visualizing a simple dataset with a limited number of categories (ideal for 3–6 segments)
Emphasizing proportions rather than absolute values

Example use case

A household wants to analyze its monthly expenses. A pie chart effectively visualizes how much of the budget goes toward rent, groceries, entertainment, and savings.

Bar Chart vs. Pie Chart: Pros & Cons

Feature	Bar Chart	Pie Chart
Best for	Comparisons	Proportions
Handles large datasets	Yes	No
Shows trends	Yes	No
Easy to interpret	Yes	Yes
Works with negative values	Yes	No
Visually appealing	Yes	Yes (If limited segments)

Here’s a step-by-step guide to implementing the Bar Chart and Pie Chart in the Syncfusion^® .NET MAUI Toolkit using the SfCartesianChart and SfCircularChart controls.

Step 1: Create the Model

Define a model class to represent the data for both charts, as shown in the code example below.

public class ChartModel
{
    public string Source { get; set; }
    public string TrafficImage { get; set; }
    public double Visitors { get; set; }
    public double DailyActiveUsers { get; set; }
    public string AgeGroup { get; set; }
    public double Percentage { get; set; }
}

Step 2: Create the ViewModel

In the ViewModel, we will create sample data for the Bar Chart (Visualize traffic stats) and the Pie Chart (Age group distribution of users).

Refer to the following code example.

public class ViewModel
{
    public ObservableCollection TrafficStats { get; set; }
    public ObservableCollection ActiveUsers { get; set; }

    public ViewModel()
    {
        TrafficStats = new ObservableCollection
        {
            new ChartModel { Source = "Google", Visitors = 1200 },
            new ChartModel { Source = "Facebook", Visitors = 950 },
            new ChartModel { Source = "Twitter", Visitors = 700 },
            new ChartModel { Source = "LinkedIn", Visitors = 450 }
        };

        ActiveUsers = new ObservableCollection
        {
            new ChartModel { Category = "Rent", Percentage = 40 },
            new ChartModel { Category = "Groceries", Percentage = 20 },
            new ChartModel { Category = "Transport", Percentage = 15 },
            new ChartModel { Category = "Entertainment",Percentage = 10 },
            new ChartModel { Category = "Savings", Percentage = 15 }
        };
    }
}

Step 3: Bind data to the Bar Chart (Traffic stats)

Use the SfCartesianChart to visualize traffic stats as a Bar Chart, as shown in the code example below.

<chart:SfCartesianChart IsTransposed="True">
    <chart:SfCartesianChart.XAxes>
        <chart:CategoryAxis>
            <chart:CategoryAxis.Title>
                <chart:ChartAxisTitle Text="Social Media" />
            </chart:CategoryAxis.Title>
        </chart:CategoryAxis>
    </chart:SfCartesianChart.XAxes>

    <chart:SfCartesianChart.YAxes>
        <chart:NumericalAxis />
    </chart:SfCartesianChart.YAxes>

    <chart:ColumnSeries 
        ItemsSource="{Binding TrafficStats}"
        XBindingPath="Source"
        YBindingPath="Visitors"
        ShowDataLabels="True" />

    <chart:ColumnSeries 
        ItemsSource="{Binding TrafficStats}"
        XBindingPath="Source"
        YBindingPath="DailyActiveUsers"
        ShowDataLabels="True" />
</chart:SfCartesianChart>

Step 4: Bind Data to the Pie Chart

Use the SfCircularChart to visualize the age group distribution of users as a pie chart, as shown in the code example below.

<chart:SfCircularChart.Legend>
    <chart:ChartLegend Placement="Right" />
</chart:SfCircularChart.Legend>

<chart:PieSeries 
    ItemsSource="{Binding ActiveUsers}"
    XBindingPath="AgeGroup"
    YBindingPath="Percentage">
</chart:PieSeries>

Step 5: Enhance the appearance and effectiveness of the chart.

Customizing the tooltip for better readability

Instead of default tooltips, you can create a custom tooltip template to show icons and values clearly. The tooltip will show the platform logo, name, and visitor count when hovering over a bar.

Refer to the following code example.

<chart:ColumnSeries.TooltipTemplate>
    <DataTemplate>
        <StackLayout BackgroundColor="Black" Padding="5" Orientation="Horizontal">
            <Image Source="{Binding TrafficImage}" WidthRequest="20" HeightRequest="20" />
            <Label Text="{Binding Source}" TextColor="White" FontSize="14" Margin="5,0,0,0" />
            <Label Text="Visitors: {Binding Visitors}" TextColor="White" FontSize="14" />
        </StackLayout>
    </DataTemplate>
</chart:ColumnSeries.TooltipTemplate>

Adding legends to improve clarity

Use a legend to differentiate visitors and daily active users. A legend at the bottom makes it easy to distinguish between the two datasets.

Refer to the following code example.

<chart:SfCartesianChart.Legend>
    <chart:ChartLegend Placement="Bottom" IsVisible="{OnPlatform Android='False',iOS='False',Default='True'}" />
</chart:SfCartesianChart.Legend>

Enhancing the Pie Chart with the Explode feature

The largest age group slice is pulled out, drawing focus to the most significant segment. To make certain slices more prominent, use the ExplodeIndex property, as shown in the code example below.

<chart:PieSeries 
    ItemsSource="{Binding ActiveUsers}"
    XBindingPath="AgeGroup"
    YBindingPath="Percentage"
    ExplodeOnTouch="True"
    ExplodeIndex="3">
</chart:PieSeries>

Choosing the right chart: A quick guide

If you need comparisons → Use a Bar Chart
If you need proportions → Use a Pie Chart
If you have many categories → Avoid Pie Charts

Choosing the right chart type ensures your data is easily interpretable and visually appealing. Use bar charts when comparing values and pie charts when showing percentage distributions.

By leveraging Syncfusion’s .NET MAUI Toolkit SfCartesianChart and SfCircularChart, you can build interactive and insightful visualizations for your applications.

After executing the previously outlined steps, the output will look like the following image.

Selecting Effective Data Visualization between Bar Chart and Pie Chart

GitHub reference

For more details, refer to the project on the GitHub demo.

Conclusion

We hope this guide helped you decide when to use a bar chart versus a pie chart. Using the Syncfusion^® .NET MAUI Toolkit, you can easily bring your data to life with clean models, smooth data binding, interactive legends, custom tooltips, and stunning explode effects.

Ready to take your charts to the next level? Start implementing our shared examples and share your experience in the comments.

Existing customers can access the new version of Essential Studio^® on the license and downloads page. If you aren’t a Syncfusion^® customer, try our 30-day free trial to explore these new features along with over 1,900 other UI components.

For further help, reach out to us via our support forum, support portal, or feedback portal—we’re here to help you build beautiful, data-driven apps with ease.

Related blogs

This article was originally published at Syncfusion.com.