Salesforce solution architects who need modern frontend experiences often start with a clear goal. They want to deliver responsive interfaces, rich data grids, or interactive dashboards that match what their teams already build outside Salesforce. The platform’s native tool, Lightning Web Components, supports many of those needs but creates friction the moment React enters the picture.
Lightning Web Components serves as the primary UI framework for reusable, lightweight components on the platform. It follows web standards such as custom elements, templates, shadow DOM, and ES modules while integrating directly with Lightning Data Service, the @wire decorator, more than eighty base components, SLDS styling, and Lightning App Builder placement. Most teams can build record pages, quick actions, and Experience Cloud sites without leaving this system.
The friction appears when those same teams try to bring in React or other modern libraries. Earlier approaches required loading React and ReactDOM through static resources and the lightning/platformResourceLoader module. Developers then mounted components inside a container div, often relying on lwc:dom="manual". This pattern created several persistent problems. JSX could not be used without additional bundling steps. The two frameworks competed for DOM control. Performance suffered from running two separate runtimes. Access to platform services such as @wire or Lightning Data Service became difficult from the React side. Lightning Web Security further restricted third-party scripts, and every React update introduced new maintenance overhead.
These constraints matter most to solution architects and license owners who manage mid-market or enterprise Salesforce orgs. They face pressure to deliver polished customer or internal portals while staying inside the platform’s security and governance model. The old workaround route forced a choice between accepting limited React functionality or building separate hosted applications that required their own authentication and data access layers.
Salesforce introduced Salesforce Multi-Framework to remove that forced choice. Announced in open beta around April 2026 and reaching general availability on July 16, 2026, the capability lets React applications run natively on supported Hyperforce orgs. The runtime supplies built-in authentication, security governance, sharing rules, CRUD and field-level security, and data access without requiring separate tokens or external hosting. Existing Lightning Web Components continue to operate unchanged because the new runtime sits alongside rather than replaces the original framework.
Data access patterns differ between the two approaches. Lightning Web Components rely on declarative @wire adapters and Lightning Data Service with built-in caching. React applications under Multi-Framework use GraphQL queries and mutations or Apex calls through the Data SDK, accessed via createDataSDK(). Tooling also diverges. React teams gain full access to npm, Vite, Vitest, React DevTools, Tailwind, shadcn/ui, and Material UI. Lightning Web Components stay within Salesforce CLI and a more contained set of base components. Styling follows the same split: React brings its own CSS approach while Lightning Web Components default to SLDS tokens and classes.
Placement options reflect these differences. Lightning Web Components work directly inside Lightning pages, Flows, quick actions, and Experience Cloud sites through Lightning App Builder. Multi-Framework applications launch as standalone entries in the App Launcher on the salesforce.app domain or embed through thin Lightning Web Component wrappers using the lightning-ui-embedding module. Winter ’27 added Angular support, richer Data SDK capabilities, microfrontend embedding options, and 2GP packaging support for both unlocked and managed packages.
The shift from hacky static-resource loading to native support reduces several layers of technical debt. Teams no longer maintain dual runtime bundles or fight Lightning Web Security restrictions on every library update. They can still respect org permissions and field-level security because both frameworks ultimately call the same underlying APIs. Agentforce Vibes can even generate starter React code that follows the new patterns.
Practical rollout follows a short sequence. First confirm that the org runs on supported Hyperforce infrastructure and uses an Enterprise or higher edition where the feature is available. Install Salesforce CLI and Node.js version 18 or later. Generate a new UI Bundle with the command sf template generate ui-bundle or a React-specific template such as reactinternalapp. Develop locally with Vite or another preferred toolchain, then deploy the built bundle using sf project deploy start. Configure a Custom Application and permission sets so the app appears in the App Launcher. For embedded use cases, create a thin Lightning Web Component wrapper that loads the React bundle through the embedding module.
Limitations remain worth noting. Some packaging and translation features stayed on the roadmap after general availability. Managed package support and full Translation Workbench integration were not complete at launch. React teams still manage their own package.json dependencies and must plan for periodic updates. Beta-era restrictions such as limited App Builder support and partial platform API access delayed production use for several months. Winter ’27 addressed several of these gaps, yet architects should verify current packaging requirements before committing to a managed distribution model.
The decision between Lightning Web Components and Multi-Framework React comes down to placement and complexity rather than a blanket preference for one technology. Use Lightning Web Components when the interface must appear inside record pages, Flows, or quick actions that business users configure through Lightning App Builder. Choose Multi-Framework React when the application centers on complex grids, custom charting libraries, or npm-heavy components that would require repeated workarounds inside Lightning Web Components. Hybrid patterns work well for teams that need both: keep core record interactions in Lightning Web Components and surface heavier custom views through an embedded React bundle.
Concrete criteria help teams self-select. If the surface area stays within Lightning pages and requires no external libraries beyond the eighty-plus base components, Lightning Web Components deliver faster time to value and simpler maintenance. If the project involves dense data tables that benefit from AG Grid, advanced visualization libraries, or cross-platform component reuse across multiple Salesforce and non-Salesforce surfaces, the React path under Multi-Framework removes the previous friction. When the application must support Experience Cloud sites with heavy admin configuration, Lightning Web Components remain the safer default. When the goal is a standalone internal tool that lives in the App Launcher and reuses an existing React design system, Multi-Framework reduces both development time and ongoing technical debt.
Long-term maintenance also factors into the choice. Lightning Web Components receive platform updates automatically. React applications require the team to track dependency versions and test against new Salesforce releases. Both approaches inherit the same security model and respect field-level security and sharing rules, so the decision does not create new governance gaps.
App Kit
Custom apps on a proven foundation — one UI, any backend.
Read Next
Decouple Salesforce Frontend: Replace Experience Cloud with Your Own React Stack
Solution architects and Salesforce admins can now run full React apps natively on the platform. Learn how Multi-Framework removes Experience Cloud constraints while keeping data, security, and governance inside Salesforce.
How Do SF Platform Architects Build Headless Salesforce Experiences with Multiple Frameworks?
SF Platform Architects build headless Salesforce experiences by exposing core data through APIs and composing frontends from React, LWC, Vue and more—without framework lock-in.
Salesforce Platform SDK Guide for Platform Architects Building React Apps
Platform architects facing React integration challenges on Salesforce can use the Platform SDK and Multi-Framework for native security and GraphQL access without custom OAuth layers.
