Modern digital products live or die on speed, reliability and user experience. With .NET 10, Microsoft has invested heavily in Blazor to make it easier to deliver responsive, resilient web applications that are also easier to operate and evolve.

This article explains, in business-friendly terms, what the key Blazor improvements in .NET 10 mean for your organisation – and how Assemblysoft can help you either:

Modernise existing ASP.NET / Blazor applications to .NET 10, or

Build new, greenfield solutions using the latest .NET, Blazor and Azure technologies.

As .NET 10 Blazor experts, Assemblysoft focuses on turning these platform enhancements into real-world business value: faster systems, better UX, stronger security and smoother releases.

1. Faster Load Times & Better First Impressions

Smaller downloads, smarter caching

In .NET 10, the Blazor runtime script (the file that boots the app in the browser) is now processed like any other static asset:

It’s compressed and fingerprinted (given a unique name based on its content).

This avoids stale caching and reduces the size of what users download.

The core script shrinks from roughly 183 KB to about 43 KB – a ~76% reduction.

For senior stakeholders, the key takeaway is simple:

Pages load faster, especially on slower networks, and deployments are less likely to cause “it’s suddenly slow” complaints.

Standalone Blazor WebAssembly apps also benefit from improved client-side fingerprinting, making sure users always get the correct, up-to-date scripts after a deployment.

How Assemblysoft helps

Assemblysoft can review your existing Blazor or ASP.NET setup and:

Upgrade you to .NET 10, ensuring static assets and Blazor scripts are using the latest performance improvements.

Host and optimise your apps on Azure as part of a broader Microsoft Azure development strategy.

Design new solutions with these optimisations baked in from day one through full-stack Blazor development.

2. Smoother Navigation, Less Friction for Users

No more “jump to top” when you stay on the same page

Previously, if the app used Blazor’s interactive router and you navigated to the same page (for example, updating filters or query parameters), the browser would scroll back to the top.

In .NET 10:

Blazor preserves the scroll position for same-page navigations and forward/back navigation.

User benefit:
They keep their place in long forms, lists or reports, reducing frustration and accidental errors.

Navigation links that behave like users expect

Blazor’s NavLink component shows which page is active in the menu. In .NET 10:

NavLink can now ignore query strings and fragments (e.g. ?status=Approved), so the menu item stays active when only filters change.

Developers can still revert to old behaviour or implement custom rules when needed.

User benefit:
Navigation feels consistent and predictable, even on complex reporting pages where the URL changes frequently.

Clearer data tables with QuickGrid row styling

Blazor’s QuickGrid control now makes it far easier to:

Highlight rows based on business rules (e.g. overdue, high risk, archived).

Apply CSS classes conditionally using a simple parameter (RowClass).

Business benefit:
Important items stand out visually — ideal for finance, operations, or case management screens where attention needs to go to the right records quickly.

How Assemblysoft helps

As .NET 10 Blazor experts, Assemblysoft can:

Refine your navigation and data grids to align with how your teams actually work.

Modernise older pages into clear, responsive Blazor UX that your users can trust.

Build new modules – dashboards, reporting screens, admin consoles – using modern full-stack Blazor patterns.

Learn more about our full-stack Blazor development services.

3. More Reliable Connections & Less Lost Work

Built-in reconnection experience

Real-world networks drop: Wi-Fi glitches, laptops sleep, VPNs disconnect. In .NET 10:

Blazor Web App templates now include a standard Reconnection UI out of the box.

Users see a clear message and progression of states (including a new “retrying” state).

Developers can fully customise the look and behaviour while still having a safe fallback.

Business benefit:
Users are less likely to assume “the system failed” and more likely to trust that it’s recovering safely.

Persisting state to avoid “flicker” and re-entry

Blazor often prerenders content on the server for fast initial load, then re-renders on the client. Without care, that can cause:

Flickering as data reloads.

Extra calls to back-end services.

Confusing states where information appears to change.

In .NET 10, Blazor introduces a declarative way to persist and restore state using attributes. This allows:

Data loaded during prerender to be reused, rather than fetched again.

Component state to be preserved across reconnections and enhanced navigations, where appropriate.

The upshot is simpler code for developers — and smoother, more reliable behaviour for users.

Circuit state persistence for long-running sessions

For server-side Blazor apps:

.NET 10 can persist the circuit state when a connection is paused or interrupted, then resume it later without losing unsaved work.

This is particularly valuable for:

Staff who multitask across browser tabs.

Field workers on mobile or unstable connections.

How Assemblysoft helps

Assemblysoft can:

Assess where users currently lose work or context and apply state persistence and reconnection patterns to minimise it.

Design new workflows that assume intermittent connectivity but protect business data.

Host and scale these solutions in Azure, integrating with wider Microsoft Azure development strategies, including identity, storage and monitoring.

4. Cleaner Operations, Better Deployments

Environments set at build-time for WebAssembly apps

In .NET 10:

Standalone Blazor WebAssembly apps can have their environment (e.g. Development, Staging, Production) set at build time via project configuration.

This aligns nicely with CI/CD pipelines:

Each environment can have different configuration, feature flags, endpoints or branding baked in.

Less reliance on headers or manual configuration tweaks after deployment.

More predictable PWA updates

Progressive Web Apps rely on service workers for offline support and caching. In .NET 10:

The Blazor PWA template now uses updateViaCache: 'none' when registering the service worker.

This avoids cases where the browser silently serves outdated service worker code from cache.

Business benefit:
Offline and PWA behaviour becomes more reliable after updates – crucial for scenarios where teams rely on offline capabilities in the field.

How Assemblysoft helps

Assemblysoft can:

Integrate Blazor apps into your DevOps pipelines, making use of build-time environments for safer releases.

Review your current deployment strategy and streamline it with Azure services and GitHub Actions.

Build or upgrade PWA-style Blazor apps that behave consistently across updates and devices.

Our wider platform and cloud capabilities are outlined in our Azure development services.

5. Stronger Security and Identity Options

Blazor in .NET 10 also improves the security story:

Updated sample solutions for Blazor Web Apps secured with:

OpenID Connect identity providers.

Microsoft Entra ID (Azure AD).

Windows Authentication.

Built-in support for passkeys (WebAuthn/FIDO2) via ASP.NET Core Identity:

Users can sign in using device-based authentication like biometrics or security keys.

Reduces reliance on passwords and phishing-prone credentials.

Guidance around:

Encrypted distributed token caches for web farms.

Integration with Azure Key Vault and managed identities.

Business benefit:
A stronger foundation for single sign-on, passwordless access, and compliance-ready security in Blazor-based systems.

How Assemblysoft helps

Assemblysoft can:

Design and implement modern identity flows in your Blazor and .NET 10 applications.

Integrate with Microsoft Entra ID, third-party identity providers, and secured APIs.

Combine authentication with robust operational controls on Azure, logging and governance.

6. Better Observability, Validation & API Governance

Deeper metrics and diagnostics

.NET 10 introduces richer metrics and tracing for Blazor apps, covering:

Component lifecycle.

Navigation and event handling.

Circuit management and performance.

This makes it easier to:

Detect performance bottlenecks.

Understand how users actually move through the app.

Justify optimisation work with concrete data.

Stronger validation for forms and APIs

Blazor forms now support:

Validation of nested objects and collections, not just flat models.

A source-generated validation approach that’s compatible with ahead-of-time compilation.

Clearer, more consistent validation behaviour aligned with the broader .NET platform.

Minimal APIs gain:

Built-in validation support for query parameters, headers and bodies.

Consistent error responses using standard problem details.

Business benefit:
Higher data quality, fewer bad records, and more predictable behaviour for both internal and external consumers of your APIs.

How Assemblysoft helps

Assemblysoft can:

Introduce structured validation into your existing forms and APIs.

Align your applications with OpenAPI and .NET 10’s API features to support growth and external integrations.

Build new, API-first systems with strong validation and documentation baked in from the start.

7. Why Consider .NET 10 Blazor Now – and Why Partner with Assemblysoft

From a senior stakeholder perspective, the key message is:

Blazor in .NET 10 isn’t just a developer upgrade – it’s an opportunity to improve performance, reliability, security, and long-term maintainability of your business-critical systems.

The platform now better supports:

Fast, cache-friendly applications that feel modern and responsive.

Resilient user experiences that cope with real-world connectivity issues.

Secure, identity-aware solutions aligned with Microsoft’s latest recommendations.

Operational efficiency, with cleaner deployments and better diagnostics.

How Assemblysoft turns these features into business value

Assemblysoft specialises in:

Modernising existing systems

Upgrading ASP.NET and Blazor apps to .NET 10.

Restructuring front-ends with modern Blazor components (QuickGrid, improved routing, new validation).

Migrating hosting, identity and storage to Azure, leveraging best practices from our Microsoft Azure development services.

Building new, greenfield solutions

Designing and delivering full-stack Blazor applications, from UI to APIs, using the latest .NET 10 features.

Implementing rich dashboards, workflows, and complex forms with full-stack Blazor development.

Integrating with existing ERPs, CRMs and line-of-business systems.

Advisory, architecture & ongoing support

Providing strategic guidance on when and how to adopt Blazor in .NET 10.

Helping you phase modernisation to de-risk change while delivering early wins.

Offering ongoing support, optimisation and enhancement as your products evolve.

Looking for a partner to guide you into adding AI into your existing software applications?

At Assemblysoft we know how to simplifying AI concepts

Next Steps

If you’re:

Running an existing ASP.NET or Blazor application that’s starting to show its age, or

Planning a new internal platform, portal, or customer-facing system and want to use modern, Microsoft-backed technology,

then now is an excellent time to explore what Blazor in .NET 10 can do for you.

👉 Visit Assemblysoft to discover how our .NET 10 Blazor experts can help you modernise what you have or build what you need next – using the latest .NET, Blazor and Azure capabilities tailored to your business.

When Vibe Coding Projects Stall

It’s becoming increasingly common for organisations to approach us after a vibe coding project—promising rapid results and lower costs—has stalled before reaching production.

In many cases, the original delivery teams were sold on speed, with project estimates based on optimistic assumptions about the productivity of low-code or no-code tools. Unfortunately, clients often only discover these limitations once the budget is spent and the project still isn’t meeting operational or commercial requirements.

At Assemblysoft, we see this situation frequently—and the good news is that these projects can be recovered and delivered successfully.

The Value of Vibe Coding

Let’s be clear: we still see huge value in vibe coding tools. They are transforming how requirements, UX, and design come together by enabling rapid experimentation, visual feedback, and early user engagement.

Where they shine is in:

🧠 Prototyping and requirements discovery, where ideas are being tested, not finalised.

🚀 Exploratory or early-stage products, where market fit and feature direction are still evolving.

These are the environments where speed and iteration matter more than production-grade robustness—and vibe coding tools are unmatched in helping teams learn fast and pivot early.

Where Things Go Wrong

The challenges typically arise when organisations try to push these tools beyond their sweet spot—into fixed-deliverable projects that need reliability, integrations, and maintainability.

Some of the most common issues we see include:

⚙️ Over-optimistic assumptions about integrations and APIs — many connectors work well in demos but fail under real-world data and scale.

🧩 Missing migration or validation steps — data quality and schema transitions are often overlooked.

🔄 Weak DevOps, testing, and delivery discipline — vibe coding tools can obscure essential engineering rigour.

🧱 Limited experience taking a prototype to production — teams underestimate what it takes to operationalise and secure the solution.

None of these challenges are insurmountable—but they require the right engineering maturity, governance, and cloud expertise to bridge the gap from a prototype to a production-ready platform.

How Assemblysoft Can Help

At Assemblysoft, we specialise in getting stalled projects back on track by combining deep technical expertise with practical delivery experience.

Here’s how we help:

🧾 Due Diligence Reviews – We assess the current system, identify where the vibe coding approach has reached its limits, and map a clear route to production readiness.

🛠️ Managed Delivery Support – Our UK-based team provides hands-on engineering expertise to rebuild, integrate, and stabilise systems for sustainable operation.

💡 Hackathons & Workshops – We guide teams on using vibe coding tools effectively for requirement validation, prototyping, and stakeholder engagement—without overreaching their scope.

Our approach ensures you retain the speed and flexibility of your early work while introducing the engineering discipline and scalability needed to go live with confidence.

A Balanced Future for Vibe Coding

We remain genuinely excited about the potential of vibe coding tools. In fact, we use them internally at Assemblysoft for requirements discovery and prototyping, helping clients visualise and iterate on concepts quickly.

However, we’ve learned that the massive productivity curve peaks early—and teams need to transition to traditional engineering approaches for production. Being realistic about this curve helps ensure timely delivery, cost control, and long-term success.

If your project has lost momentum or needs expert guidance to reach production, Assemblysoft can help you regain control and move forward confidently.

Let’s Get Your Project Moving Again

If your organisation is struggling with a stalled vibe coding initiative, don’t start over—build on what’s already working.

Our specialists can help you:

Assess current progress and identify technical blockers.

Strengthen integrations, testing, and DevOps pipelines.

Transition from prototype to a scalable production environment.

👉 Contact Assemblysoft today to discuss how we can help you turn your stalled project into a success story.

In today’s fast-moving digital landscape, delivering seamless, secure, and scalable web applications is no longer optional—it’s essential. One critical aspect of modern web development is client-side data management, which directly impacts performance, user experience, and compliance. Business leaders and technology decision-makers need confidence that their applications handle data efficiently across sessions, browsers, and devices.

This article blog explores the differences between localStorage, sessionStorage, and cookies—three client-side storage mechanisms that every organisation should understand when building high-performing web applications. From persistent user preferences to secure authentication tokens, each approach carries unique strengths, limitations, and security considerations.

At Assemblysoft, a leading Blazor development company, we specialise in helping organisations modernise applications using .NET and Blazor. If you’re looking to hire Blazor developers who understand both technical depth and business impact, our UK-based team can deliver solutions that are secure, scalable, and future-proof.

In modern web development, managing data on the client side has become an essential skill. Developers often rely on localStorage, sessionStorage, and cookies to store data in the user’s browser. While these three mechanisms serve similar purposes, they have distinct differences in terms of capacity, persistence, and use cases. In this blog, we'll explore these differences, with examples, to help you better understand when and how to use each one.

1. localStorage: Persistent Client-Side Storage

Purpose: localStorage is designed to store data on the client side that persists even after the browser is closed. It's an excellent choice for data that needs to be retained across multiple sessions.

Capacity: localStorage offers substantial storage space, typically up to 10MB per domain, which is sufficient for most applications.

Persistence: Data stored in localStorage remains available until explicitly deleted by the user or the application. This makes it ideal for storing user preferences, like theme settings, that should persist across different visits to the site.

Example: Suppose you have a web application that offers both light and dark modes. You can use localStorage to save the user's preference so that the next time they visit, the site automatically loads in their chosen mode.

2. sessionStorage: Temporary Session-Based Storage

Purpose: sessionStorage also stores data on the client side, but it is limited to the duration of the page session. This means the data is cleared when the user closes the browser tab or window.

Capacity: Similar to localStorage, sessionStorage provides around 5MB of storage per domain. Although the capacity is smaller, it's often sufficient for temporary data.

Persistence: The key difference between sessionStorage and localStorage is persistence. sessionStorage data is only available for the duration of the page session, making it suitable for storing temporary data that doesn't need to persist beyond the current session.

Example: Imagine a multi-step form where users input data across several pages. You can use sessionStorage to temporarily store the form data as the user progresses through the steps. This ensures that if they accidentally reload a page, they don’t lose their progress.

// Save form data temporarily in sessionStorage
sessionStorage.setItem('step1Data', JSON.stringify({ name: 'John Doe', age: 30 }));

// Retrieve the saved data
const step1Data = JSON.parse(sessionStorage.getItem('step1Data'));
console.log(step1Data); // Output: { name: 'John Doe', age: 30 }

At Assemblysoft, our expert team provides guidance and delivery for organisations seeking to build or modernise with Blazor. Whether you’re transforming a legacy monolith, introducing interactive Blazor UIs, or scaling your SaaS product, we can help. If you’re ready to hire Blazor developers with proven experience in delivering secure, modern, and business-aligned solutions, we’re here to partner with you.

3. Cookies: Small, Persistent Storage with Server Interaction

Purpose: Cookies are used to store small pieces of data that need to persist across sessions and can be sent with HTTP requests to the server. They are often used for tracking user sessions, storing authentication tokens, and remembering user settings.

Capacity: Cookies are much smaller in capacity compared to localStorage and sessionStorage, with a limit of 4KB per cookie. However, multiple cookies can be stored, each with this limit.

Persistence: Cookies have a configurable expiration time. They can either expire at the end of a session or persist for a specified duration. This flexibility allows cookies to be used for both short-term and long-term storage.

Example: A common use of cookies is to store a user’s login token, which allows the user to stay logged in across sessions without having to re-enter their credentials every time they visit the site.

// Set a cookie with an expiration date
document.cookie = "username=JohnDoe; expires=Fri, 31 Dec 2024 23:59:59 GMT; path=/";

// Retrieve the cookie value
const cookies = document.cookie.split(';').reduce((acc, cookie) => {
    const [key, value] = cookie.trim().split('=');
    acc[key] = value;
    return acc;
}, {});
console.log(cookies.username); // Output: JohnDoe

When to Use Each Storage Mechanism

localStorage:

Use when you need to store large amounts of data that should persist across multiple sessions and are not sensitive (e.g., user preferences, non-sensitive application state).

sessionStorage:

Ideal for temporary data that should only persist for the duration of the user’s session (e.g., single-session form data, temporary state).

Cookies:

Best for storing small pieces of data that need to be sent to the server with HTTP requests or need a specific expiration (e.g., authentication tokens, user preferences that need to interact with the server).

Conclusion

Understanding the differences between localStorage, sessionStorage, and cookies is crucial for making the right choice in your web applications. Each has its own strengths and limitations, and knowing when to use each one will help you build more efficient, user-friendly applications.

👉 Start your journey with Assemblysoft, your trusted Blazor development company, and build applications that delight users while delivering measurable business value.

🚀 Ready to Build with Blazor?

Looking for a partner who understands both the technology and business impact of modern application development?

👉 Hire Blazor Developers at Assemblysoft — your UK-based Blazor development company, helping you deliver secure, scalable, and user-friendly applications.

Let’s turn your next project into a success story.

Why Blazor?

Choosing Blazor as your web platform means you’re invested in a modern, full-stack .NET solution — where your developers can build interactive, client-rich web applications using C# instead of JavaScript.

But here’s the challenge many businesses face:

"What happens when we want to support different customers, brands, or design systems — but don’t want to rebuild our entire application?"

This is where a modular, configurable Blazor UI strategy becomes a game-changer.

Imagine This Scenario

You're a software provider, consultancy, or platform builder. Over time, you’re asked to:

✅ Support white-labeled interfaces for clients
✅ Provide a lightweight version of your app for low-bandwidth environments
✅ Migrate a legacy Bootstrap UI to a modern material look (e.g., MudBlazor or Telerik)
✅ Trial a new UI library internally without breaking your production system

With a traditional approach, this could mean separate codebases, duplicated logic, and a huge maintenance overhead.

The Solution: UI Abstraction + Runtime Selection

At Assemblysoft, we have been helping a selection of forward-thinking clients to not only structure their Blazor apps to separate business logic from UI components, but to also enable the entire UI Framework to be selected at runtime, depending on the scenario.

Why Multiple UI Targets Are Sometimes Necessary

Why Multiple UIs Matter

White-Labeling for Clients - Different branding, color schemes, or design systems per client

Licensing Models - Open-source vs. commercial component libraries (e.g., free tier uses Bootstrap, paid tier gets Telerik)

Performance Profiles - Use a lighter UI (e.g., Bootstrap) for mobile users or emerging markets

Department Preferences - Marketing prefers Bootstrap, IT prefers MudBlazor, Finance uses Syncfusion grids

Testing & Prototyping - Try out newer libraries like AntDesign or Blazorise without affecting production

What Stays the Same?

Your business logic, services, models, and data access all stay untouched. Only the UI layer adapts — and it does so dynamically.

Business Benefits at a Glance

🎯 One Core System - Build once, adapt visually for each use case

🎨 Custom Branding - Deliver branded UIs for clients, partners, or internal teams

🏎️ Optimised Performance - Load only what's needed — faster apps, lower hosting costs

💸 Reduce Cost & Risk - Avoid duplicated code, multiple deployments, and diverging branches

🔁 Future-Proofing - Swap or test new frameworks (e.g., DevExpress, AntDesign) without lock-in

How It Works (High-Level)

UI Components are separated into modular units (via Razor Class Libraries)

Configuration settings determine which UI framework is used (e.g., "MudBlazor", "Telerik", "Syncfusion")

At runtime, only the relevant UI assets, scripts, and libraries are downloaded

The app looks and feels different — but the backend remains the same

🔀 One System, Many UI Experiences — All Configurable

With Assemblysoft’s modular Blazor architecture, every part of your application can be independently configured to use the UI framework that best suits its audience or purpose — all while sharing the same backend, services, and business rules.

For example, you could:

• ✅ Use Bootstrap for a fast-loading, minimal public portal
• ✅ Use Telerik for a polished enterprise dashboard
• ✅ Use Syncfusion where complex data grids or export capabilities are essential
• ✅ Use MudBlazor internally for teams that prefer a modern, material design system

And here's the key:
Each of these areas could be configured to use any supported UI framework — not just the one listed above.

Whether it's your dashboard, portal, admin panel, or internal tools, each can run its own UI framework without duplicating code or forking the application.

💡 All without rewriting the application.

Each UI layer is:

• 🔧 Configurable at runtime or per deployment
• 🐇 Lazily loaded to avoid unnecessary bloat
• 🔄 Connected to the same service and data infrastructure

📱 Extend Your Blazor App with .NET MAUI Blazor Hybrid

Your UI flexibility doesn't stop at the browser. With .NET MAUI Blazor Hybrid, you can bring your existing Blazor components to desktop and mobile platforms — without rewriting your codebase.

Blazor Hybrid allows you to:

• 📱 Run your Blazor UI inside a native mobile or desktop app (Windows, macOS, Android, iOS)
• 🔄 Reuse your existing components and service layer
• 🧩 Plug in any of the supported UI frameworks (MudBlazor, Telerik, Bootstrap, etc.) — just like on the web
• 🔐 Secure and distribute apps via native app stores or enterprise channels

Why this matters:

• You can deliver a consistent experience across web, desktop, and mobile — with tailored UI frameworks per platform.
• For example, use Telerik in your enterprise web dashboard and MudBlazor for your internal MAUI field app — all from a shared codebase.

Whether you're building public-facing portals, internal tools, or offline-capable mobile apps, .NET MAUI Blazor Hybrid provides the reach you need, while preserving the architecture you've already invested in.

Assemblysoft helps clients bring their Blazor apps to mobile and desktop using .NET MAUI — with runtime UI framework selection intact.

🔗 Talk to us about cross-platform Blazor

🔄 Introducing or Swapping UI Frameworks Per Client or Scenario

With a modular Blazor architecture, you gain the ability to introduce a new UI framework or swap out an existing one — without disrupting the entire application or duplicating code.

This makes it easy to tailor the user experience for specific clients, brands, or business contexts. Here's a practical example:

🧠 Example: A Blazor App with 3 Client-Specific UIs

Each of these UIs:

• Uses the same shared backend, services, and data models
• Loads only the assets needed for its specific UI framework (via lazy loading)
• Can be configured at runtime or per deployment

🔧 Adding a New Framework Later — No Rebuild Required

Let’s say a new client joins and they prefer a different visual style — for example, something that matches their brand guidelines or internal systems.

With our flexible setup, we don’t need to rebuild the entire application. Instead, we simply:

1. Add a new design layer that matches their preferred look and feel
2. Connect it to the existing logic and features already powering the application
3. Set up the app to use that new design automatically for that specific client

Once this quick setup process is complete, switching between design frameworks becomes as easy as changing a setting.
Need to go back to a previous style? Just update the configuration — no code changes required.

The result?
The new client sees the app exactly how they want — while everything underneath (data, workflows, and business rules) stays the same.

This means we can support different clients with completely different user experiences — all from the same core system, and without costly redevelopment.

🪄 Swap Anytime, Without a full Rewrite

Need to replace MudBlazor with Blazorise for your internal tools? No problem.
Want to try DevExpress for reporting? Just configure it for your reporting module.

Each part of the application can evolve independently, which means your app becomes more adaptable, testable, and maintainable — long term.

All powered by the same codebase, running in the same hosting environment — saving you money, time, and stress.

Why Assemblysoft?

We’re not just Blazor experts — we’re business enablers. At Assemblysoft, we build Blazor apps that:

✅ Support multiple brands or teams

✅ Perform at scale across devices

✅ Are maintainable, testable, and future-ready

🔗 Learn more about our Blazor solutions
🔗 Partner with Assemblysoft today

Why Waiting on Data Is Costing You

In today's fast-moving digital landscape, timely access to accurate data is the edge your business needs. Whether you're overseeing operations, driving strategy, or delivering value to customers, delays in accessing key business metrics can result in missed opportunities, poor forecasting, and reactive decision-making.

Change Data Capture (CDC) is a powerful yet low-impact technology built into SQL Server and Azure SQL Managed Instance that helps you break free from lagging data. It allows changes in your business systems—like sales, customer updates, or inventory adjustments—to instantly flow into your reporting tools, dashboards, and integrations.

Real-Time Data, Real-World Impact

Know immediately when a customer record is updated, a sale is made, or inventory drops below threshold. With CDC in place, these insights can flow instantly into your decision-making tools, enabling more responsive customer service, improved operational efficiency, and proactive business planning.

At Assemblysoft, we help you unlock these capabilities without risk. Our UK-based team specializes in aligning CDC strategies with your business goals—whether you're modernizing a legacy ERP system or integrating with third-party platforms.

What Is CDC, in Simple Terms?

Change Data Capture (CDC) is a method of tracking changes made to your data—such as inserts, updates, and deletes—in real time. Rather than constantly querying entire tables to see what's changed, CDC monitors your SQL Server's transaction log behind the scenes and stores just the changes in a special structure.

These tracked changes can then be used to sync systems, update reports, or power real-time apps—all without rewriting or redeploying your existing software.

Think of CDC as a smart data mirror—it only reflects what’s changed, helping your team act on fresh insights faster.

Business Benefits of CDC

CDC Helps Delayed Reports Automatically feed data into dashboards like Power BI or Excel in near real-time Manual Syncing Eliminate spreadsheets or overnight batch jobs for syncing data across systems Compliance & Auditing Capture every change to sensitive data for full traceability Modernization Without Risk

Start using real-time data without replacing your current systems

Assemblysoft’s CDC Enablement Services

We guide businesses through every stage of adopting CDC—tailored to your environment and goals.

🔧 Assessment – We evaluate your current SQL Server (on-prem or cloud) for CDC readiness

🚀 Implementation – We enable CDC on your databases and help configure safe, secure pipelines

🧩 Integration – We connect your change-tracked data into your BI tools, ETL jobs, or custom apps

🛡️ Monitoring & Support – We help set up job monitoring and retention policies for ongoing reliability

Whether you’re running SQL Server 2016+ on-prem or Azure SQL Managed Instance, our UK-based team ensures a seamless transition to real-time operations.

Under the Hood: How CDC Works (For Technical Teams)

Data flow

The following illustration shows the principal data flow for change data capture.

The source of change data for change data capture is the SQL Server transaction log. As inserts, updates, and deletes are applied to tracked source tables, entries that describe those changes are added to the log. The log serves as input to the capture process. Then, it reads the log and adds information about changes to the tracked table's associated change table. Functions are provided to enumerate the changes that appear in the change tables over a specified range, returning the information in the form of a filtered result set. The filtered result set is typically used by an application process to update a representation of the source in some external environment.

Once enabled, CDC works by:

Reading the transaction log for INSERT, UPDATE, and DELETE operations

Populating change tables that mirror your original tables, but include metadata (timestamp, operation type, etc.)

Exposing SQL functions that developers or ETL tools can call to query what’s changed over a specific time window

Each tracked table becomes a "capture instance" with its own change table and functions like:

fn_cdc_get_all_changes_<table> – all changes between LSNs

fn_cdc_get_net_changes_<table> – net result of changes per row (optional)

Feature Comparison Table

🕒 Retention and Cleanup
CDC keeps changes by default for 3 days using a cleanup job that runs nightly. This can be configured to align with your storage, performance, and compliance needs.

🔄 Multiple Schema Versions
CDC can track schema changes and support two capture instances per table, allowing old systems and new systems to run in parallel during transitions.

⚙️ Minimal Overhead
Since CDC reads from the log, it avoids impacting your day-to-day operations. SQL Server Agent must be enabled to support the capture and cleanup processes.

Better Decisions Without Rebuilding Your Systems

Rather than replacing your core systems—which can be risky and expensive—CDC enables incremental modernization. It works with your existing SQL Server or Azure SQL databases to feed downstream systems such as Power BI, Salesforce, or custom dashboards, without touching your application code.

A Strategic Enabler for Digital Transformation

For business leaders, the real power of CDC lies in its ability to future-proof your data strategy. It enables your systems to work together in real time without duplication or disruption. As part of your modernization journey, CDC becomes a stepping stone to cloud adoption, automation, and real-time business intelligence.

Ready to Unlock the Power of Change?

At Assemblysoft, we believe in smart, sustainable modernization. CDC is just one of the many technologies we use to help our clients extract more value from their data, systems, and people.

🔍 Whether you're planning a move to Azure or improving your on-prem SQL Server environment, we can help implement CDC with confidence, clarity, and measurable results.

👉 Get in touch with our team today for a free consultation and see how CDC can transform the way your business sees and uses data.

Conclusion

In today's competitive landscape, access to up-to-date information is no longer a luxury—it's a necessity. Business owners often face delays in getting accurate data into reporting tools, CRMs, or compliance dashboards. Change Data Capture (CDC) solves this by ensuring that data changes are automatically tracked and delivered in near real-time, giving decision-makers a live view of the business.

Whether you're running operations on-premises or in the cloud with Azure, CDC enables fast, accurate data movement between systems without disrupting day-to-day activities. That means more timely reporting, better forecasting, and faster reactions to emerging trends or risks.

Related Links for Further Reading

Assemblysoft Custom Software Development

Fullstack Blazor Development

Assemblysoft Home

API & Integration Services

Proven architecture patterns for performance, scalability, and great UX when your components can run on the server and in the browser.

Introduction

.NET 8 introduced one of the most important evolutions in Blazor: multiple render modes per component. It’s now possible to combine static server-side rendering (SSR), Blazor Server, and Blazor WebAssembly (WASM) within a single application.

Used well, this unlocks faster first paint, progressive enhancement, and resilient user experiences. Used poorly, it introduces duplicated data loads, unnecessary HTTP hops, and subtle UX inconsistencies.Assemblysoft perspective: we apply mixed render modes in production systems (dashboards, workflows, field-first experiences, and SaaS modules). The consistent differentiator is intentional data-flow architecture and keeping interactive components lean. Explore our work and approach at Assemblysoft Blazor Development and Software Modernisation.

Render Modes in .NET 8 and Beyond

Blazor now supports running components in several distinct execution models:

• Static Server-Side Rendering (SSR)
• Blazor Server
• Blazor WebAssembly (WASM)
• InteractiveAuto (WASM if available, otherwise Server)

In practice, this enables the best of both worlds: fast initial rendering from the server, and a rich interactive experience that can shift to WASM when available.

What InteractiveAuto Really Does

When you mark a component with @rendermode InteractiveAuto, Blazor can render it multiple times across environments. The typical lifecycle looks like this:Syntax error in textmermaid version 10.9.5

Key implication: component initialisation can run more than once. Data fetching must be designed to avoid duplication and flicker.

@rendermode InteractiveAuto

A Business-Oriented Example: Loading a Dashboard Summary

Rather than a weather demo, here’s a realistic line-of-business scenario: loading a Dashboard Summary used to power KPI cards.

@page "/dashboard"
@rendermode InteractiveAuto
@inject HttpClient HttpClient

<h1>Business Dashboard</h1>

@if (_dashboardSummary == null)
{
    <p><em>Loading summary…</em></p>
}
else
{
    <DashboardSummaryView Model="_dashboardSummary" />
}

@code {
    private DashboardSummaryModel? _dashboardSummary;

    protected override async Task OnInitializedAsync()
    {
        _dashboardSummary = await HttpClient
            .GetFromJsonAsync<DashboardSummaryModel>("api/dashboard/summary");
    }
}

Two problems show up quickly in production

• Problem 1: Duplicate data fetching. Prerender fetch + interactive fetch = double load and possible KPI flicker.
• Problem 2: Server-to-server HTTP calls. When running on the server, the component still calls your own API via HTTP.

In real delivery work, these issues disproportionately affect the “first impression” screens—dashboards, landing pages, project overviews—where UX matters most. For examples of outcomes achieved in production systems, see Assemblysoft case studies.

Best Practice 1: Persist State Across Render Modes

Use PersistentComponentState to prevent duplicate loads by persisting data fetched during prerender and restoring it during interactive startup.

@inject PersistentComponentState AppState
@implements IDisposable

@code {
    private DashboardSummaryModel? _dashboardSummary;
    private PersistingComponentStateSubscription _persistSubscription;

    protected override async Task OnInitializedAsync()
    {
        _persistSubscription = AppState.RegisterOnPersisting(PersistDashboardSummary);

        var restored = AppState.TryTakeFromJson<DashboardSummaryModel>(
            "dashboard-summary", out var cachedSummary);

        _dashboardSummary = restored
            ? cachedSummary
            : await HttpClient.GetFromJsonAsync<DashboardSummaryModel>("api/dashboard/summary");
    }

    private Task PersistDashboardSummary()
    {
        AppState.PersistAsJson("dashboard-summary", _dashboardSummary);
        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _persistSubscription.Dispose();
    }
}

Client (Interactive)PersistentComponentStateServer (Prerender)Client (Interactive)PersistentComponentStateServer (Prerender)Load DashboardSummaryModelPersist "dashboard-summary"Restore "dashboard-summary"Render without refetch

Outcome: one fetch, stable KPI values, and reduced flicker. This is a common baseline optimisation in Assemblysoft dashboard builds.

Best Practice 2: Eliminate Server-Side HTTP with a Business Abstraction

Avoid server-to-server HTTP by abstracting the data load behind an interface. Provide two implementations: a direct server implementation and an HTTP-based client implementation.

Shared contract

public interface IDashboardSummaryService
{
    Task<DashboardSummaryModel?> LoadAsync();
}

Client implementation (HTTP)

public class ClientDashboardSummaryService : IDashboardSummaryService
{
    private readonly HttpClient _http;

    public ClientDashboardSummaryService(HttpClient http)
    {
        _http = http;
    }

    public Task<DashboardSummaryModel?> LoadAsync()
        => _http.GetFromJsonAsync<DashboardSummaryModel>("api/dashboard/summary");
}

Server implementation (direct domain/data access)

public class ServerDashboardSummaryService : IDashboardSummaryService
{
    public Task<DashboardSummaryModel?> LoadAsync()
    {
        // Direct database / domain access (EF Core, repositories, etc.)
        return Task.FromResult(new DashboardSummaryModel());
    }
}

Blazor ComponentIDashboardSummaryServiceClientDashboardSummaryService
HTTPServerDashboardSummaryService
Direct AccessAPI EndpointDatabase

This pattern improves performance and observability by removing unnecessary internal HTTP hops—especially important in high-traffic dashboards.

Assemblysoft commonly applies this approach when building modern line-of-business systems and multi-tenant SaaS modules. Learn more at Assemblysoft Software Development.

A Simpler (Often Better) Pattern: Server Host + Interactive Child

In many real-world screens, the cleanest approach is to separate responsibilities:

• Host component: server-only, fetches data directly
• Child component: interactive, receives data via parameters and focuses on UX

Server-only host component

@page "/dashboard"
@inject IDashboardSummaryService DashboardSummaryService

<DashboardSummaryPanel
    Model="_dashboardSummary"
    @rendermode="InteractiveAuto" />

@code {
    private DashboardSummaryModel? _dashboardSummary;

    protected override async Task OnInitializedAsync()
    {
        _dashboardSummary = await DashboardSummaryService.LoadAsync();
    }
}

Interactive child component (no fetching, no persistence plumbing)

@code {
    [Parameter]
    public DashboardSummaryModel? Model { get; set; }
}

Syntax error in textmermaid version 10.9.5Why Assemblysoft recommends this pattern: fewer moving parts, clearer separation of concerns, easier testing, and excellent UX. This is particularly effective for dashboards, planners, and workflow screens that need interactivity without re-implementing data access logic in every render mode.

How Data Crosses Render Mode Boundaries

When a server-rendered host passes parameters to an Auto-rendered child, Blazor serialises parameters, embeds them into the HTML payload, and rehydrates them on the client during interactive startup. You design for this behaviour by keeping the child component parameter-driven.

Practical takeaway: interactive components should generally avoid owning data-fetch responsibilities unless there is a strong reason.

When InteractiveAuto Delivers the Most Value

Based on delivery experience, InteractiveAuto is most valuable when:

• Users perform meaningful interaction (forms, planners, filters, editable grids)
• You want WASM performance benefits when possible, but need reliable fallback
• First paint and perceived responsiveness matter (dashboard/landing screens)
• Connectivity is variable and resilience is required

For purely read-only content, static SSR is often sufficient—and may reduce operational complexity.

Why Assemblysoft Takes a Deliberate Render Strategy

Blazor render modes are an architectural tool, not a novelty feature. Assemblysoft designs render strategies into:

• Legacy system modernisation programmes
• Multi-tenant SaaS platforms
• Field-first applications and offline-capable modules
• High-performance executive dashboards

If you are planning a Blazor build or modernisation and want to avoid rework while delivering a great UX, you can speak with Assemblysoft here: https://assemblysoft.com/contact.

Final Summary

Blazor Auto render mode enables fast, resilient, user-friendly applications—when paired with the right architecture.

• Use PersistentComponentState to prevent duplicate loads and avoid KPI flicker
• Abstract business logic behind interfaces to support both server-direct and client-HTTP execution
• Avoid server-side HTTP where possible to reduce latency and tracing noise
• Prefer the server host + interactive child pattern for clarity and maintainability

These patterns are proven in production and are designed to keep UX smooth while controlling operational complexity.

Deploying Entity Framework Migrations in Production: Best Practices for Reliable .NET Apps

Deploying database schema changes in production environments can be risky without the right strategy. Entity Framework Core (EF Core) provides several ways to apply migrations, but not all are production-safe. At Assemblysoft, we specialize in .NET modernization and help businesses implement reliable deployment pipelines for EF Core using proven practices.

In this article, we'll explore the various strategies for applying migrations to production databases, when to use each, and how Assemblysoft can support your team in adopting these best practices.

Why Migrations Matter

EF Core migrations allow developers to evolve their database schema over time in a controlled and repeatable manner. However, in production environments, this needs to be handled carefully to avoid:

Data loss

Downtime

Schema inconsistencies across environments

That’s where the right deployment approach becomes critical.

1. SQL Scripts – The Gold Standard

SQL script generation is the recommended method for applying migrations in production:

Benefits:

Reviewable: Scripts can be manually reviewed and approved before execution.

Auditable: Supports change tracking and versioning.

Safe: Reduces the risk of runtime surprises.

Customizable: Tailor queries for environment-specific considerations.

Automation Ready: Integrate with CI/CD tools like GitHub Actions or Azure DevOps.

Example:

dotnet ef migrations script -o migrate.sql

You can also generate idempotent scripts for multi-tenant or distributed environments:

dotnet ef migrations script --idempotent -o migrate-safe.sql

✅ Learn how Assemblysoft helps automate SQL-based deployments

1. Migration Bundles – Modern & Flexible

EF Core 6+ introduced migration bundles, which compile your migrations into a standalone executable. Perfect for:

Deployment teams without .NET SDK installed

Environments with limited access

CI/CD pipeline integration

Benefits:

Self-contained: No EF tooling or SDK required

Environment-independent: Works across dev, test, and production

Scriptless: Ideal for infrastructure teams who prefer binary tools

Example:

dotnet ef migrations bundle --self-contained --target-runtime win-x64
.\efbundle.exe --connection "YourConnectionString"

🔧 Assemblysoft can help integrate this into your CI/CD process using GitHub Actions and deployment stages.

1. Command-line Tools – Good for Dev, Not Prod

Tools like Update-Database or dotnet ef database update work well during development but are not suited for production:

Risks:

Immediate schema changes with no review

Requires project source code and SDK on the production server

Limited rollback capability

We recommend reserving these tools for local and QA environments.

1. Runtime Migrations (MigrateAsync()) – Use Caution

Applying migrations programmatically at app startup using context.Database.MigrateAsync() can be tempting—but it’s rarely safe in production:

Why It’s Risky:

Requires elevated DB permissions

No rollback safety

Potential concurrency issues in load-balanced environments

using (var scope = host.Services.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService();
await db.Database.MigrateAsync();
}

🚫 Avoid using this in production pipelines.

1. 🧪 Development Mode Checks – The Best of Both Worlds

During development, it’s beneficial to auto-apply migrations to streamline testing and schema evolution. However, this should be gated by a check to ensure the app only does this in safe environments.

if (env.IsDevelopment())
{
using var scope = host.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
await db.Database.MigrateAsync();
}

This allows teams to enjoy seamless developer experience while maintaining strict controls in production. Combined with Git-based migration reviews, this pattern offers a healthy balance between agility and safety.

⚙️ Assemblysoft helps implement dev-safe patterns like this across Blazor and .NET solutions.

Assemblysoft: Your .NET Migration Experts

At Assemblysoft, we help teams implement secure, scalable, and automated database migration workflows using:

CI/CD pipelines with GitHub Actions or Azure DevOps

SQL script generation with review gates

Self-contained bundles for repeatable execution

Environment-based rollout strategies

Dev-mode safety checks for faster iteration

Our UK-based team of experienced developers and architects work closely with you to ensure your .NET applications evolve safely—without disrupting business continuity.

📌 Explore our Fullstack Blazor Development or Custom Software Development Services to see how we can help modernize your stack.

Conclusion

EF Core migrations are a powerful way to manage evolving database schemas—but only if used correctly. By adopting SQL scripts or bundles, adding dev-mode checks, and avoiding runtime risks in production, your team can ensure seamless, zero-downtime updates.

When you're ready to take your .NET application lifecycle to the next level, Assemblysoft is here to help.

The Future of User Interfaces Starts Now

At Assemblysoft, we’ve always been passionate about combining innovation with practicality. Today, we’re stepping beyond traditional chatbots and introducing a game-changing concept: enabling users to interact with Blazor applications using natural language—and even their voice—to manipulate user interface components in real-time.

But before you can envision this in action, you need to understand what makes large language models (LLMs) truly powerful—and why we’ve integrated them into our Blazor and AI solutions.

What This Means for Business Owners

You don’t need to be a developer to appreciate the impact of this technology. Here’s what natural language interfaces mean for your business:

1. Faster User Adoption

Employees can interact with your systems using plain language—whether typed or spoken. This reduces training time and speeds up onboarding, particularly for users less familiar with software tools.

2. Improved Productivity

By removing the need to click through multiple menus or memorize complex workflows, users get straight to what they need. This saves time, reduces errors, and helps teams focus on outcomes rather than interfaces.

3. Accessibility by Default

Voice input and natural language commands allow more people to engage with your systems—especially those who rely on assistive technology. It’s a modern, inclusive approach that aligns with digital accessibility standards.

4. Global-Ready

Because AI understands multiple languages, your platform becomes instantly adaptable to users across different regions and backgrounds. This supports international teams and future-proofs your solution for global expansion.

5. Smarter Customer Service

Imagine your internal support tools or CRM being operated by voice or simple instructions—no menus, no complexity. Customer service teams get faster access to data, leading to quicker resolution times and better experiences.

6. AI Without the Hype

Assemblysoft takes proven Microsoft-backed technologies and implements them into your business applications responsibly. We don’t promise magic—we deliver results through expert engineering and real-world testing.

Beyond Chat: What Can a Large Language Model Really Do?

Chatbots are often seen as the pinnacle of LLM capabilities—but that’s just scratching the surface. At Assemblysoft, we leverage LLMs not just for conversation, but to translate natural language into structured instructions, such as generating or modifying code, JSON objects, or UI states.

These models are trained on billions of tokens of text, enabling them to understand context, semantics, and even intent. Whether it's translating English to German or reconfiguring a UI component with a simple spoken instruction, LLMs can reason across language and structure.

From Text to UI: Real-Time State Manipulation

In a Blazor application, many components expose a state object—typically serialized as JSON. Instead of requiring users to navigate complex menus or press multiple buttons, we allow them to say something like:

“Show me customers from page five.”

The LLM translates this into a structured JSON response:

jsonCopyEdit{  "page": 5}

Our application then applies this JSON to update the UI—no clicks required.

This isn’t just a gimmick. It's a profound shift in how users interact with data-driven components.

Natural Language Interfaces in Blazor

With Blazor, we can harness these AI-powered interactions directly in a browser-based .NET app. Here’s what we do at Assemblysoft to make this seamless:

Embed an AI-powered service using Microsoft.Extensions.AI

Feed user input (voice or text) into the AI pipeline

Translate that input into structured grid state updates

Apply the updated state via Blazor’s component APIs

We've implemented this with full support for paging, filtering, sorting, and grouping—turning a data grid into an AI-responsive interface that adapts to how the user thinks, not how they click.

Speech-to-UI: Accessible, Inclusive, and Smarter

To make things even more intuitive, we’ve added speech-to-text capabilities using browser-native APIs and open-source tools like Blazorators. This allows users to speak commands like:

“Sort by city in ascending order.”

The spoken words are transcribed, sent to the AI, and applied to the UI. No mouse, no keyboard—just voice.

This also provides immense accessibility benefits, making software more usable for those who rely on assistive technologies or have difficulty navigating traditional UI paradigms.

Secure, Scalable, and Future-Proof

Everything we’ve built integrates securely with Azure OpenAI through Microsoft's Extensions.AI library. This gives our clients:

A plug-and-play AI abstraction for LLMs

Full compatibility with .NET 10 and beyond

Easy migration paths to multi-modal models in future updates

As .NET keeps evolving, we’re already preparing our solutions to support multi-lingual speech input natively—no extra infrastructure needed.

Why Choose Assemblysoft?

At Assemblysoft, our UK-based development team excels in bringing together cutting-edge technology and real business outcomes. We help modernize .NET applications, build secure APIs, and create intelligent, intuitive frontends using Blazor—all while ensuring your investment is future-ready.

Whether you’re:

Looking to integrate AI into your UI,

Want to simplify complex interactions,

Or aiming to enhance accessibility across your software stack...

We can help you lead the way.

Let’s Talk About Your Next AI-Driven .NET Project

Ready to explore how natural language and AI can elevate your applications?

📞 Contact Assemblysoft
💻 Learn more about Fullstack Blazor Development
🚀 Explore our Custom Software Development Services
📚 Dive into the future with Microsoft.Extensions.AI

Introduction

In today's digital landscape, businesses are driven by APIs. Whether you're building a public-facing SaaS platform or modernizing legacy systems, your API is the contract between your services and the outside world. At Assemblysoft, we help organizations of all sizes design, implement, and operate Web APIs that are secure, scalable, and built to last.

Through our custom software development services, we partner with you to deliver APIs that meet your unique needs—adhering to RESTful principles, enabling platform independence, and ensuring long-term maintainability. This article explores our API-first approach, featuring best practices, real-world tooling, and how our UK-based development team can help you succeed.

Why Design-First Matters

We believe in treating your API like a product. That means following a design-first approach using OpenAPI specifications. Before a single line of backend code is written, our developers and stakeholders agree on the API contract. This reduces friction, supports parallel development, and enables a better developer experience for consumers.

At Assemblysoft, every API we build starts with:

OpenAPI-driven design

API contract validation in CI/CD pipelines

Mocking with tools like Prism or Stoplight

Clear versioning and lifecycle documentation

Seamless integration with Azure API Management (APIM)

Learn more about our fullstack Blazor development and API integration expertise.

The 15 Golden Rules of Web API Operations

Assemblysoft’s API projects follow a battle-tested playbook. Here are just a few highlights:

Treat API Specs as Code – All contracts live in Git, reviewed via pull requests.

Validate OpenAPI Automatically – Catch errors early with CI linting tools like Spectral.

Automate Everything – From deployment to policy rollout via GitHub Actions or Azure DevOps.

Mock Early, Integrate Late – Empower front-end teams with mock servers before backends are ready.

Publish Consistently – We automate API documentation publication using SwaggerHub or ReDoc.

Monitor Usage and Performance – Observability is built-in using Azure Monitor or OpenTelemetry.

Scan for Vulnerabilities – Secure your APIs with tools like OWASP ZAP or Snyk during every build.

Canary & Blue/Green Releases – Deploy with confidence and roll back instantly if needed.

We don’t just build APIs—we help govern them through metadata standards, developer portals, and consumer feedback loops.

RESTful Design Done Right

Following industry standards and the Richardson Maturity Model, we target Level 3 maturity where appropriate. Our approach includes:

Clean, consistent URI design (e.g., /customers/123/orders)

Proper HTTP verb usage (GET, POST, PUT, PATCH, DELETE)

Support for content negotiation (JSON, XML)

Pagination, filtering, sorting, and projection query support

Asynchronous operation handling with polling and status endpoints

Versioning via URI, headers, or media types

Multitenancy using subdomains, headers, or claims

We also support HATEOAS where applicable, helping clients understand the "what's next" of your API.

Tools We Use to Power Your APIs

Assemblysoft leverages industry-leading tools to streamline API development and testing:

🛠️ Design: Swagger Editor, Stoplight Studio, Postman API Builder

🔐 Security: Azure API Management, Azure Key Vault, OAuth2, IdentityServer

🔬 Testing: Postman, Dredd, FluentAssertions, Playwright

🌍 .NET Integration: Swashbuckle, NSwag, JWT middleware, OpenTelemetry

We don’t just recommend tools—we use them every day to build and maintain robust APIs for our clients.

Your API, Built to Last

Working with Assemblysoft means more than just code delivery. We ensure:

Secure-by-default APIs with OAuth2, HTTPS, and token validation

Documentation that is versioned, published, and consumer-friendly

CI/CD pipelines that test, validate, and deploy across environments

Observability through logs, tracing, and health endpoints

Lifecycle governance for versioning, deprecation, and retirement

Check out how our clients are succeeding with modern, maintainable APIs by visiting assemblysoft.com.

Ready to Build Your API?

Whether you're launching a new product or modernizing a monolith, Assemblysoft brings deep expertise in Web API design and delivery. Our UK-based team is ready to guide your project from concept to production with proven best practices and real-world results.

Let us help you design APIs that developers love and businesses can rely on.

Contact Assemblysoft today to start your API journey with confidence.

Modernizing legacy applications is more than just a technology upgrade — it's a strategic move to future-proof your business. At Assemblysoft, we’ve helped numerous clients successfully migrate from aging platforms to modern Blazor-based applications, enabling them to streamline workflows, enhance user experiences, and embrace cloud and mobile architectures.

With our UK-based development team, we deliver solutions that are fast, secure, and scalable — backed by best practices and tailored to your organization’s needs.

Why Blazor?

Blazor is a modern UI framework built on .NET that allows you to develop rich, interactive web UIs using C#. By eliminating the dependency on JavaScript and enabling full-stack .NET development, Blazor bridges the gap between client and server-side logic, resulting in faster development and easier maintenance.

At Assemblysoft, we specialize in full-stack Blazor development that empowers businesses to leverage both Blazor Server and Blazor WebAssembly. With .NET 8’s support for multiple render modes, Blazor now offers unparalleled flexibility for building web applications.

9 Essential Blazor Best Practices

Here are the top strategies we apply at Assemblysoft when building or modernizing apps with Blazor:

1. Understand the Component Lifecycle

Understanding lifecycle methods like OnInitialized, OnParametersSet, and ShouldRender helps ensure your components behave predictably and efficiently. This knowledge is vital for managing when components render or refresh.

2. Find the Right Component Size

Start simple. Build your UI logic inside a single page, then break it down into reusable child components as complexity grows. Prioritize cohesion over file length to keep your code maintainable.

3. Implement Render Mode Agnostic Components

With .NET 8, you can mix Blazor Server and WebAssembly. Avoid setting render modes in reusable components. Instead, define them at the page or layout level to increase reusability across hosting models.

4. Learn Proper Event Handling

Use C# event handlers and ensure you unsubscribe from events like NavigationManager.LocationChanged to avoid memory leaks. For component-to-component communication, leverage EventCallback.

5. Choose Appropriate State Management

From simple parameters to complex state containers like Fluxor, your state management strategy should match your application’s complexity. Assemblysoft can help architect scalable patterns for shared state.

6. Polish Code Organization and Structure

Structure your Blazor solution with meaningful folder layouts and consistent naming conventions. Group related services, models, and components logically to improve discoverability and maintainability.

7. Secure Your Application

Implement ASP.NET Core Identity for robust authentication and authorization. Use HTTPS, never store raw passwords, and follow OWASP Top 10 guidelines to protect against common web vulnerabilities.

8. Use Proper Error Handling and Logging

Utilize structured logging with tools like Serilog to capture meaningful diagnostic data while excluding sensitive information. Implement global error boundaries to gracefully handle exceptions.

9. Keep It Simple

Favor straightforward solutions. For instance, pass data using component parameters before introducing shared services. Simplicity leads to clarity, less maintenance, and fewer bugs.

Component Libraries We Support

Assemblysoft offers expert integration with the industry's most powerful Blazor UI libraries, ensuring pixel-perfect, accessible, and performant UIs:

Library Highlights

Telerik UI for Blazor

100+ feature-rich components with performance-first architecture and enterprise-grade support.

MudBlazor

Lightweight Material Design components with great developer experience.

Blazorise

Supports multiple CSS frameworks (Bootstrap, Material, Bulma, etc.).

Syncfusion

Over 100 components including advanced data grids and visualizations.

Radzen

Enterprise-ready UI with low-code productivity features.

AntDesign Blazor

Elegant UI components based on Ant Design.

MatBlazor

Simple Material Design UI components.

Microsoft Fluent UI

Fluent Design components for accessible and consistent UI.

Blazored

A collection of reusable, open-source Blazor components and utilities.

We help you select the best library based on your design requirements, performance goals, and licensing model.

Why Choose Assemblysoft?

• 🧠 Deep Blazor Expertise: From Blazor Server to WebAssembly and Hybrid apps, we have hands-on experience across the stack.
  
  
• ☁️ Cloud-Native Architecture: We design for scalability using Azure services and modern CI/CD pipelines.
  
  
• 📱 Mobile-Ready UI: We support Blazor Hybrid for native mobile apps alongside responsive web experiences.
  
  
• 🔒 Secure by Design: Every solution we build adheres to security best practices and compliance expectations.
  
  

We offer more than just Blazor expertise — we’re a trusted partner for custom software development, capable of designing, building, and scaling full platforms from the ground up.

Let’s Modernize Together

Legacy applications hold valuable business logic, but their outdated architectures slow progress. At Assemblysoft, we turn that legacy into leverage — enabling your systems to thrive with the latest technology.

Contact us today to discuss your modernization needs and learn how our Blazor expertise can help transform your platform into a future-proof solution.

https://assemblysoft.com/contact

In today’s fast-paced digital world, choosing the right technology foundation for your application can be the difference between launching something that works — and launching something that lasts.

Whether you're building a new platform in healthcare, revolutionizing construction project workflows, enhancing digital learning experiences, or exploring the next frontier in AI, understanding the difference between web, native, and hybrid app development is critical.

At Assemblysoft, we don’t just deliver code — we become your technology partner. With a UK-based team, transparent processes, and a focus on pragmatic results, we help organisations like yours design, build, and scale digital solutions with confidence.

Let’s take a look at your options.

1. Web Application (Blazor WebAssembly)

Blazor WebAssembly enables applications to run in the browser without installation. It's a fantastic choice for:

Quick, universal access on PCs, tablets, and mobile devices.

Low maintenance thanks to centralised updates.

When you don’t immediately need hardware features like offline access or camera input.

Whether it’s a construction management portal, a secure healthcare dashboard, or a learning system for students, this approach makes it simple for users to get started — no app store needed.

💡 Best for: Rapid MVPs, educational tools, healthcare reporting systems, or admin dashboards.

2. Native App Experience (Blazor Hybrid + .NET MAUI)

Want to access the full power of a device? Native applications built with Blazor Hybrid and .NET MAUI can be published to the Apple App Store, Google Play, or Microsoft Store and offer:

Deep integration with hardware (biometrics, GPS, camera, secure printing).

Offline functionality, critical for field environments or limited connectivity areas.

A more immersive user experience, perfect for secure or data-intensive workflows.

This is ideal for use cases such as:

Medical staff needing secure, on-device access in hospitals or clinics.

Construction site managers collecting data and capturing images offline.

AI applications leveraging device sensors for real-time input.

💡 Best for: Secure field apps, native healthcare tools, AI data collection, or inspection tools.

3. Best of Both Worlds – Web + Native with Shared Code

Why choose one when you can have both?

By sharing a codebase between a Blazor Web App and a Blazor Hybrid Native App, you get:

A flexible rollout strategy — start on the web, expand to mobile later.

A cost-effective development process, with fewer redundancies.

The ability to future-proof your platform for scale, compliance, and innovation.

This model is perfect for businesses looking to start lean, then scale smart — like education providers rolling out digital learning tools, or AI firms prototyping and testing across devices.

💡 Best for: Scalable education platforms, healthtech startups, smart AI assistants, or any phased go-to-market plan.

So… What’s Right for You?

That’s where Assemblysoft comes in. We’ll help you navigate the landscape — from planning and design to development and deployment — with honest advice, flexible engagement models, and a proven track record of delivering across industries.

We’ve worked with clients in the medical sector, construction, education, and even emerging AI technologies, crafting tailored solutions that balance innovation with reliability.

Why Assemblysoft?

✅ UK-based developers, making collaboration easy

✅ Affordable, transparent pricing

✅ Expertise in .NET, Blazor, .NET MAUI, Azure, and AI integrations

✅ Pragmatic approach focused on your business goals

✅ Scalable delivery models to match your project size and speed

Let’s Build Something That Works — And Grows

Whether you're digitising your site workflows, modernising your healthcare tools, or launching an intelligent AI platform — Assemblysoft is ready to support you.

We don’t just write code. We build platforms that scale, products that solve problems, and partnerships that last.

📩 Contact us today to schedule a no-obligation discovery call. Let’s bring your ideas to life — together.

APIs are the engines driving digital transformation, connecting applications, systems, and users across the globe. Fully managing your APIs—from concept, design, and build to deployment—requires an advanced platform like Azure API Management (APIM). It also demands a skilled development partner to help businesses realize its full potential.

At Assemblysoft, we specialize in custom API development and integrations that align with your unique needs. Whether you are just starting your API journey or enhancing an existing APIM solution, our team can simplify, extend, and customize your API Management to deliver business value. With our help, you focus on innovation while we manage the complexity.

Understanding Azure API Management (APIM)

Azure API Management is a versatile, cloud-based platform that simplifies API governance. It bridges backend services with frontend applications, ensuring APIs are secure, efficient, and scalable.

1. API Gateway: Handles requests, enforces security policies, and routes traffic seamlessly.
2. Management Plane: Offers tools to configure, analyze, and monitor APIs via Azure’s portal, CLI, or SDKs.
3. Developer Portal: A customizable space for developers to explore, test, and subscribe to APIs.

Azure API Management is a hybrid, multicloud management platform for APIs across all environments. As a platform-as-a-service, API Management supports the complete API lifecycle.

Why Azure APIM?

Azure APIM solves challenges faced by both technical and business stakeholders:

• Abstract Legacy Systems: Transform outdated systems into modern, RESTful APIs.
• Enhance Security: Protect APIs with Azure Entra ID, API keys, and advanced rate-limiting policies.
• Streamline Multi-Channel Apps: Support web, mobile, and IoT platforms with reusable APIs.
• Centralize Governance: Ensure consistent policies, documentation, and analytics across APIs.

Assemblysoft’s Expertise in API Development

Assemblysoft is a trusted API development company that delivers tailored solutions with Azure APIM. We address every API lifecycle challenge, including:

• Custom API Development Services: Whether you need a new API or enhancements to an existing one, we design APIs tailored to your requirements.
• API-First Approach: We prioritize robust API design, ensuring seamless integrations from the start.
• Scalability and Monitoring: Leveraging Azure’s tools, we ensure your APIs remain performant and adaptable.
• Enhanced Security: From JWT tokens to WAF integration, we safeguard your APIs against threats.

Explore our API development services.

Real-World Use Cases

1. Digital Transformation: Modernize legacy systems into API-driven platforms.
2. API Monetization: Unlock new revenue streams by offering APIs to partners or customers.
3. Improved Compliance: Utilize role-based access and detailed analytics to meet regulatory standards.
4. Streamlined Integration: Enable seamless B2B data exchanges using Azure APIM.

Implementation Challenges and Solutions

Challenge: Managing and scaling APIs for multiple platforms.
Solution: Assemblysoft ensures scalability with tools like Application Insights and Azure Monitor.

Challenge: Balancing security with user experience.
Solution: We implement advanced authentication methods, such as OAuth2 and Azure Entra ID.

Learn about our .NET expertise in API solutions.

Pricing Tiers and Implementation Considerations

Azure APIM offers flexible pricing to suit varied needs:

• Developer Tier: Best for testing and initial implementation.
• Standard Tier: Optimized for production environments with moderate traffic.
• Premium Tier: Ideal for high availability, private networks, and global reach.

Short-term adoption focuses on publicly accessible APIs, while long-term solutions integrate private endpoints with premium-tier security.

Discover how Assemblysoft can customize Azure APIM for you.

FAQs

What is API development?
API development refers to creating interfaces that allow software systems to communicate and share data seamlessly.

What does API mean in software development?
API, or Application Programming Interface, defines how different software components interact.

What is API in web development?
APIs enable the exchange of data between frontend and backend systems in web applications.

What is API-driven development?
API-driven development emphasizes building robust APIs to guide application development and integrations.

What is API-first development?
API-first development is a design approach prioritizing APIs as the foundation for all software interactions.

What is API design and development?
It involves planning, creating, and managing APIs to ensure they are efficient, secure, and easy to use.

Next Steps

To unlock the full potential of Azure API Management and gain a competitive edge, partner with Assemblysoft. From initial implementation to advanced customizations, we’re here to help.

Contact us to learn more.

In today’s rapidly evolving tech landscape, businesses must modernize legacy applications, streamline workflows, and leverage cutting-edge tools to remain competitive. Assemblysoft, a leading provider of dedicated, bespoke development teams, specializes in Microsoft technologies, offering tailored solutions for businesses looking to modernize their systems and supercharge their development processes. Whether you’re diving into Blazor development, working with .NET developers, exploring .NET MAUI, or upgrading monolithic systems, Assemblysoft ensures your business thrives in the digital age.

Our mission is to empower businesses to

• Modernize legacy applications with the latest Microsoft technologies.
• Transition monolithic architectures into more efficient, modular systems.
• Enhance development workflows for better productivity and team alignment.

How We Help Modernize Legacy Applications

Legacy applications can be a significant bottleneck for businesses, especially when they rely on outdated technologies. Assemblysoft provides a comprehensive approach to modernizing these systems:

1. Assessment and Strategy:

We evaluate your existing applications, identify pain points, and propose a modernization strategy tailored to your needs.

2. Implementation:

Using .NET Core, Blazor, and Azure, we rebuild or refactor applications to meet modern standards while ensuring seamless user experiences.

3. Integration and Deployment:

Our team specializes in integrating modern solutions with existing infrastructures, minimizing downtime during deployment.

From Monoliths to Microservices: Simplifying Complex Systems

Migrating a monolith to a microservices architecture can seem daunting. Assemblysoft specializes in breaking down complex monolithic systems into modular, manageable components.

Example: Transforming a Legacy Retail Management System - A recent client faced performance issues with their retail management system, built on an aging monolithic structure. By leveraging Blazor development and modern .NET frameworks, we transitioned the system into microservices, improving scalability, reducing maintenance costs, and enhancing user satisfaction.

3 Tips for Better Development Workflows

Efficient workflows are critical for development teams. Here are three proven strategies Assemblysoft employs to help clients streamline their processes:

1. Automate Repetitive Tasks

Repetitive tasks like merge conflict resolution, deployment setups, and infrastructure management can drain valuable time from developers. Automating these processes not only saves time but also minimizes human error.

For example, one of our projects involved setting up CI/CD pipelines in Azure DevOps for a Blazor WebAssembly application. By automating build and deployment processes, we reduced deployment time by 60%, allowing developers to focus on delivering features instead of wrestling with infrastructure.

2. Use AI to Assist with Complex Tasks

AI-powered tools like GitHub Copilot and Amazon Q have revolutionized development workflows. From refactoring code to identifying performance bottlenecks, AI can accelerate development without compromising quality.

Example in Practice

In a recent .NET Core project, we used AI to generate unit tests for a complex financial calculation module. This saved over 20 hours of manual testing and improved test coverage by 35%.

3. Centralize Tools for Team Alignment

Miscommunication and tool sprawl can lead to inefficiencies, especially in remote or hybrid teams. Tools like Azure DevOps, GitHub, and Slack can centralize repositories, pull requests, and project updates, keeping everyone on the same page.

Real-World Example:

For a global client, we centralized their development workflow using Azure DevOps, integrating task management, code repositories, and CI/CD pipelines into a single platform. This reduced delays caused by misalignment and improved project visibility for stakeholders.

Why Modern Microsoft Technologies Matter

Microsoft technologies like Blazor, .NET Core, and .NET MAUI are at the forefront of innovation, enabling developers to create performant, scalable, and user-friendly applications. Assemblysoft specializes in these technologies, helping clients stay ahead of the curve.

The Power of Blazor Development

Blazor allows developers to build interactive web applications using C#, eliminating the need for JavaScript-heavy frameworks. This simplifies development and ensures a unified tech stack across projects.

.NET MAUI for Cross-Platform Solutions

For businesses seeking cross-platform applications, .NET MAUI provides the flexibility to build apps for iOS, Android, Windows, and macOS using a single codebase. Assemblysoft’s team of .NET MAUI developers ensures your applications deliver seamless experiences across devices.

Partner with Assemblysoft for Your Development Needs

If you’re ready to modernize your systems, streamline workflows, or build the next big thing with Microsoft technologies, Assemblysoft is your go-to partner. Our Blazor development expertise, skilled .NET developers, and proven track record of modernizing legacy applications make us the ideal choice for businesses looking to innovate and grow.

Get in touch today to learn how Assemblysoft can help transform your development process and deliver world-class software solutions tailored to your business needs.

Why Choose Assemblysoft for Your .NET Projects?

At Assemblysoft, we focus on helping businesses modernize and optimize their software by providing skilled .NET developers and .NET MAUI developers with expertise in building scalable, maintainable solutions. Our teams are dedicated to solving your unique challenges, whether it's upgrading older technologies, migrating monolithic applications to microservices, or enhancing user experiences with Blazor and other modern frameworks.

Integrating AI capabilities into your applications is now easier than ever with .NET Aspire. Whether you’re experimenting with local AI models or deploying them to the cloud, Assemblysoft can guide your business in leveraging these advanced tools. By combining the flexibility of .NET Aspire with robust frameworks like Ollama, you can create innovative, AI-powered solutions tailored to your needs.

Using Local AI Models in .NET Aspire

Local AI models offer a convenient way to prototype and experiment without relying on cloud resources. By using Ollama’s integration with .NET Aspire, developers can:

• Download and manage AI models locally.
• Interact with models via a web interface for testing.
• Transition seamlessly to cloud-hosted models when ready for deployment.

Here’s how Assemblysoft helps you get started:

Set Up OllamaInstall the Ollama hosting integration from NuGet:

dotnet add package CommunityToolkit.Aspire.Hosting.Ollama

Configure it in Program.cs to enable local hosting:

var ollama =
    builder.AddOllama("ollama")
           .WithDataVolume()
           .WithOpenWebUI();

This setup ensures that models are downloaded and persisted, saving time on restarts and enabling easy interaction through a web UI.

Run AI Models LocallyAdd your preferred model using the AddModel method:

var chat = ollama.AddModel("chat", "llama3.2");

You can also include models from the Hugging Face model hub for additional versatility.

Integrate Models into Your ApplicationLink the AI models to your API project with minimal code:

builder.AddProject<Projects.MyApi>("api")
       .WithReference(chat)
       .WaitFor(chat);

This ensures your application waits until the model is fully downloaded and ready for use, enhancing stability and reliability.

Transitioning to Cloud-Hosted Models

While local models are excellent for development, cloud-hosted AI services like Azure OpenAI provide scalability and performance for production environments. With .NET Aspire’s abstractions, transitioning is seamless. Here’s how you can manage both local and cloud-hosted models:

if (builder.Environment.IsDevelopment())
{
    builder.AddKeyedOllamaSharpChatClient("chat");
}
else
{
    builder.AddKeyedAzureOpenAIClient("chat");
}

builder.Services.AddChatClient(b => b
    .UseFunctionInvocation()
    .UseOpenTelemetry(configure: t => t.EnableSensitiveData = true)
    .UseLogging()
    .Use(b.Services.GetRequiredKeyedService<IChatClient>("chat")));

This approach ensures your development and production environments use the most appropriate resources while maintaining consistent code.

Enhancing Applications with AI Integration

With Assemblysoft’s expertise, your business can:

• Develop AI-driven APIs that leverage the latest in machine learning.
• Utilize Microsoft.Extensions.AI abstractions for seamless transitions between local and cloud models.
• Integrate AI capabilities into existing .NET Aspire solutions with minimal effort.

Why Choose Assemblysoft?

At Assemblysoft, we specialize in empowering businesses to adopt cutting-edge technologies like AI and .NET Aspire. From setting up local AI models to deploying scalable cloud-based solutions, our team provides end-to-end support tailored to your goals.

Get Started Today

Whether you're exploring local AI models or preparing for cloud integration, Assemblysoft can help you navigate the complexities of modern AI development. Contact us today to learn how we can transform your applications with .NET Aspire and advanced AI tools!

ASP.NET Core in .NET 9 brings a streamlined and powerful way to create OpenAPI documents for your API endpoints. This new built-in support simplifies your development workflow and enhances the integration of OpenAPI definitions into your applications. With the growing ecosystem of tools like Swagger UI, Redoc, and the Kiota client library generator, this feature opens new possibilities for building, testing, and documenting APIs more effectively.

Why OpenAPI?

OpenAPI provides a standard way to define and document HTTP APIs. It describes your API’s endpoints, request and response formats, authentication schemes, and more. This standardization:

• Improves developer collaboration.
• Makes APIs easier to consume.
• Enables seamless integration with tools and services.

Additionally, many large language models (LLMs) have been trained on OpenAPI documents, enabling automated code generation, testing, and more. By adopting OpenAPI, you unlock the potential to accelerate your development process.

Key Features in .NET 9

With .NET 9, OpenAPI document generation becomes more integrated and user-friendly. Highlights include:

• Runtime and build-time OpenAPI document generation.
• Attributes and extension methods for metadata annotation.
• Transformer APIs for custom document modifications.
• Multiple OpenAPI document generation from a single app.
• JSON schema support via System.Text.Json.
• Compatibility with native AOT in Minimal APIs.

Getting Started with OpenAPI in .NET 9

1. Update to .NET 9Ensure your project targets .NET 9. You can download it from the official .NET website. For existing projects, follow the migration guide available in the ASP.NET Core docs.

Enable OpenAPI SupportIf starting a new project, OpenAPI is built into the .NET 9 WebAPI template. For existing projects:

dotnet add package Microsoft.AspNetCore.OpenApi

In Program.cs, add OpenAPI services:

builder.Services.AddOpenApi();
app.MapOpenApi();

Add Metadata for ClarityEnhance your OpenAPI documents by adding descriptions, summaries, tags, and parameter details using attributes or extension methods:

app.MapGet("/hello", () => "Hello, World!")
   .WithSummary("Get a greeting")
   .WithDescription("This endpoint returns a friendly greeting.")
   .WithTag("Greetings");

Customize Your OpenAPI DocumentsUse transformers to modify your documents:

builder.Services.AddOpenApi(options =>
{
    options.AddDocumentTransformer((doc, ctx, ct) =>
    {
        doc.Info.Contact = new OpenApiContact
        {
            Name = "Support",
            Email = "support@yourcompany.com"
        };
        return Task.CompletedTask;
    });
});

Generate OpenAPI Documents at Build Time

For integration into CI/CD workflows, generate OpenAPI documents during the build process. Install the Microsoft.Extensions.ApiDescription.Server package and configure your project:

<PropertyGroup>
  <OpenApiDocumentsDirectory>./</OpenApiDocumentsDirectory>
</PropertyGroup>

This allows for tasks like linting, client code generation, and automated testing to be seamlessly integrated into your development pipeline.

Conclusion

The built-in OpenAPI support in .NET 9 revolutionizes how developers approach API documentation and integration. Whether you're building Minimal APIs or controller-based applications, this feature ensures your APIs are well-documented, easy to consume, and in sync with your code. With Assemblysoft's expertise in .NET and API development, we can help you harness these new capabilities to create robust, future-proof applications.

Contact us today to learn how Assemblysoft can elevate your API development!