React Compiler 2026: A Paradigm Shift for SaaS Developers

The landscape of React development has undergone a seismic shift in 2026, and if you are building SaaS applications, understanding this transformation is not optional. The React Compiler represents the most significant architectural change to the framework since the introduction of hooks, fundamentally altering how developers approach performance optimization. For SaaS founders, CTOs, and full-stack developers working with modern JavaScript stacks, this shift eliminates years of accumulated optimization patterns while introducing entirely new considerations for building scalable applications.

Gone are the days when senior React developers distinguished themselves through masterful placement of useMemo, useCallback, and React.memo. The compiler now handles these optimizations automatically, performing static analysis at build time to insert memoization precisely where it delivers measurable benefits. This is not merely an incremental improvement; it is a paradigm shift that affects everything from how you structure components to how you evaluate developer candidates for your SaaS engineering team.

Key Takeaways

• Automatic memoization eliminates the need for manual performance hooks in most scenarios, reducing cognitive overhead and simplifying codebases
• Build-time optimization replaces runtime hints, providing more consistent and predictable performance across your SaaS application
• Migration requires careful planning, especially for large existing codebases with extensive manual optimization patterns
• New performance skills are emerging around server components, data fetching patterns, and architectural decisions rather than micro-optimizations
• SaaS applications benefit significantly from reduced bundle complexity and improved rendering performance in data-heavy dashboards
• The compiler is opt-in and requires explicit configuration; upgrading to React 19 alone does not enable these features

Understanding the Fundamental Shift in React Performance

For nearly a decade, React developers have relied on a mental model where performance optimization was a manual, developer-driven process. You identified expensive computations, wrapped them in useMemo, ensured callback stability with useCallback, and prevented unnecessary re-renders with React.memo. This approach worked, but it came with significant costs that compounded as applications scaled.

The react compiler fundamentally changes this equation by shifting optimization responsibility from runtime to compile time. Instead of developers guessing where memoization might help and scattering hints throughout the codebase, the compiler performs static analysis of your component code during the build process. It traces data flow through every render path, identifies values that remain stable between renders, and inserts granular memoization instructions into the compiled output.

This distinction matters enormously for SaaS development teams. Manual optimization required deep expertise, created maintenance burden, and introduced subtle bugs when dependency arrays fell out of sync. The compiler eliminates these concerns by performing the same analysis a senior developer would, but with perfect consistency across every component in your application. For teams building complex SaaS dashboards with dozens of interactive components, this translates directly to faster development cycles and more maintainable codebases.

Consider what this means for your hiring and team structure. Previously, performance optimization expertise was a differentiating skill that justified higher salaries and longer ramp-up times for new team members. Now, that expertise shifts toward architectural decisions, server component boundaries, and data fetching strategies. The compiler democratizes performance optimization, allowing junior developers to write performant code without years of accumulated React knowledge.

How the Compiler Actually Works Under the Hood

Understanding the compiler's internal mechanics helps you write code that optimizes well and debug situations where optimization does not occur as expected. The compiler operates as a Babel plugin that integrates into your existing build pipeline, analyzing component functions and custom hooks during compilation.

The process begins with dependency graph construction. For every component, the compiler builds a complete graph of all values and their relationships. Props flow into derived computations, state updates trigger specific code paths, and callback functions reference particular values. This graph captures the complete data flow within your component, providing the foundation for optimization decisions.

Next comes reactivity inference. The compiler determines which values are "reactive," meaning they might change between renders. Props are inherently reactive because parent components can pass different values. State is reactive because user interactions or effects can modify it. Derived values inherit reactivity from their dependencies. The compiler tracks this reactivity through every computation, understanding exactly which values can change and which remain stable.

Finally, the compiler performs memoization insertion. Based on its analysis, it wraps values in the appropriate memoization primitives. Expensive computations become useMemo calls with precisely correct dependency arrays. Callback functions that reference reactive values become useCallback calls. The compiler even memoizes JSX expressions when doing so prevents unnecessary child re-renders.

The granularity of compiler optimization exceeds what most developers would implement manually. While a developer might memoize an entire filtered array, the compiler can memoize individual expressions within that computation when beneficial. This expression-level optimization delivers performance improvements that would be impractical to achieve through manual means, particularly in complex SaaS interfaces with numerous interactive elements.

What Changes in Your Daily Development Workflow

The practical implications of compiler-driven development affect nearly every aspect of how you write React code. For SaaS developers accustomed to defensive memoization patterns, the transition requires unlearning habits that were once considered best practices.

The most immediate change is code simplification. Components that previously contained extensive memoization logic become dramatically cleaner. Consider a typical SaaS dashboard component that displays filtered, sorted data with interactive callbacks:

Before the compiler: Developers wrapped every computed value in useMemo, every callback in useCallback, and every child component in React.memo. Dependency arrays required constant maintenance, and missing dependencies introduced subtle bugs that manifested as stale data or broken interactions.

With compiler-driven optimization, you write the same component using straightforward JavaScript. Filter your data directly. Define callbacks as regular functions. The compiler analyzes your code and inserts the necessary optimizations. Your source code remains clean and readable while the compiled output contains all the performance optimizations you previously wrote manually.

This simplification has cascading benefits for SaaS teams. Code reviews become faster because reviewers no longer debate memoization strategies. Onboarding new developers takes less time because they do not need to learn complex optimization patterns. Bug density decreases because there are fewer dependency arrays to maintain. For startups moving quickly to achieve product-market fit, these efficiency gains compound into meaningful competitive advantages.

However, the transition is not entirely frictionless. Developers must learn to trust the compiler, which requires understanding what it can and cannot optimize. Certain patterns, particularly those involving external mutable state or non-deterministic computations, may not optimize as expected. Building this intuition takes time, and teams should expect a learning curve as they adapt to the new paradigm.

Migration Strategies for Existing SaaS Applications

If you are maintaining an existing SaaS application built with manual optimization patterns, migration to the compiler requires careful planning. The good news is that the compiler is designed to work alongside existing code, allowing incremental adoption rather than requiring a complete rewrite.

The recommended approach begins with enabling the compiler in strict mode on a subset of your codebase. This mode provides detailed feedback about code patterns that may not optimize correctly, helping you identify and address issues before they affect production. Start with newer, simpler components and gradually expand coverage as your team builds confidence.

Existing useMemo and useCallback calls do not break when the compiler is enabled. The compiler recognizes these patterns and either preserves them or replaces them with its own optimizations depending on the specific situation. However, over time, you should remove manual memoization to reduce code complexity and allow the compiler full control over optimization decisions.

For large SaaS applications with extensive manual optimization, consider a phased migration strategy:

1. Audit existing optimizations to understand where manual memoization exists and why it was added
2. Enable compiler analysis without removing existing code to identify potential issues
3. Address compiler warnings by refactoring code patterns that do not optimize correctly
4. Gradually remove manual memoization from components where the compiler provides equivalent optimization
5. Measure performance throughout the process to ensure optimization quality remains consistent

Teams using a Next.js boilerplate or similar foundation should check for framework-level compiler integration. Next.js 15 and later versions provide built-in support for the React Compiler, simplifying configuration and ensuring compatibility with server components and other framework features. This integration is particularly valuable for SaaS applications that leverage server-side rendering for improved initial load performance.

Performance Implications for Data-Heavy SaaS Dashboards

SaaS applications frequently feature complex dashboards displaying large datasets with multiple interactive filters, sorting options, and real-time updates. These interfaces historically required extensive manual optimization to maintain acceptable performance, and the compiler delivers substantial improvements in this domain.

Consider a typical analytics dashboard displaying thousands of data points with user-configurable visualizations. Without optimization, every user interaction triggers re-renders that cascade through the component tree, recalculating derived data and re-rendering charts even when the underlying data has not changed. Manual optimization addressed this through careful memoization, but maintaining these optimizations as features evolved was challenging.

The compiler handles these scenarios automatically, memoizing expensive data transformations and ensuring that chart components only re-render when their specific data dependencies change. Reports from production deployments indicate performance improvements ranging from 10% to 40% depending on the complexity of the interface and the quality of previous manual optimization.

For SaaS applications serving enterprise customers with strict performance requirements, these improvements can be differentiating. Faster dashboards mean better user experience, which translates to higher retention and expansion revenue. The compiler makes achieving this performance level accessible to teams without deep React optimization expertise, leveling the playing field for smaller SaaS companies competing against well-resourced incumbents.

Beyond raw performance, the compiler improves performance consistency. Manual optimization quality varied based on developer expertise and time constraints. Some components were thoroughly optimized while others received minimal attention. The compiler applies consistent optimization across your entire application, eliminating the performance variations that frustrated users and complicated debugging.

Server Components and the Evolving Optimization Landscape

The React Compiler does not operate in isolation; it is part of a broader evolution in React architecture that includes server components, streaming rendering, and improved data fetching patterns. Understanding how these pieces fit together is essential for SaaS developers building modern applications.

Server components fundamentally change where optimization matters. Components that render on the server do not benefit from client-side memoization because they execute once per request rather than re-rendering in response to user interactions. The compiler recognizes this distinction and applies different optimization strategies based on component type.

For SaaS applications, this creates new architectural decisions. Data-heavy components that display relatively static information often belong on the server, eliminating client-side rendering overhead entirely. Interactive components that respond to user input remain on the client, where compiler optimization delivers its benefits. Drawing this boundary correctly has more impact on overall performance than any amount of client-side optimization.

The combination of server components and compiler optimization creates a powerful performance story for SaaS applications. Initial page loads benefit from server rendering, delivering content to users faster than client-side rendering alone. Subsequent interactions benefit from compiler-optimized client components, maintaining responsiveness as users navigate and interact with your application. This hybrid approach delivers the best of both worlds, and the compiler makes the client-side portion of this equation dramatically simpler to implement.

Teams building with a SaaS boilerplate should evaluate how well the foundation supports this hybrid architecture. Modern boilerplates increasingly provide patterns for server component boundaries, data fetching strategies, and compiler configuration that reflect current best practices. Starting with a well-architected foundation saves significant time compared to retrofitting these patterns into an existing codebase.

New Skills That Define Performance Expertise

As the compiler automates traditional optimization patterns, new skills emerge as differentiators for senior React developers. Understanding these shifts helps SaaS leaders build teams capable of delivering high-performance applications in the compiler era.

Architectural decision-making becomes paramount. Where you draw component boundaries, how you structure data flow, and where you place server versus client component boundaries have more impact on performance than any micro-optimization. Senior developers who excel in this new landscape think holistically about application architecture rather than focusing on individual component optimization.

Data fetching patterns gain importance as applications leverage server components and streaming rendering. Understanding when to fetch data on the server versus the client, how to structure queries for optimal performance, and how to handle loading states gracefully are skills that directly impact user experience. The compiler cannot optimize poor data fetching decisions; it only improves rendering performance for data that has already arrived.

Bundle optimization remains relevant even as the compiler handles component optimization. Code splitting strategies, lazy loading patterns, and dependency management affect initial load performance in ways the compiler cannot address. SaaS applications serving global users must consider bundle size alongside rendering performance to deliver acceptable experiences across varying network conditions.

Monitoring and observability skills become more valuable as optimization becomes automatic. Understanding how to measure real-user performance, identify bottlenecks in production, and correlate performance metrics with business outcomes helps teams make informed decisions about where to invest optimization effort. The compiler handles the mechanics of optimization, but humans must still decide what to optimize and verify that optimizations deliver expected results.

Common Pitfalls and How to Avoid Them

Despite the compiler's sophistication, certain code patterns can prevent effective optimization or introduce unexpected behavior. Understanding these pitfalls helps SaaS developers write code that optimizes well and avoid frustrating debugging sessions.

Mutating objects or arrays breaks compiler assumptions. The compiler relies on referential equality to determine when values have changed. If you mutate an object instead of creating a new one, the compiler may incorrectly conclude that the value has not changed and skip necessary re-renders. Always create new objects and arrays when updating state or derived values.

Non-deterministic computations cannot be safely memoized. If a function returns different results for the same inputs, memoizing it would produce incorrect behavior. The compiler detects many non-deterministic patterns and skips optimization, but subtle cases may slip through. Avoid using Date.now(), Math.random(), or external mutable state within computations you expect to be memoized.

Relying on side effects during render creates problems the compiler cannot solve. React's rendering model assumes render functions are pure, producing the same output for the same inputs without observable side effects. The compiler reinforces this assumption by potentially calling render functions multiple times or caching their results. Side effects during render can produce unpredictable behavior that is difficult to debug.

Pro tip: Enable the compiler's strict mode during development to catch problematic patterns early. The detailed warnings help you understand why specific code does not optimize and provide guidance for refactoring.

Over-relying on the compiler for performance can mask architectural problems. If your SaaS application has fundamental performance issues stemming from poor data fetching, excessive component nesting, or inappropriate state management, the compiler cannot fix these problems. Use the compiler as one tool in your performance toolkit, not a magic solution that eliminates the need for thoughtful architecture.

Integration with Popular SaaS Development Tools

The React Compiler integrates with the broader ecosystem of tools SaaS developers rely on, though integration quality varies across different tools and frameworks. Understanding these integrations helps you make informed decisions about your technology stack.

Next.js provides first-class compiler support, with configuration options that simplify setup and ensure compatibility with framework features like server components and API routes. For teams building SaaS applications with Next.js, enabling the compiler typically requires minimal configuration changes. The framework handles integration details, allowing developers to focus on application code rather than build configuration.

State management libraries generally work well with the compiler, though some patterns require attention. Libraries that rely heavily on external mutable state may not optimize as expected. Modern state management solutions designed with React's concurrent features in mind, such as Zustand or Jotai, integrate smoothly with compiler optimization. Evaluate your state management approach if you encounter unexpected optimization behavior.

Testing frameworks continue to work as expected, though you may need to update snapshot tests that captured memoization-related code. The compiler transforms your code, so snapshots of compiled output will differ from snapshots of source code. Consider whether your testing strategy should focus on source code or compiled output, and adjust accordingly.

For teams using a SaaS starter kit or Next.js SaaS template, verify that the foundation has been updated for compiler compatibility. Well-maintained boilerplates typically provide compiler configuration out of the box, along with patterns that optimize well. Starting with a compiler-ready foundation saves significant setup time and ensures you benefit from optimization from day one.

Measuring Performance Impact in Production

Enabling the compiler without measuring its impact leaves you uncertain whether optimization is actually improving user experience. Establishing performance baselines and monitoring key metrics helps you quantify the compiler's benefits and identify areas needing additional attention.

Core Web Vitals provide standardized metrics that correlate with user experience. Largest Contentful Paint (LCP) measures loading performance, First Input Delay (FID) measures interactivity, and Cumulative Layout Shift (CLS) measures visual stability. The compiler primarily impacts FID and related interactivity metrics by reducing rendering overhead during user interactions.

For SaaS applications, custom metrics often matter more than generic web vitals. Time to interactive for your dashboard, response time for filter operations, and render time for data visualizations directly impact user satisfaction. Instrument these metrics before enabling the compiler to establish baselines, then monitor changes as you roll out compiler optimization.

Real User Monitoring (RUM) provides insights that synthetic testing cannot capture. Your users interact with your application on diverse devices, network conditions, and usage patterns. RUM data reveals how the compiler impacts actual user experience across this diversity, helping you prioritize optimization efforts where they matter most.

Consider A/B testing the compiler rollout if your application serves sufficient traffic. Serving compiler-optimized code to a subset of users while maintaining the baseline for others provides statistically rigorous evidence of performance impact. This approach is particularly valuable for SaaS applications where performance directly impacts conversion and retention metrics.

Future Directions and What to Watch

The React Compiler continues to evolve, with ongoing improvements to optimization quality, broader pattern support, and deeper framework integration. Staying informed about these developments helps SaaS developers plan their technology roadmap and capitalize on new capabilities as they emerge.

Improved optimization coverage is an active development area. The compiler team continues expanding the patterns that optimize correctly, reducing the cases where manual optimization remains necessary. Each release brings incremental improvements that benefit existing codebases without requiring code changes.

Better debugging tools are emerging to help developers understand compiler behavior. Visualization tools that show optimization decisions, profiling integrations that attribute performance to specific optimizations, and IDE extensions that provide real-time feedback are all in various stages of development. These tools will make working with the compiler more intuitive and reduce the learning curve for new adopters.

Ecosystem standardization is progressing as more libraries and frameworks adapt to compiler-driven development. State management libraries, component libraries, and testing tools are updating their patterns to optimize well with the compiler. This standardization reduces friction for SaaS developers and ensures consistent optimization across the entire application stack.

For SaaS developers building applications today, the compiler is ready for production use. The core functionality is stable, the performance benefits are real, and the ecosystem support is sufficient for most use cases. Waiting for future improvements means missing current benefits; adopting now positions your application to benefit from ongoing improvements automatically.

Building a Compiler-Ready SaaS Architecture

Starting a new SaaS project in 2026 provides the opportunity to build an architecture optimized for compiler-driven development from the beginning. This approach avoids migration challenges and ensures your codebase benefits fully from automatic optimization.

Embrace simplicity in component design. Write components using straightforward JavaScript without preemptive optimization. Trust the compiler to handle memoization and focus your attention on clear, maintainable code. This approach produces codebases that are easier to understand, modify, and debug.

Design clear component boundaries based on data dependencies rather than optimization concerns. Components should encapsulate coherent functionality with well-defined props interfaces. The compiler optimizes across component boundaries, so artificial splitting for optimization purposes is unnecessary and potentially counterproductive.

Leverage server components for data-heavy, relatively static content. Server components eliminate client-side rendering overhead entirely for qualifying content, providing performance benefits the compiler cannot match. Reserve client components for truly interactive elements that require browser APIs or respond to user input.

Implement proper data fetching patterns using React's built-in capabilities and framework features. Suspense boundaries, streaming rendering, and server-side data fetching reduce the amount of work client components must perform. The compiler optimizes what remains, but reducing the optimization surface area through architectural decisions delivers compounding benefits.

For teams evaluating a SaaS template or boilerplate, prioritize options that reflect these architectural principles. Modern foundations increasingly incorporate compiler-aware patterns, server component boundaries, and data fetching strategies that align with current best practices. The right foundation accelerates development while ensuring your application benefits from the full range of React's performance capabilities.

Team Considerations and Knowledge Transfer

Adopting the React Compiler affects your team beyond technical implementation. Training, hiring criteria, and code review practices all require adjustment to reflect the new development paradigm.

Update training materials to reflect compiler-driven development. Existing React training often emphasizes manual optimization patterns that are now unnecessary. New team members should learn to write simple, clear code and trust the compiler, rather than learning optimization patterns they will never use. This shift actually simplifies onboarding, reducing the knowledge required before developers can contribute effectively.

Revise hiring criteria to emphasize architectural thinking over optimization expertise. Candidates who demonstrate strong understanding of component design, data flow, and application architecture are more valuable than those who have memorized memoization patterns. Interview questions should explore how candidates approach complex UI challenges holistically rather than testing knowledge of specific hooks.

Adapt code review practices to focus on clarity and correctness rather than optimization. Reviews should ensure code follows React's rules, maintains clear data flow, and implements features correctly. Debates about whether specific values need memoization are no longer productive; the compiler makes these decisions based on analysis rather than developer judgment.

Foster compiler intuition through experience and experimentation. Encourage team members to explore how the compiler handles different patterns, review compiled output to understand optimization decisions, and share learnings with colleagues. This collective knowledge helps the team write code that optimizes well and debug situations where optimization does not occur as expected.

Conclusion

The React Compiler represents a fundamental shift in how SaaS developers approach performance optimization. By automating memoization decisions at build time, the compiler eliminates years of accumulated optimization patterns while delivering more consistent, granular optimization than manual approaches could achieve. For SaaS applications with complex, data-heavy interfaces, this translates to better user experiences with simpler, more maintainable codebases.

The transition requires adjustment. Teams must unlearn defensive optimization habits, develop new skills around architecture and data fetching, and update processes from training to code review. However, the benefits justify this investment. Faster development cycles, reduced bug density, improved performance consistency, and democratized optimization expertise all contribute to competitive advantages in the SaaS market.

Whether you are starting a new SaaS project or migrating an existing application, the compiler is ready for production use. The core functionality is stable, framework integration is mature, and the ecosystem continues to evolve in support of compiler-driven development. Adopting now positions your application to benefit from ongoing improvements while avoiding the accumulation of technical debt in the form of manual optimization code.

The skills that define senior React developers are evolving. Architectural thinking, server component boundaries, data fetching strategies, and performance monitoring replace micro-optimization as the differentiating capabilities. Teams that embrace this shift will build faster, more maintainable SaaS applications while those clinging to outdated patterns will find themselves increasingly disadvantaged.

Frequently Asked Questions

Does enabling the React Compiler automatically improve all performance issues in my SaaS application?

The React Compiler specifically addresses rendering performance by automatically inserting memoization where beneficial. It cannot fix performance issues stemming from poor architecture, inefficient data fetching, excessive network requests, or backend bottlenecks. For example, if your SaaS dashboard makes 50 API calls on initial load, the compiler will optimize how components render that data but cannot reduce the network overhead. Teams should view the compiler as one tool in a comprehensive performance strategy that includes server component architecture, efficient data fetching patterns, appropriate caching, and backend optimization. Measure your application's performance holistically and address bottlenecks at their source rather than expecting the compiler to solve all performance challenges.

How do I know if the React Compiler is actually optimizing my components?

The compiler provides several mechanisms for understanding its optimization decisions. Enable strict mode during development to receive detailed warnings about patterns that cannot be optimized. Review the compiled output in your build directory to see the memoization the compiler has inserted. Use React DevTools Profiler to compare render behavior before and after enabling the compiler, looking for reduced render counts and shorter render durations. For production monitoring, implement Real User Monitoring to track interaction latency and compare metrics between compiler-enabled and baseline deployments. The compiler team is also developing visualization tools that show optimization decisions inline with your source code, making it easier to understand why specific code optimizes or does not optimize as expected.

Should I remove all existing useMemo and useCallback calls from my codebase?

You do not need to remove existing memoization immediately, and doing so all at once could introduce regressions. The compiler recognizes existing memoization and works alongside it. However, over time, removing manual memoization simplifies your codebase and gives the compiler full control over optimization decisions. Adopt a gradual approach: leave existing memoization in place initially, verify the compiler is working correctly, then progressively remove manual optimization from components where the compiler provides equivalent or better optimization. Prioritize removing memoization from components that change frequently, as maintaining dependency arrays in these components creates ongoing maintenance burden. Keep manual memoization temporarily in components with complex optimization requirements until you verify the compiler handles them correctly.

Is the React Compiler compatible with all state management libraries?

Most modern state management libraries work well with the React Compiler, though some patterns require attention. Libraries designed with React's concurrent features in mind, such as Zustand, Jotai, and Redux Toolkit, generally integrate smoothly. Libraries that rely heavily on external mutable state or non-standard subscription patterns may not optimize as expected. If you encounter unexpected behavior, check whether your state management library has published compiler compatibility guidance. The compiler team maintains a compatibility matrix for popular libraries, and most library maintainers are actively updating their implementations to optimize well. For SaaS applications with complex state requirements, consider evaluating your state management approach if you experience optimization issues after enabling the compiler.

How does the React Compiler interact with server components in Next.js?

Server components and the React Compiler address different aspects of performance and work together effectively. Server components execute on the server, rendering HTML that is sent to the client without JavaScript overhead. The compiler does not optimize server components because they do not re-render on the client. Client components, marked with the "use client" directive, execute in the browser and benefit from compiler optimization. Next.js handles this distinction automatically, applying compiler optimization only to client components. For SaaS applications, this combination is powerful: use server components for data-heavy, relatively static content to eliminate client-side rendering overhead, and use compiler-optimized client components for interactive elements. The framework's built-in compiler integration ensures these pieces work together seamlessly without manual configuration.

What is the performance overhead of the React Compiler itself?

The compiler adds overhead to your build process but not to runtime performance. Build times increase modestly, typically by 10 to 30 percent depending on codebase size and complexity, because the compiler must analyze every component and custom hook. This overhead occurs once during build rather than repeatedly at runtime. The compiled output is slightly larger than unoptimized code due to inserted memoization, but this increase is typically negligible compared to overall bundle size. Runtime performance improves because the compiler's optimizations reduce unnecessary re-renders and computations. For SaaS applications with continuous deployment pipelines, the build time increase is usually acceptable given the runtime performance benefits. If build times become problematic, consider incremental adoption strategies that enable the compiler only for specific directories or components.

Ready to Build Your Next SaaS Application?

Building a performant SaaS application requires more than just enabling the React Compiler. You need a solid foundation with authentication, payments, user management, and the architectural patterns that support modern React development. SaasCore provides a comprehensive Next.js foundation designed for the compiler era, with server component boundaries, efficient data fetching patterns, and production-ready features that let you focus on your unique value proposition rather than rebuilding common functionality. Explore the demo and see how a well-architected SaaS boilerplate accelerates your path from idea to launched product.