Guidance on choosing the right framework for your project and when to use React vs. Blazor with the Strongtie Design System.
Choosing the right framework is one of the most important decisions you'll make when starting a new project. This guide will help you make an informed decision based on your team's needs, technical requirements, and long-term maintainability.
TL;DR: For new applications, we strongly recommend React. The Strongtie
Design System is built with React as a first-class citizen, offering the best
developer experience, performance, and long-term support.
Our Primary Recommendation: React
For new applications and projects, we recommend using React with the Strongtie Design System. Here's why:
1. Native Integration
The Strongtie Design System is built from the ground up using React. This means:
Zero friction integration – Components work out of the box with no adapters or wrappers needed
Type-safe props – Full TypeScript support with intelligent autocomplete
React hooks support – Leverage modern React patterns and hooks throughout
Consistent updates – New features and components are developed for React first
2. Ecosystem Maturity
React has the largest and most mature ecosystem in the frontend world:
👥Community Size
Over 12 million developers use React worldwide, with extensive Stack
Overflow support and community resources.
📦Package Ecosystem
Over 400,000 npm packages are compatible with React, solving virtually any
problem you might encounter.
💼Talent Pool
React developers are abundant and easier to hire compared to specialized
framework developers.
📚Learning Resources
Thousands of tutorials, courses, documentation, and examples available for
every skill level.
Efficient reconciliation – React's virtual DOM minimizes expensive DOM operations
Code splitting – Easy to implement with React.lazy() and dynamic imports
Tree shaking – Eliminate unused code automatically with modern bundlers
Smaller bundles – Our React components typically result in 40-60% smaller bundle sizes compared to WebAssembly alternatives
4. Framework Agnostic Styling
While our components are React-based, the styling approach is flexible:
Works seamlessly with Tailwind CSS
Compatible with CSS Modules
Integrates with styled-components or Emotion
Supports vanilla CSS and CSS custom properties
5. Modern Development Experience
React offers a superior developer experience:
Fast Refresh – See changes instantly without losing component state
Rich debugging tools – React DevTools provide deep insights into your application
Error boundaries – Graceful error handling at the component level
Concurrent features – Suspense, transitions, and other modern React features
When You Might Consider Blazor
While we strongly recommend React for most projects, there are specific scenarios where Blazor might make sense:
Valid Use Cases for Blazor
Blazor Limitations to Consider
Before choosing Blazor, be aware of these significant constraints:
Critical Considerations - No official Strongtie Design System support
– You'll need to create custom styles or use alternative design systems -
Larger bundle sizes – Blazor WebAssembly requires downloading the .NET
runtime (~1.5-2MB+ compressed) - Slower initial load times – The
WebAssembly runtime must boot before your app becomes interactive - Limited
component libraries – Far fewer pre-built component options compared to
React - Smaller talent pool – Harder to find experienced Blazor developers
Browser compatibility – No support for Internet Explorer or older
browsers
If You Must Use Blazor
If you've determined that Blazor is the right choice for your specific situation, here are your options for design consistency:
Option 1: Use CSS-Only Styles (Recommended for Blazor)
The most straightforward approach is to use our CSS-only styles via CDN:
Best for: Enterprise applications Professional component library with both
free and premium tiers. - 70+ components including data grids - Excellent form
and validation support - Free tier available with optional premium features -
Great for data-heavy applications Visit Radzen →
🐜Ant Design Blazor
Best for: Enterprise UI systems
Blazor implementation of Ant Design, the popular enterprise design system.
Note: These design systems have their own design languages that differ
from Strongtie Design System. You'll need to decide whether design consistency
with Strongtie or having pre-built components is more important for your
project.
Option 3: Partner with Our UX Team
If you need custom Blazor components that match the Strongtie Design System exactly, our UX team can help:
Initial Consultation
Meet with our UX team to discuss your project requirements, timeline, and
component needs.
Design Specifications
We'll provide detailed design specifications, Figma files, and style
guidelines for your Blazor components.
Style Guide Creation
Our team will create a comprehensive Blazor-specific style guide based on
Strongtie Design System principles: - CSS custom properties for design tokens
We'll provide ongoing support during development: - Design reviews of your
Blazor components - Feedback on implementation details - Accessibility audits
Performance recommendations
Quality Assurance
Final review to ensure design consistency and adherence to Strongtie Design
System standards.
What We Can Provide
Design tokens in CSS format – Colors, typography, spacing mapped to CSS variables
Component specifications – Detailed design specs for each component you need
Figma files – Access to Strongtie Design System Figma library
Accessibility guidelines – WCAG compliance requirements for each component
Responsive design guidance – Mobile-first breakpoints and layout patterns
Code review – Review your Blazor markup and styles for design consistency
What We Cannot Provide
C# code implementation – We don't write Blazor component logic
Blazor-specific debugging – Technical Blazor issues should be handled by your dev team
Long-term component maintenance – You'll own the code and be responsible for updates
How to Get Started
Contact the UX team to discuss your Blazor project:
If you have an existing Blazor application and want to move toward React, here's a pragmatic migration approach:
Gradual Migration
Assess Current Application
Audit your existing Blazor app to identify: - Frequently changed features
(migrate these first) - Standalone components that can be isolated -
Performance bottlenecks that React could improve
Choose a Migration Pattern
Micro-frontend approach: - Keep existing Blazor app running - Build new
features in React - Use iframe or web components for initial integration -
Gradually replace Blazor sections with React API-first refactor: - Create
clear API boundaries - Build new React frontend consuming same APIs - Run both
apps in parallel during transition - Switch over when React version reaches
feature parity
Establish Design System
Install Strongtie Design System in your new React application: bash npm install @strongtie/design-system sonner
Migrate Component by Component
Start with standalone components, then move to complex features: - Simple
forms and buttons first - Complex data grids and visualizations later - Shared
components used across multiple pages
Update Infrastructure
- Set up React build pipeline (Vite or
Next.js recommended) - Configure routing strategy - Implement
authentication/authorization - Set up state management if needed
Complete Transition
Once all features are migrated: - Remove Blazor dependencies - Archive legacy
code - Update documentation - Train team on React patterns
Timeline Expectations
Based on typical project complexity:
Application Size
Estimated Migration Time
Small (< 20 pages)
1-3 months
Medium (20-50 pages)
3-6 months
Large (50-100 pages)
6-12 months
Enterprise (100+ pages)
12-24 months
Migration Resources: Contact our team for migration workshops, pair
programming sessions, and architectural guidance.
Making the Decision
Use this decision framework to determine the right path forward:
Decision Tree
Are you starting a new project?
Yes → Strongly consider React
No → Continue to question 2
Do you have an existing Blazor application?
Yes → Is this a major rewrite?
Yes → Consider migrating to React
No → Maintain with Blazor, use CSS-only styles
No → Continue to question 3
What is your team's expertise?
React/TypeScript → Use React with full design system
C# only → Can your team learn TypeScript?
Yes → Use React (investment will pay off)
No → Continue to question 4
What are your performance requirements?
High performance, fast load times → Use React
Less critical (internal tools) → Blazor may be acceptable with UX team support
Key Factors to Weigh
✅Choose React When:
Starting a new project - Performance is critical - Large user base - Need
extensive component library - Want fastest development velocity - Hiring
developers is a concern
🤔Consider Blazor When:
Maintaining existing Blazor app - Deep .NET infrastructure investment -
Team cannot learn TypeScript - Small internal tool - Willing to partner with
UX team - Accept limitations listed above
Migration Support: Schedule a consultation with our architecture team
Conclusion
While we respect that every project has unique requirements and constraints, we strongly recommend React for new applications due to its superior ecosystem, performance, and first-class support in the Strongtie Design System.
If you must use Blazor, we're here to help you succeed with CSS-only styles, design consultations, and architectural guidance. However, for the best long-term maintainability, developer experience, and integration with our design system, React remains our primary recommendation.
Still unsure? Reach out to our team for a consultation. We're happy to
discuss your specific use case and help you make the best decision for your
project.