Fastercialmah

In today’s hybrid work environment, conference room AV installation has become the backbone of effective business communication. Whether you’re an experienced AV system integrator, a consultant, or a system designer, understanding the complexities of conference room av installation is essential for delivering solutions that enhance collaboration, productivity, and user experience.

Conference room av installation involves the strategic planning, design, and deployment of audiovisual equipment to create seamless communication environments. From video conferencing systems and audio DSP processors to display technologies and control systems, every component plays a critical role in ensuring meetings run smoothly without technical disruptions.

The importance of conference room av installation cannot be overstated. According to a 2025 report by AVIXA, 78% of organizations consider high-quality AV systems essential for employee productivity and client engagement (Source: AVIXA Industry Outlook Report 2025). As remote work continues to evolve, businesses are investing more in professional AV

integration services to bridge the gap between in-person and virtual participants.

This comprehensive guide covers everything AV professionals need to know about conference room av installation, from selecting the right equipment to troubleshooting common challenges. Whether you’re designing a small huddle space or a large boardroom AV system, this article provides actionable insights based on 20 years of industry expertise and the latest semantic SEO frameworks.

✓ Conference room AV installation transforms meeting spaces into collaborative hubs with integrated video, audio, and control systems

✓ Proper AV system design requires understanding room acoustics, display placement, and network infrastructure

✓ Modern installations leverage AI-powered automation, wireless presentation systems, and unified communications platforms

✓ Cable management, signal flow optimization, and DSP tuning are critical for professional installations

✓ Regular system commissioning and preventive maintenance ensure long-term performance and ROI

✓ Cloud-based management and remote monitoring are reshaping how AV systems are deployed and maintained

✓ Understanding fire alarm system integration, building codes, and ADA compliance is essential for commercial projects

Conference room AV installation is the professional process of designing, integrating, and deploying audiovisual technology within meeting spaces to facilitate effective communication and collaboration. This encompasses the complete lifecycle from initial site assessment and system architecture to physical installation, programming, calibration, and ongoing support.

At its core, AV installation involves several interconnected disciplines:

System Design and Engineering: Creating detailed technical drawings, rack elevations, and signal flow diagrams that map out every component, connection, and control pathway. This includes load calculations, power distribution planning, and network topology design.

Infrastructure Installation: Running structured cabling (Cat6a, fiber optics), installing conduit pathways, mounting display screens and ceiling microphones, and building equipment racks that house matrix switchers, amplifiers, video processors, and control processors.

Integration and Programming: Connecting disparate AV equipment from multiple manufacturers, writing control system code (Crestron, Extron, AMX), configuring DSP presets, calibrating audio zones, and integrating with building management systems and room scheduling platforms.

Testing and Commissioning: Performing comprehensive system testing, acoustic measurements, video calibration, and end-user training to ensure the installation meets project specifications and client expectations.

Conference room AV installation goes beyond simply mounting screens and speakers. It requires deep technical knowledge of signal processing, network protocols (Dante, AES67, AVB), control architectures, and the ability to troubleshoot complex interoperability issues between video codecs, collaboration platforms (Microsoft Teams, Zoom), and legacy equipment.

Professional AV integrators must also understand electrical codes, fire safety regulations, accessibility standards (ADA Section 508), and best practices for rack building, grounding schemes, and RF interference mitigation.

The strategic value of professional conference room av installation extends far beyond technology deployment. Organizations that invest in properly designed AV systems experience measurable benefits across multiple dimensions:

Enhanced Communication and Collaboration

Modern AV installations eliminate the frustration of technical difficulties that derail meetings. When video conferencing equipment works flawlessly, audio reinforcement is crystal clear, and wireless content sharing happens instantly, participants can focus on meaningful discussion rather than troubleshooting technology. This directly impacts decision-making speed and team cohesion.

Improved Employee Productivity

Research consistently shows that poorly functioning meeting room technology wastes significant time. Professional conference room AV installation ensures meetings start on time, remote participants can fully engage, and presenters can seamlessly share content. The cumulative time savings across an organization translates to substantial productivity gains.

Professional Brand Image

When clients or partners visit your office or join virtual meetings, the quality of your AV infrastructure speaks volumes about your organization’s commitment to excellence. A well-executed conference room av installation creates positive impressions and demonstrates professionalism that can influence business outcomes.

Support for Hybrid Work Models

The shift toward flexible work arrangements has made unified communications technology mission-critical. Professional AV installations create equity between in-room and remote participants through intelligent camera tracking, beamforming microphones, and spatial audio processing that replicates natural conversation dynamics.

Cost Efficiency and ROI

While professional conference room av installation requires upfront investment, it delivers long-term value through reduced downtime, lower maintenance costs, energy efficiency, and extended equipment lifespan. Properly installed systems experience fewer service calls and provide more predictable total cost of ownership.

Compliance and Accessibility

Commercial installations must meet building codes, fire safety standards, and accessibility requirements. Professional AV integrators ensure systems comply with regulations while creating inclusive environments for users with hearing or visual impairments through assistive listening systems and closed captioning integration.

Scalability and Future-Proofing

Thoughtful system architecture accommodates growth and technology evolution. Professional installations include proper network infrastructure, modular signal distribution, and open protocols that allow seamless upgrades without complete system replacement.

A comprehensive conference room AV installation comprises multiple integrated subsystems. Understanding each component and how they work together is fundamental to successful AV integration.

Display Technologies

Video displays serve as the visual focal point of any conference room. Professional installations consider:

Large Format Displays: Commercial-grade LED displays or laser projectors with appropriate screen sizes calculated using the 4:6:8 rule (screen height to viewing distance ratio). 4K resolution or higher ensures content clarity for hybrid meetings.

Touch Displays: Interactive touchscreen monitors for collaborative workspaces, enabling direct annotation and whiteboarding applications.

Video Walls: Multi-panel LED or LCD video walls for command centers, executive boardrooms, or presentation halls requiring large-scale visualization.

Projector Systems: Laser phosphor projectors with appropriate throw ratios, lumens ratings, and mounting configurations for dedicated presentation spaces.

Audio Systems

Professional audio installation ensures every participant hears clearly and is heard:

Microphone Arrays: Ceiling microphones with beamforming technology, gooseneck mics for podiums, or boundary microphones for conference tables. Proper microphone placement based on coverage patterns and pickup ranges is critical.

Loudspeakers: Properly positioned ceiling speakers, in-wall speakers, or column arrays that provide even sound pressure level distribution without dead zones or hot spots.

Audio DSP: Digital signal processors that handle acoustic echo cancellation, noise reduction, automatic gain control, ducking, equalization, and routing to ensure intelligible speech.

Amplifiers: Appropriately sized power amplifiers or powered speakers that match impedance and wattage requirements.

Video Conferencing Equipment

The heart of modern collaboration technology:

Video Codecs: Hardware or software-based video conferencing systems (Poly, Cisco, Logitech) that connect to unified communications platforms (Zoom Rooms, Microsoft Teams Rooms, Google Meet).

PTZ Cameras: Pan-tilt-zoom cameras with auto-tracking capabilities that follow active speakers using AI algorithms.

USB Peripherals: All-in-one video bars or modular camera-mic-speaker kits for smaller meeting spaces.

Content Cameras: Dedicated document cameras or downward-facing cameras for capturing physical materials.

Control Systems

User interface devices that simplify operation:

Touch Panels: Wall-mounted or tabletop touchscreen controllers (Crestron, Extron) providing intuitive control of source selection, volume, lighting, and shades.

Button Panels: Simple keypad interfaces for spaces requiring minimal control options.

Mobile Control: Smartphone and tablet apps that allow BYOD control and room booking integration.

Automation: Occupancy sensors and scheduling systems that power equipment on/off based on calendar events.

Signal Distribution

Infrastructure components that route audio and video:

Matrix Switchers: Centralized or distributed video switching and routing platforms that manage multiple sources and destinations.

Scaling and Processing: Video scalers, format converters, and windowing processors that handle resolution matching and multi-image composition.

AV-over-IP: Network-based distribution using Dante, SDVoE, NDI, or proprietary IP protocols for flexible signal routing.

Wireless Presentation: Collaboration gateways (Barco ClickShare, Mersive Solstice) enabling wireless screen sharing from laptops and mobile devices.

Network Infrastructure

IT backbone supporting modern AV systems:

Structured Cabling: Cat6a or fiber optic cables providing bandwidth for 4K video and high-channel-count audio.

Network Switches: Managed switches with PoE+ capability, VLAN configuration, QoS policies, and multicast support.

Network Security: Firewall rules, certificate management, and encryption protocols protecting AV endpoints.

Mounting and Furniture

Physical integration elements:

Equipment Racks: Standard 19-inch racks with proper ventilation, power distribution, and cable management.

Display Mounts: Articulating arms, fixed mounts, or ceiling lifts designed for commercial display weights.

Conference Tables: Integrated cable cubby systems, pop-up connectivity boxes, and under-table mounting solutions.

Power Management

Electrical systems ensuring reliable operation:

UPS Systems: Uninterruptible power supplies protecting critical equipment from outages and voltage fluctuations.

Power Conditioning: Voltage regulators and isolation transformers eliminating electrical noise.

Sequential Power: Power sequencers that turn equipment on/off in proper order preventing damage.

Different meeting spaces demand tailored AV solutions. Understanding room typologies helps system designers specify appropriate technology:

Small Huddle Rooms (4-6 People)

Huddle space AV focuses on simplicity and cost-effectiveness:

Display: Single 32-55 inch display or short-throw projector

Audio: USB speakerphone or simple soundbar with integrated microphone

Video: Wide-angle webcam or all-in-one video bar

Control: Wireless presentation dongle or native app-based control

Connectivity: HDMI cable at table, USB-C docking station

Installation Considerations: Minimal infrastructure, plug-and-play systems, wireless connectivity, wall-mounted equipment to preserve table space

Medium Conference Rooms (6-12 People)

Mid-size meeting room AV balances functionality and sophistication:

Display: 55-75 inch commercial display or dual displays for hybrid layouts

Audio: Ceiling microphone array (3-4 elements) with DSP processing, in-ceiling or surface-mount speakers (2-4 channels)

Video: Auto-tracking PTZ camera or dual-camera system (room view + presenter view)

Control: Tabletop touch panel or wireless touch interface

Connectivity: Table connectivity box with HDMI, USB-C, VGA (legacy), wireless presentation system

Installation Considerations: Cable pathways through furniture, proper acoustic treatment, camera positioning for optimal framing, network drops for control and video

Large Conference Rooms (12-20 People)

Enterprise conference room AV requires sophisticated integration:

Display: 80-98 inch display, video wall, or high-lumen projector with motorized screen

Audio: Comprehensive microphone coverage (ceiling array + table mics), multi-zone speakers with DSP zoning

Video: Dual PTZ cameras for room coverage, dedicated content camera

Control: In-wall touch panel with customized UI, wireless mobile control

Connectivity: Multiple HDMI/USB-C inputs at table and lectern, presentation switching

Additional Systems: Room scheduling displays, occupancy sensors, lighting control integration

Installation Considerations: Acoustical analysis, sight line studies, structured cable infrastructure, equipment room or ceiling plenum for rack mounting

Boardrooms and Executive Spaces (20+ People)

Premium boardroom AV delivers highest quality experience:

Display: Large-format video wall (LED or LCD), confidence monitors, annotation displays

Audio: Distributed microphone system (8+ channels), line array speakers or in-ceiling speakers with subwoofers, assistive listening systems

Video: Multi-camera production system with preset positions, video switching, streaming encoder

Control: Integrated control system managing AV, lighting, shades, HVAC, video recording

Connectivity: Comprehensive connectivity including dual redundant systems, backup switchers

Additional Systems: Confidence monitoring, recording and streaming, interpretation systems, voting systems

Installation Considerations: Dedicated equipment room, redundant systems, aesthetic integration (hidden speakers, motorized lifts), acoustic design by certified acoustician, architectural coordination

Training and Multipurpose Rooms

Flexible AV systems that adapt to multiple use cases:

Display: Multiple displays or projectors with independent source selection

Audio: Zoned audio system supporting breakout configurations, wireless microphones for presenters

Video: Movable camera systems or multiple fixed cameras with preset switching

Control: Scene-based control for different room configurations

Additional Systems: Audience response systems, simultaneous interpretation, stage lighting

Installation Considerations: Flexible infrastructure, portable equipment options, multiple AV connection points, modular furniture integration

Specialty Spaces

Unique environments requiring specialized approaches:

Auditoriums: Professional sound reinforcement, theatrical lighting, presentation switching, assisted listening

Video Production Studios: Broadcast-quality cameras, professional audio mixing, lighting grids, video routing infrastructure

Telepresence Suites: Immersive video walls, spatial audio, precise lighting control, architectural acoustics

Command Centers: Video wall controllers, KVM systems, multi-source monitoring, 24/7 reliability design

Step-by-Step Conference Room AV Installation Process

Professional conference room av installation follows a systematic methodology ensuring successful outcomes:

Phase 1: Discovery and Requirements Gathering

Needs Assessment: Conduct stakeholder interviews with IT managers, facilities personnel, and end users. Document use cases, meeting types, participant counts, and technology preferences.

Site Survey: Visit the space to document room dimensions, ceiling heights, window locations, electrical outlets, network access, HVAC systems, acoustical characteristics, and architectural constraints.

Budget Planning: Establish realistic budgets covering equipment, labor, infrastructure, licensing, training, and ongoing support.

Technology Research: Evaluate AV manufacturers, compare product specifications, review compatibility matrices, and assess integration complexity.

Phase 2: System Design and Engineering

Conceptual Design: Create preliminary designs showing equipment locations, display positions, speaker placement, and user interface locations. Develop use case scenarios and workflow diagrams.

Detailed Engineering: Produce comprehensive technical documentation including:

Equipment schedules listing every component with model numbers and quantities

Rack elevations showing physical layout of equipment in racks

Signal flow diagrams mapping video, audio, and control pathways

Cable schedules detailing every cable run with source, destination, length, and type

Network diagrams showing IP addresses, VLAN assignments, and switch port configurations

Electrical plans indicating power requirements, circuit locations, and UPS connections

Acoustic Analysis: Perform reverberation time calculations, assess background noise levels, model speaker coverage patterns, and specify acoustic treatments if needed.

Code Compliance Review: Verify designs meet building codes, fire regulations, ADA requirements, and telecommunications standards.

Value Engineering: Review designs for cost optimization while maintaining performance objectives.

Phase 3: Pre-Installation Planning

Procurement: Order equipment with adequate lead times, verify specifications match design, inspect shipments for damage.

Coordination: Schedule installation around occupancy, coordinate with general contractors, electricians, low-voltage contractors, and IT teams.

Staging: Unpack equipment, label components, pre-build racks, pre-terminate cables, upload firmware updates, and test equipment before field installation.

Permitting: Obtain necessary building permits and schedule required inspections.

Phase 4: Infrastructure Installation

Cable Installation: Pull structured cabling through conduit or plenum spaces, maintain bend radius specifications, properly label all cables, test cable runs with certification equipment (Fluke, Ideal Networks).

Electrical Work: Install dedicated circuits, outlet boxes, and conduit by licensed electricians following NEC requirements.

Mounting: Install display mounts, projector mounts, speaker brackets, equipment racks, and furniture integration components. Ensure proper load-bearing capacity and seismic bracing where required.

Testing: Verify cable runs, test power circuits, confirm network connectivity.

Phase 5: Equipment Installation

Rack Building: Mount equipment in racks with proper vertical spacing for cooling, install cable managers, make all interconnections, implement cable labeling systems.

Device Mounting: Mount displays following manufacturer specifications, install speakers and acoustic panels, position cameras at correct angles and heights, mount touch panels at accessible locations.

Cable Dressing: Route cables neatly using cable ties and velcro straps, avoid tight bends, separate power from signal cables, use cable concealers for exposed runs, ensure cable service loops for future maintenance.

Power-Up: Energize systems gradually, verify proper voltage, check for ground loops or interference, confirm cooling systems function.

Phase 6: System Integration and Programming

Network Configuration: Assign static IP addresses, configure VLAN tagging, set QoS policies, establish firewall rules, implement network security.

Control Programming: Write control system code, create user interfaces, define button functions, program preset recalls, implement conditional logic.

DSP Programming: Configure audio routing matrices, set EQ curves, adjust gain structures, program acoustic echo cancellation, create preset scenes.

Video Processing: Configure scaling parameters, set EDID management, program input/output resolutions, establish switching presets.

Integration: Connect video conferencing platforms, integrate room scheduling systems, link building management systems, enable remote monitoring.

Phase 7: Testing and Commissioning

Functional Testing: Test every input source, verify all output destinations, confirm control functions, validate audio processing, check video quality.

Performance Testing: Measure audio levels with SPL meter, verify microphone coverage, test video conferencing quality, assess wireless performance, check network bandwidth utilization.

User Acceptance Testing: Conduct tests with end users, simulate actual meeting scenarios, gather feedback, make adjustments.

Documentation: Create as-built drawings, produce system operation manuals, document IP addresses and credentials, provide maintenance procedures.

Phase 8: Training and Handoff

User Training: Conduct hands-on sessions covering basic operation, troubleshooting, wireless connectivity, and video conferencing etiquette.

Technical Training: Train IT staff on system administration, remote monitoring, firmware updates, and first-level troubleshooting.

Documentation Delivery: Provide complete project documentation, warranty information, support contact details.

Project Closeout: Obtain sign-off, transfer warranties, schedule follow-up visits.

Even experienced AV integrators encounter obstacles during conference room av installation. Anticipating these challenges improves project outcomes:

Network and IT Integration Issues

Challenge: Network infrastructure inadequate for AV bandwidth requirements, IT security policies blocking AV protocols, VLAN configuration conflicts, insufficient PoE budget.

Solution: Engage IT stakeholders early, conduct network assessments, document bandwidth requirements, establish dedicated AV VLANs, implement QoS policies, upgrade switches if necessary, coordinate firewall rules.

Acoustic Problems

Challenge: Excessive reverberation time, background noise from HVAC systems, sound isolation issues, acoustic echo in video conferencing.

Solution: Perform acoustic measurements, specify appropriate acoustic treatment (absorption panels, bass traps), work with mechanical engineers to address HVAC noise, implement advanced DSP acoustic echo cancellation, adjust microphone placement and gain structure.

Cable Infrastructure Limitations

Challenge: Insufficient cable pathways, distance limitations for copper cables, inability to fish cables through walls, legacy conduit filled to capacity.

Solution: Conduct thorough site surveys, plan cable routes before installation, use fiber optic extenders for long runs, consider AV-over-IP to leverage existing network infrastructure, coordinate with building owners for pathway additions.

Power and Electrical Issues

Challenge: Inadequate electrical circuits, voltage fluctuations, ground loops causing audio hum, insufficient UPS capacity.

Solution: Coordinate with licensed electricians, install dedicated circuits, implement proper grounding schemes, use isolation transformers, specify appropriate UPS systems, install power sequencers.

Room Layout Constraints

Challenge: Obstructions blocking camera views or speaker placement, insufficient wall space for displays, awkward sightlines, columns or beams interfering with equipment.

Solution: Conduct detailed site surveys, create 3D models, coordinate with architects, consider ceiling-mounted solutions, use articulating mounts, plan around constraints during design phase.

Interoperability and Compatibility

Challenge: Manufacturer compatibility issues, firmware conflicts, EDID problems, HDCP handshake failures, legacy equipment integration.

Solution: Thoroughly test equipment combinations before purchase, use EDID managers and video scalers, maintain current firmware versions, implement video processing equipment to handle format conversions, document compatibility matrices.

User Adoption and Change Management

Challenge: Users resist new technology, insufficient training leads to support calls, complexity overwhelms end users, previous system familiarity causes confusion.

Solution: Involve users in design process, create intuitive user interfaces, provide comprehensive training with hands-on practice, create quick reference guides, offer ongoing support, implement progressive disclosure (simple interface with advanced options hidden).

Budget Overruns

Challenge: Scope creep, unexpected site conditions, equipment price increases, additional infrastructure requirements discovered mid-project.

Solution: Conduct thorough site surveys, include contingency budget (10-15%), establish clear change order processes, maintain detailed project tracking, communicate frequently with stakeholders.

Scheduling and Coordination

Challenge: Delays from other trades, occupied spaces limiting installation windows, equipment delivery delays, inspection hold-ups.

Solution: Develop realistic schedules with buffer time, coordinate regularly with all trades, track equipment lead times, schedule installations during off-hours if necessary, maintain open communication with project managers.

Documentation and As-Built Issues

Challenge: Changes made during installation not documented, wiring labels inconsistent or missing, system configuration not recorded, lack of operational documentation.

Solution: Implement field documentation procedures, update drawings in real-time, photograph installations, use cable labeling systems, create comprehensive system documentation, provide operational manuals and training videos.

Professional AV integrators follow established best practices ensuring reliable, maintainable systems:

Design Best Practices

Standardization: Develop room templates for common space types, specify consistent equipment brands and models across the organization, create standardized user interfaces, enabling easier training and support.

Scalability: Design systems with growth capacity, specify modular equipment allowing expansion, provision extra cable pathways and network drops, choose open protocols and standards enabling future integration.

Redundancy: Include backup systems for critical applications, specify dual network paths, implement failover for essential services, provide manual overrides for automated systems.

Accessibility: Ensure controls are reachable from wheelchairs, provide assistive listening systems, integrate closed captioning, use high-contrast user interfaces, follow ADA guidelines.

Energy Efficiency: Implement automatic power management, specify energy-efficient equipment, program standby modes, use occupancy-based control.

Installation Best Practices

Cable Management: Use proper cable ties (velcro, not plastic zip ties on horizontal runs), maintain service loops, avoid crossing power and signal cables, keep cables away from heat sources, label everything clearly.

Grounding: Establish single-point ground, avoid ground loops, use balanced audio connections, separate audio and video grounds when necessary, follow manufacturer grounding recommendations.

Cooling: Provide adequate ventilation in equipment racks, maintain manufacturer-specified clearances, install rack fans if needed, avoid mounting heat-generating equipment adjacent to each other, monitor temperatures.

Cable Testing: Certify all network cables to Cat6a specifications, test HDMI cables at full resolution, verify fiber optic connections with OTDR, document all test results.

Labeling: Label both ends of every cable, use consistent naming conventions, create durable labels, photograph all connections, maintain label databases.

Integration Best Practices

Network Security: Change default passwords, implement VLANs, enable port security, use encryption for remote access, keep firmware updated, disable unused services and ports.

Programming Standards: Write modular code, include detailed comments, use consistent variable naming, implement error handling, create user-friendly feedback messages.

DSP Configuration: Start with manufacturer presets, make incremental adjustments, document all changes, save multiple configuration versions, implement password protection.

System Validation: Test every feature thoroughly, simulate real-world scenarios, verify failover functions, stress-test systems, document performance metrics.

Documentation Best Practices

As-Built Drawings: Update drawings to reflect actual installation, mark all cable routes, document deviations from design, include equipment locations and heights.

System Documentation: Create comprehensive operation manuals, document all IP addresses and credentials, provide wiring diagrams, include troubleshooting flowcharts, maintain version control.

Training Materials: Develop quick start guides, create video tutorials, provide laminated quick references, establish online knowledge bases.

Maintenance Best Practices

Preventive Maintenance: Schedule regular system checks, clean equipment and displays, verify all functions, update firmware systematically, test backup systems.

Remote Monitoring: Implement network monitoring tools, track system health metrics, receive alerts for failures, enable remote troubleshooting, maintain uptime statistics.

Support Processes: Establish clear escalation procedures, maintain spare parts inventory, document common issues and solutions, provide help desk access, schedule periodic training refreshers.

Lifecycle Management: Track equipment age, plan for technology refresh cycles (typically 5-7 years), budget for upgrades, phase out obsolete equipment systematically.

Project Management Best Practices

Communication: Hold regular project meetings, maintain detailed meeting notes, provide status reports, communicate changes promptly, establish clear escalation paths.

Quality Control: Implement inspection checklists, conduct peer reviews of designs, verify equipment before shipment, validate installations at key milestones, obtain stakeholder sign-offs.

Risk Management: Identify potential issues early, develop mitigation strategies, maintain contingency plans, track risks throughout project lifecycle.

Client Relationships: Set realistic expectations, communicate transparently, address concerns promptly, exceed performance commitments when possible, maintain post-installation relationships.

When selecting an AV integration partner for your conference room av installation projects, expertise and proven methodology matter. XTEN-AV brings comprehensive capabilities that ensure successful outcomes:

Deep Technical Expertise

With specialized knowledge in audio DSP programming, video signal processing, network infrastructure, and control system integration, XTEN-AV’s certified engineers deliver solutions that work seamlessly from day one. Our team holds industry certifications including CTS (Certified Technology Specialist), CTS-D (Design), CTS-I (Installation), Dante Level 3, Crestron DMC, and manufacturer-specific credentials.

Proven Methodologies

XTEN-AV follows structured project management approaches based on PMI standards and AVIXA best practices. Every installation progresses through rigorous quality checkpoints ensuring systems meet performance specifications and client expectations.

Comprehensive Services

From initial consultation and system design through installation, programming, commissioning, and ongoing support, XTEN-AV provides end-to-end services. This single-point accountability streamlines projects and ensures consistent quality throughout the technology lifecycle.

Technology Partnerships

Strategic relationships with leading AV manufacturers (Crestron, Extron, Shure, Sennheiser, Sony, Barco, Poly, Cisco) provide access to latest technologies, technical support resources, extended warranties, and competitive pricing that benefits clients.

Industry Experience

Extensive project portfolio spanning corporate boardrooms, educational institutions, healthcare facilities, government agencies, and hospitality venues demonstrates capability to address diverse requirements and complex integration challenges.

Client-Centric Approach

XTEN-AV prioritizes understanding unique business requirements, involving stakeholders throughout the design process, providing comprehensive training, and maintaining responsive support long after installation completion.

Quality Assurance

Rigorous testing protocols verify every system function before client acceptance. Detailed documentation, comprehensive warranties, and ongoing maintenance programs protect client investments.

Innovation Focus

Continuous research into emerging technologies (AI-enhanced video, spatial audio, cloud-based management, IoT integration) ensures clients benefit from forward-looking solutions that anticipate future needs.

Future Trends in Conference Room AV Installation

The AV industry continues rapid evolution driven by technological advancement and changing workplace dynamics. System designers and AV integrators must anticipate emerging trends:

AI and Machine Learning Integration

Artificial intelligence is transforming conference room technology:

Intelligent Framing: AI-powered cameras automatically frame active speakers, adjust composition based on meeting dynamics, and switch between overview and close-up shots without manual intervention.

Voice Recognition: Natural language processing enables voice-controlled meeting room functions, automated transcription services, real-time language translation, and smart assistant integration.

Predictive Analytics: Machine learning algorithms analyze usage patterns, predict equipment failures before they occur, optimize system performance, and provide actionable insights for facility managers.

Audio Enhancement: AI-based noise suppression removes background sounds, enhances speech intelligibility, and creates immersive spatial audio experiences.

Cloud-Based Management and Analytics

Cloud platforms are centralizing AV system management:

Remote Administration: Cloud dashboards enable IT teams to monitor system health, deploy firmware updates, modify configurations, and troubleshoot issues across entire enterprise portfolios from any location.

Usage Analytics: Detailed metrics track room utilization, popular features, technical issues, and user behavior patterns informing space planning and technology investment decisions.

Subscription Models: Software-as-a-service licensing shifts from capital expenses to operational expenses, ensuring systems stay current with regular feature updates.

Increased Network Convergence

AV-over-IP continues displacing traditional point-to-point architectures:

Standards Adoption: SMPTE ST 2110, NDI, SDVoE, and Dante AV provide interoperable protocols enabling flexible signal routing over standard network infrastructure.

Reduced Infrastructure: Centralized equipment rooms replace distributed racks, simplifying maintenance and reducing hardware footprint.

Flexibility: Network-based systems easily adapt to changing requirements through software configuration rather than physical re-cabling.

Enhanced Hybrid Meeting Experiences

Technology addressing hybrid work challenges:

Presence Equity: Intelligent cameras, directional microphones, and spatial audio create experiences where remote participants feel equally present and engaged.

Virtual Collaboration: Digital whiteboards, interactive annotation, and content sharing tools enable seamless collaboration across physical and virtual participants.

Immersive Technologies: Early adoption of holographic displays and virtual reality conferencing creating next-generation meeting experiences.

Sustainability and Green AV

Environmental considerations influencing design decisions:

Energy Efficiency: Low-power components, intelligent power management, and efficient cooling reducing operational costs and carbon footprint.

Lifecycle Management: Focus on repairable, upgradable equipment reducing e-waste and extending useful life.

Sustainable Materials: Preference for manufacturers using recycled materials and responsible supply chains.

Wireless and BYOD Proliferation

Shift toward wireless connectivity:

Wireless Presentation: Continued refinement of wireless collaboration platforms with lower latency, higher resolution support, and better security.

Personal Device Integration: BYOD (Bring Your Own Device) ecosystems where users leverage personal devices as primary collaboration tools.

5G Integration: Emerging 5G networks enabling new use cases for mobile collaboration and remote participation.

Security and Privacy Enhancements

Growing emphasis on protecting sensitive communications:

Encryption: End-to-end encryption for video conferencing streams and control protocols.

Privacy Controls: Physical camera shutters, microphone mute indicators, and clear user notifications when recording.

Compliance: Enhanced features supporting GDPR, HIPAA, and other regulatory requirements for data protection.

Modular and Adaptable Spaces

Physical environments becoming more flexible:

Reconfigurable Rooms: Movable walls, modular furniture, and flexible AV infrastructure enabling spaces that adapt to different meeting types.

Portable Equipment: High-quality portable video conferencing kits complementing fixed installations.

Multi-Purpose Design: Single spaces serving diverse functions from presentations to brainstorming to social gatherings.

Advanced Analytics and Optimization

Data-driven approach to space and technology management:

Occupancy Analytics: Sensor-based tracking identifying underutilized spaces and optimizing real estate investments.

Quality Metrics: Automated collection of audio quality scores, video resolution data, and network performance metrics.

Predictive Maintenance: Analytics identifying patterns preceding equipment failures enabling proactive service.

What is the typical cost of a conference room AV installation?

Conference room AV installation costs vary significantly based on room size, equipment quality, and complexity. A basic huddle room (4-6 people) with all-in-one video bar, single display, and simple connectivity typically ranges $5,000-$10,000. Mid-sized conference rooms (8-12 people) with professional PTZ cameras, DSP audio processing, control systems, and wireless presentation cost $15,000-$35,000. Large boardrooms or specialized spaces can exceed $100,000 when including video walls, multi-camera systems, advanced audio, architectural integration, and custom programming. Installation labor typically represents 20-40% of total project cost depending on complexity and infrastructure requirements.

How long does a conference room AV installation take?

Installation timelines depend on project scope and site conditions. Simple huddle space deployments may complete in 1-2 days including equipment mounting, cabling, and basic configuration. Standard conference rooms typically require 3-5 days for complete installation and commissioning. Complex boardrooms with extensive infrastructure, custom programming, and architectural coordination may take 2-4 weeks. These timelines assume equipment is available and site conditions are favorable. Additional time is required for design, procurement, and user training. Many installations occur in phases to minimize disruption to occupied spaces.

What certifications should I look for in an AV integrator?

Professional AV integrators should hold relevant industry certifications demonstrating technical competency and commitment to best practices. Key certifications include AVIXA CTS (Certified Technology Specialist) demonstrating foundational AV knowledge, CTS-D (Design) for system designers, and CTS-I (Installation) for installation technicians. Manufacturer-specific certifications (Crestron DMC, Extron Control Professional, QSC Q-SYS) indicate expertise with specific platforms. Network certifications (Dante Certification, Cisco CCNA) are valuable for AV-over-IP projects. Project managers should hold PMP or similar credentials. Acoustical consultants should have NCAC or LEED AP certifications for specialized projects.

How often should conference room AV systems be updated?

Technology refresh cycles for AV systems typically range 5-7 years, though this varies by component type. Video codecs and collaboration platforms may require upgrades every 3-5 years to support evolving unified communications standards. Displays can last 7-10 years with proper maintenance. Control systems and audio processors often remain serviceable for 7-10 years with periodic software updates. Rather than complete system replacement, many organizations implement phased upgrades replacing obsolete components while retaining functional infrastructure. Regular preventive maintenance and firmware updates extend equipment life and maintain compatibility with evolving standards. Budget approximately 10-15% of original installation cost annually for maintenance and incremental upgrades.

Can existing AV systems be integrated with new equipment?

Legacy system integration is often possible with proper planning and appropriate interface equipment. Key considerations include signal compatibility (analog vs. digital, resolution support), control protocol compatibility, and network infrastructure adequacy. Video scalers and converters bridge format differences. Control systems may require updated programming to accommodate new devices. Audio DSP systems can often integrate additional microphones or speakers through expansion cards or Dante networking. Thorough assessment of existing equipment capabilities, manufacturer support status, and integration costs versus complete replacement is essential. Sometimes partial upgrades deliver better long-term value than attempting to extend obsolete systems.

What maintenance is required for conference room AV systems?

Preventive maintenance extends system life and ensures reliable operation. Quarterly tasks include display cleaning using approved solutions, lens cleaning on projectors and cameras, filter replacement in projectors, verification of all system functions, and cable inspection for damage. Semi-annual activities include firmware updates, audio calibration checks, control system database backups, and cable connection retightening. Annual maintenance should include comprehensive performance testing, network security audits, acoustic measurements, detailed cleaning of all equipment, and user training refreshers. Implement remote monitoring to identify issues before they affect users. Maintain spare parts inventory for commonly-failed components enabling rapid repairs.

How do you ensure good audio quality in video conferencing?

Exceptional audio quality requires attention to multiple factors throughout design and installation. Start with proper acoustic treatment controlling excessive reverberation and background noise. Select appropriate microphone types (ceiling arrays, gooseneck, boundary) based on room geometry and seating arrangements. Position microphones within manufacturer-specified pickup patterns ensuring even coverage. Implement professional DSP processing with acoustic echo cancellation, noise reduction, and automatic gain control. Specify commercial-grade speakers with even dispersion patterns avoiding feedback zones. Conduct thorough audio testing using real-world scenarios and measurement equipment. Train users on best practices like muting when not speaking and positioning themselves appropriately relative to microphones.

Professional conference room av installation represents a critical investment in organizational collaboration infrastructure. As we’ve explored throughout this comprehensive guide, successful implementations require far more than simply connecting equipment. They demand thorough understanding of acoustical principles, video signal processing, network architecture, control system programming, and the unique requirements of different meeting space typologies.

The shift toward hybrid work models has elevated the importance of properly designed AV systems that create equitable experiences for both in-room and remote participants. Organizations that invest in professional conference room av installation delivered by experienced AV integrators experience measurable improvements in productivity, employee satisfaction, and brand perception.

Key considerations for successful projects include comprehensive needs assessment, detailed system design following semantic SEO frameworks and industry best practices, proper infrastructure installation, sophisticated integration and programming, rigorous testing and commissioning, and ongoing maintenance and support. Understanding common challenges such as network integration issues, acoustic problems, and user adoption barriers enables proactive mitigation strategies.

The AV industry continues rapid evolution with emerging technologies like AI-powered automation, cloud-based management, AV-over-IP distribution, and enhanced hybrid meeting technologies reshaping what’s possible in collaborative spaces. Forward-thinking organizations work with partners like XTEN-AV who stay current with these trends and design scalable systems that accommodate future technological advancement.

Every week, someone posts something like: “We are so cooked. AI has taken our jobs.” And every other week, someone else replies, maybe on X, saying that the same agent deleted their .env file, with the caption “lol.”

Both reactions are understandable. Neither is enough evidence.

To get a more useful answer, I benchmarked Claude Code and OpenCode on the same real refactor: migrating a deeply nested Next.js 15 and React 19 dashboard from prop drilling to Zustand. The goal was not to see which tool could write the prettiest code from a blank prompt. It was to see how each terminal coding agent handled a messy, multi-file migration with TypeScript, callback props, shared UI state, build verification, and enough component nesting to make the prop chain feel personal.

The result was not “AI replaces developers” or “AI agents are useless.” It was more practical: both tools completed the refactor, both hit the same environment issue, and one tool produced a cleaner first pass. More importantly, the mistakes showed what developers need to specify when using CLI agents for large refactors.

If you’re already experimenting with terminal agents, this benchmark pairs well with LogRocket’s guide to leveling up Claude Code workflows and its broader AI dev tool rankings.

What I benchmarked

The benchmark compared two agentic coding tools:

Tool	What it is	Why it matters for this test
Claude Code	Anthropic’s terminal-based agentic coding tool	Strong codebase navigation, conservative permissions, and tight integration with Claude models
OpenCode	An open source AI coding agent with terminal, IDE, and desktop surfaces	Provider flexibility, inspectability, and a terminal UI built around diffs and sessions

Claude Code is Anthropic’s official CLI coding agent. It can read and edit files, run shell commands, reason over a codebase, and use MCP-connected tools. It also defaults toward explicit approval for state-changing actions, which is useful when you want a coding assistant that does not silently rewrite half your repository.

OpenCode takes a different approach. It is open source, model-flexible, and designed to let developers connect different providers, including Claude, GPT, Gemini, and local models. LogRocket has covered this angle in more detail in its article on switching to OpenCode when security teams block proprietary coding tools.

For this benchmark, I used the same underlying model for both tools: Claude Opus 4.6. Anthropic positions Opus 4.6 as an agentic coding model with improved reliability on large codebases, so using it in both tools helped isolate the tool orchestration layer from the model layer.

That said, this is still a practical benchmark, not a scientific study. The results reflect one codebase, one refactor task, one machine, and one prompt. Treat the numbers as a useful field report, not a universal ranking.

The refactor task

The test app was a Next.js 15 dashboard using React 19, TypeScript, and Tailwind. The codebase was intentionally unpleasant, but not unrealistic: a project management dashboard with mock data, six levels of nested components, callback props traveling through components that did not use them, and shared UI state living too high in the tree.

The dashboard state lived in dashboard/page.tsx. From there, it flowed into DashboardHeader, Sidebar, ContentArea, ProjectList, ProjectCard, TaskRow, StatsFooter, and TaskModal.

Here was the component tree before the migration:

app/
├── layout.tsx
├── page.tsx
├── dashboard/
│   ├── page.tsx                   (owns all state)
│   └── components/
│       ├── DashboardHeader.tsx    (receives user, notifications, onMarkRead, sidebarCollapsed)
│       ├── Sidebar.tsx            (receives user, projects, selectedProjectId, onSelectProject,
│       │                           collapsed, onToggleCollapse, activeFilters, onFilterChange)
│       ├── ContentArea.tsx        (receives user, projects, tasks, selectedProjectId,
│       │                           activeFilters, onUpdateTask, onDeleteTask, onOpenTaskModal)
│       │   ├── ProjectList.tsx    (receives projects, selectedProjectId, tasks, user,
│       │   │                       activeFilters, onUpdateTask, onDeleteTask, onOpenTaskModal)
│       │   │   └── ProjectCard.tsx
│       │   │       └── TaskRow.tsx
│       │   └── StatsFooter.tsx    (receives projects, tasks, user)
│       └── TaskModal.tsx          (receives task, project, user, isOpen, onClose, onSave, projects)

ProjectCard alone received eight props, most of which it only passed down to TaskRow. That made the codebase a good candidate for a state management migration. Zustand was a reasonable choice because it lets React components consume state from a store without adding a provider wrapper, which makes it useful for cutting through deep prop chains. LogRocket’s Zustand adoption guide covers that tradeoff in more depth.

The refactor requirements were specific:

1. Create a Zustand store for user, project, and UI state
2. Replace prop drilling with direct store consumption
3. Remove dead props from every component interface
4. Keep TypeScript compiling with zero errors
5. Preserve existing behavior, including modal and task side effects

The prompt I used

I gave both tools the same prompt:

Refactor this Next.js 15 + React 19 app from prop drilling to Zustand.

Read the entire codebase first. Do not ask questions.

1. Create a Zustand store in src/store/ that consolidates user, project,
   and UI state currently being prop-drilled through the dashboard components.
2. Update every component that currently receives these props to consume
   from the store directly.
3. Remove all dead props and update TypeScript interfaces accordingly.
4. Run `npx tsc --noEmit` after every major change to verify type safety.
5. Run `npm run build` at the end to confirm the app compiles.

Maintain MISTAKES.md at the root. Log every error you encounter with:
file, what you did, the error, why it happened, how you fixed it.

The MISTAKES.md requirement turned out to be one of the most useful parts of the test. It forced both agents to leave a trail of wrong assumptions, failed commands, and recovery steps instead of silently patching over errors.

That matters because the value of a coding agent is not just whether it eventually passes the build. It is whether you can understand how it got there.

Claude Code’s attempt

Claude Code began by reading the codebase in dependency order. It opened page.tsx, traced imports, and worked through the child components. Its state audit was strong: it mapped shared state, identified where props were being passed through without being used, and separated true state mutations from callbacks that were only wiring.

That up-front analysis was exactly what I wanted. Claude Code did not immediately start writing files. It first established where the state lived and how it moved.

The Zustand store it created was clean and logically grouped:

// src/lib/store.ts
import { create } from 'zustand'

interface DashboardState {
  // User state
  user: User | null
  setUser: (user: User) => void

  // Project state
  projects: Project[]
  setProjects: (projects: Project[]) => void
  updateTask: (taskId: string, updates: Partial<Task>) => void
  deleteTask: (taskId: string) => void

  // UI state
  sidebarCollapsed: boolean
  toggleSidebar: () => void
  activeFilters: FilterState
  setFilters: (filters: FilterState) => void
  activeModal: { type: 'task' | null; data?: Task }
  openTaskModal: (task: Task) => void
  closeModal: () => void
}

This was the right shape for the migration. User state, project state, and UI state were grouped in a single dashboard store. The actions were explicit, and the modal state moved out of the prop chain.

But a good initial store is not the hard part of this refactor. The hard part is migrating every component without breaking parent-child contracts.

Mistake #1: Broken toolchain shims

Claude Code’s first failure was not actually a code failure:

$ npx tsc --noEmit
Cannot find module '../lib/tsc.js'

After installing Zustand, npm regenerated the .bin shims inside node_modules. The tsc wrapper resolved to the wrong path, looking for node_modules/lib/tsc.js instead of the TypeScript binary.

The same issue affected the Next.js build command. Claude Code recovered by calling the binaries directly:

node node_modules/typescript/lib/tsc.js --noEmit
node node_modules/next/dist/bin/next build

This is the kind of boring environment issue that does not show up in polished demos but shows up all the time in real projects. The important part is that Claude Code correctly diagnosed it as tooling breakage rather than trying to “fix” unrelated TypeScript code.

Mistake #2: Refactoring top-down instead of bottom-up

The first real coding mistake was architectural. Claude Code started by editing the root DashboardPage, removing props from parent calls before the children had been updated to read from the Zustand store.

TypeScript immediately objected:

Type '{}' is missing the following properties from type 'SidebarProps':
user, projects, selectedProjectId, onSelectProject...

This is a common migration trap. In a prop-drilling-to-store refactor, the root component is the wrong place to start. The root owns the state, but the leaf components are the ones that need to stop depending on props first.

Claude Code had to reverse direction and refactor bottom-up:

TaskRow
→ ProjectCard
→ ProjectList
→ ContentArea
→ DashboardPage

That strategy worked. Each child moved to the store first. Only then did the parent stop passing the now-dead props.

This is the most useful lesson from Claude Code’s run: for state migrations, free the leaves before pruning the trunk.

Mistake #3: Incomplete prop cascade

The second code mistake followed from the first. Claude Code removed the user prop from ContentArea, but ContentArea was still passing user to StatsFooter, which had not been migrated yet.

TypeScript caught it:

Property 'user' is missing in type '{ projects: Project[]; tasks: Task[]; }'
but required in type 'StatsFooterProps'.

The fix was simple: migrate StatsFooter at the same time as the component passing data into it. But the failure is worth keeping because it shows why deeply nested component trees create hidden coupling. Props are not just values; they are contracts between files.

Claude Code’s final result:

Metric	Claude Code result
Total time	14 minutes
Final TypeScript errors	0
Build status	Passed
Mistakes logged	4
Environment issues	2
Code issues	2

OpenCode’s attempt

OpenCode approached the same task differently. It started by mapping the file tree first:

find . -name "*.tsx" -not -path "*/node_modules/*"

Then it pulled type information before making changes. This gave it a broader view of the component graph before it touched the code.

Its state audit was similar to Claude Code’s: shared state, local state, callback props, and UI state were identified correctly. It created the same general Zustand store shape and did not add unnecessary middleware, providers, or architectural flourishes.

Then, somewhat annoyingly for anyone who enjoys drama, it mostly just worked.

OpenCode hit the same environment issues as Claude Code:

### Entry 1
- What I ran: `npx tsc --noEmit`
- Error: Cannot find module '../lib/tsc.js'
- Fix: Run TypeScript directly via
  `node node_modules/typescript/lib/tsc.js --noEmit`
- Category: Tooling / Environment issue

### Entry 2
- What I ran: `npm run build`
- Error: Cannot find module '../server/require-hook'
- Fix: Run `node node_modules/next/dist/bin/next build` directly.
- Category: Tooling / Environment issue

Unlike Claude Code, OpenCode did not make a top-down refactor mistake or leave an incomplete cascade. It moved through the dependency chain cleanly and ended with the same successful build.

OpenCode’s final result:

Metric	OpenCode result
Total time	7 minutes
Final TypeScript errors	0
Build status	Passed
Mistakes logged	2
Environment issues	2
Code issues	0

Benchmark results

Here is the side-by-side version:

Dimension	Claude Code	OpenCode
Underlying model	Claude Opus 4.6	Claude Opus 4.6
Task completed	Yes	Yes
Final TypeScript status	0 errors	0 errors
Final build status	Passed	Passed
Time to completion	14 minutes	7 minutes
Environment mistakes	2	2
Code mistakes	2	0
Main failure mode	Refactoring order and incomplete cascade	Toolchain shims only
Strongest behavior	Thorough reasoning and explicit side-effect awareness	Cleaner first-pass execution

OpenCode had the cleaner run in this benchmark. It finished faster and did not introduce code-level migration mistakes.

Claude Code’s run was still valuable. Its errors were readable, recoverable, and instructive. It also explicitly called out one behavior that mattered: preserving the handleSaveTask side effect that closes the modal after saving. OpenCode preserved the same behavior in the store, but it did not explain that decision as clearly.

That distinction matters. Passing the build is necessary, but it is not the whole story. In real refactors, developers also need to know which behavior was preserved deliberately and which behavior survived by accident.

What this benchmark actually shows

The benchmark does not prove that OpenCode is always better than Claude Code. It shows that, for this specific refactor, OpenCode’s orchestration produced a cleaner first pass.

More broadly, it shows three things about CLI coding agents:

1. The model is not the whole tool. Both agents used the same model, but they behaved differently.
2. Refactor order matters. Agents need migration strategy, not just task instructions.
3. Verification must be part of the prompt. Running TypeScript and the build after changes prevented both tools from drifting.

The environment issue is also important. Both tools hit the same broken npm shim problem. The lockfile did not care which agent was driving the terminal. Agentic coding still happens inside your actual project, with your actual dependency graph, your actual package manager state, and your actual weirdness.

That is why benchmark leaderboards are useful but incomplete. The better test is whether the agent can survive your repo.

How to prompt CLI agents for large refactors

The best prompts for CLI agents are not just task descriptions. They are operating procedures.

After running this benchmark, I would add four instructions to any large refactor prompt.

Enforce bottom-up refactoring

For prop-drilling migrations, do not let the agent start at the parent:

Refactor components bottom-up: start with the deepest leaf components
(TaskRow, StatsFooter), then work upward through ProjectCard,
ProjectList, ContentArea, and finally DashboardPage. Never modify
a parent component's props until ALL its children have been updated
to read from the store. This prevents cascade errors.

This one instruction would likely have prevented Claude Code’s main coding mistake.

Require explicit logging

OpenCode produced a cleaner log because the prompt forced failure tracking. I would make the logging even stricter:

After EVERY file you modify, immediately append to MISTAKES.md:
the file name, what you changed, and whether tsc passed or failed.
Log even if nothing went wrong. Write "No error" as the status.
This ensures the benchmark captures your full decision process,
not just failures.

A good MISTAKES.md file turns agent output into something you can audit.

Prevent scope creep

Agents love being helpful. Sometimes helpful means “I added a provider layer, middleware, and a clever abstraction you did not ask for.” Do not allow that unless you want it:

Do NOT add middleware, utilities, or patterns that do not exist in
the current codebase unless I explicitly ask for them. The goal
is a 1:1 migration of the state layer, not an improvement pass.

For Zustand specifically, this matters. Zustand can support middleware and slices, but a migration away from prop drilling does not automatically require persist, devtools, or a provider wrapper.

Protect callback side effects

Callback props are dangerous during refactors because they often carry behavior that is not visible from the child component.

Before removing any callback prop, trace its usage in the parent
component. If the callback triggers side effects such as analytics,
notifications, logging, modal state, or navigation, preserve those
side effects in the refactored version. Log any side effects you find
in MISTAKES.md before proceeding.

This was the most important safeguard in the benchmark. A refactor can compile and still be wrong if it drops a side effect.

When to use Claude Code vs. OpenCode

Based on this benchmark and a few smaller follow-up tests, I would not treat these tools as interchangeable. They overlap, but they feel different in practice.

Use case	Better fit	Why
Conservative refactors in conventional Next.js projects	Claude Code	Strong codebase reasoning and conservative file/command permissions
Open source or compliance-sensitive tool evaluation	OpenCode	Source-auditable and provider-flexible
Read-only planning before a risky migration	OpenCode	Strong planning workflow and useful TUI for inspecting diffs
Execution where you want Claude-specific workflows	Claude Code	Tight integration with Claude models, slash commands, and Claude Code conventions
Testing multiple model/provider strategies	OpenCode	Supports broader provider flexibility
Learning from the agent’s mistakes	Either	Only if you force explicit logging and verification

The safest workflow may be using both: run OpenCode in planning mode to map the refactor, then use Claude Code or OpenCode for execution depending on the project’s security, model, and workflow constraints.

A reusable CLI agent prompt for state refactors

Here is the prompt I would use for future Next.js state management migrations:

You are performing a state management refactor on a Next.js 15 + React 19 + TypeScript codebase.

## Context
This app currently uses prop drilling for shared dashboard state. Your job is to migrate that shared state to Zustand. The codebase uses the App Router with a mix of Server and Client Components.

## Rules

1. Read the entire codebase before making any changes. Map out the component tree and identify every prop that represents shared state vs. component-specific props. Log this map in MISTAKES.md under "## State Audit".

2. Before installing dependencies, verify:
   - The package manager by reading package.json and lock files
   - The tsconfig.json path aliases
   - The React version and Zustand compatibility
   - The existing build and typecheck commands

3. Create the Zustand store first. Do not touch any components until the store file compiles cleanly.

4. Refactor components bottom-up:
   - Start with the deepest leaf components
   - Move upward one component at a time
   - Do not remove a parent prop until all children that depended on it have been updated

5. After each component:
   - Run `npx tsc --noEmit`
   - If it fails, fix the error before moving on
   - Log the error in MISTAKES.md with the file, change, error, cause, fix, and category

6. Before removing any callback prop:
   - Open the parent component
   - Check whether the callback triggers side effects
   - Preserve side effects such as analytics, toasts, logging, modal state, or navigation
   - Document what you found in MISTAKES.md

7. Do not:
   - Add middleware unless requested
   - Create provider wrappers unless Zustand is being used with an explicit per-request or dependency-injection pattern
   - Convert Server Components to Client Components unless the component needs client-side interactivity
   - Run commands in parallel

8. After all components are refactored:
   - Run the project’s build command
   - Run `npx tsc --noEmit` one final time
   - Summarize the full refactor in MISTAKES.md under "## Summary"

Begin by reading the project structure and producing the State Audit.

This prompt is longer than the original, but that is the point. Large refactors fail when the agent has freedom in places where you actually need discipline.

Final takeaways

This benchmark changed how I think about terminal coding agents.

Claude Code was not bad because it made mistakes. The mistakes were understandable, recoverable, and useful. OpenCode was not magically perfect because it passed cleanly. It still depended on the same model, the same project environment, and the same verification loop.

The real lesson is that agentic CLI tools are not replacements for engineering judgment. They are accelerators for developers who can specify the migration strategy, identify the risk areas, and recognize when a passing build is not enough.

The developers who get the most out of these tools will not be the ones who refuse to use them, and they will not be the ones who trust them blindly. They will be the ones who know enough architecture to tell the agent where to start, where to stop, and what not to break.

Keep the agent. Keep the compiler. Keep MISTAKES.md.

That is where the useful work happens.

Editor’s note: This article was updated by Chizaram Ken in June 2026 to reflect current React chart library adoption, React 19 and Next.js App Router considerations, SSR and React Server Components tradeoffs, newer bundle-size guidance, and updated use cases for Recharts, react-chartjs-2, Victory, Nivo, React ApexCharts, Ant Design Charts, Apache ECharts, visx, and MUI X Charts.

Here is a quick summary of the adoption, rendering model, and best-fit use case for the React chart libraries we’ll discuss below. Download counts and GitHub stars change frequently, so treat these as directional popularity signals rather than permanent rankings.

Library	Stars	Weekly downloads	Rendering	Best for	Backed by
Recharts	27k+	48m+	SVG	General React dashboards, shadcn/ui projects, SSR-friendly SVG charts	Open source community
react-chartjs-2	6.8k+	3.7m+	Canvas	Canvas-based dashboards, Chart.js teams, authenticated SPAs	Open source community
Victory	11.1k+	371k+	SVG	Teams that need similar chart APIs across web and React Native	Nearform, formerly Formidable Labs
Nivo	14k+	760k+	SVG, Canvas, HTML	Polished dashboards with many chart types and strong defaults	Open source community
React ApexCharts	1.3k+	880k+	SVG	Interactive dashboards with zooming, panning, and mixed charts	Open source community
Ant Design Charts	2.1k+	121k+	Canvas	Ant Design-based internal tools and enterprise dashboards	Ant Design team
Apache ECharts	66k+	2.7m+	SVG, Canvas	Large datasets, advanced interactions, and dense dashboards	Apache
visx	20k+	2.2m+	SVG	Custom visualization systems and bundle-sensitive apps	Airbnb
MUI X Charts	5.7k+	845k+	SVG	MUI apps that need theme integration and SSR-capable charts	MUI team

Why use React chart libraries?

React chart libraries help you build data visualizations without hand-coding every axis, scale, tooltip, legend, animation, and resize behavior from scratch. For small projects, a custom SVG or Canvas chart can be enough. But once your application needs multiple chart types, responsive layouts, tooltips, real-time updates, accessibility support, or consistent theming, a chart library usually saves more time than it costs.

The best React chart library depends on your constraints. Recharts is still the practical default for many React dashboards because its component API is simple and widely understood. react-chartjs-2 and Apache ECharts are better fits when Canvas performance matters. visx gives you the most control, but asks you to compose visualization primitives yourself. MUI X Charts makes the most sense when your app already uses Material UI. Victory remains relevant when React Native parity matters.

That last point is important: there is no single “best” React chart library. The right choice depends on whether you prioritize developer experience, SSR, bundle size, customization, mobile support, accessibility, real-time performance, or design-system integration.

React chart library decision guide

Before comparing feature lists, start with the constraint that actually matters for your project:

Use case	Best fit	Why
“We need beautiful charts fast with minimal configuration”	Recharts or Nivo	Both offer strong defaults and familiar React APIs
“We use shadcn/ui”	Recharts	shadcn/ui chart components are built around Recharts
“We use Material UI”	MUI X Charts	It integrates with MUI themes, typography, and styling conventions
“We need React Native parity”	Victory	Victory and Victory Native have similar APIs
“We need the smallest possible custom chart layer”	visx	It lets you import low-level D3-powered primitives instead of a full charting system
“We have real-time or high-frequency data”	Apache ECharts or react-chartjs-2	Canvas rendering usually handles frequent updates better than SVG
“We need advanced dashboards with many chart types”	Apache ECharts, Nivo, or React ApexCharts	These libraries cover a broad range of visualization types
“We care about SSR in Next.js App Router”	Recharts, MUI X Charts, Victory, or static visx charts	SVG-based libraries generally have the strongest SSR story
“We need 10K+ data points”	Apache ECharts or react-chartjs-2	Canvas mode is better suited to large datasets than SVG

If you only need a bar chart, line chart, and tooltip, do not start with the most powerful option. Start with the smallest library that satisfies your rendering, accessibility, and maintenance requirements.

What changed for React chart libraries in 2026?

React charting decisions look different in 2026 than they did a few years ago. The biggest changes are not just new chart types; they are platform-level concerns around React 19, Next.js App Router, server rendering, and bundle cost.

The main changes developers should consider are:

• React 19 compatibility: Libraries that still depend on older peer dependency ranges can create install friction, especially in Next.js 15+ projects
• Next.js App Router behavior: Many chart components require 'use client' because they depend on state, effects, browser APIs, or React context
• SSR vs. RSC support: Some SVG libraries can render meaningful HTML on the server, but that does not make them true React Server Components
• Bundle size pressure: Chart libraries can add meaningful JavaScript weight, especially when they are not tree-shakeable
• Canvas vs. SVG tradeoffs: SVG is easier to inspect, style, and server-render; Canvas tends to perform better for dense or fast-changing datasets
• Design-system integration: Teams increasingly want charts that inherit tokens, colors, typography, and layout rules from existing UI systems

For a broader look at data visualization tooling and D3-based approaches, see LogRocket’s guide to D3.js adoption. If your charts live inside a larger React design system, LogRocket’s overview of building responsive themes and components with Mantine is also useful context.

React chart libraries and Next.js App Router

If your team uses Next.js App Router, compatibility is not just a matter of whether the package installs. You also need to know whether the chart can render meaningful markup on the server, whether it requires a Client Component boundary, and whether it relies on browser-only APIs.

In practice, every interactive React chart library listed here requires client-side JavaScript. None of them is a fully RSC-native charting solution. The more useful question is whether the library can still produce useful server-rendered HTML before hydration.

Library	Server-rendered HTML	RSC-native without 'use client'	Notes
Recharts	Yes, for SVG charts	No for interactive charts	SVG output gives it a better SSR story than Canvas libraries. Recharts v3 also improves accessibility defaults
react-chartjs-2	No	No	Canvas needs a browser environment. Use a Client Component or dynamic import with SSR disabled
Victory	Yes, for SVG charts	No for interactive charts	Good SSR story for SVG output; React Native parity remains its strongest differentiator
Nivo	Partial	No	SVG/HTML variants can pre-render, but Nivo components still need a Client Component boundary in App Router
React ApexCharts	No in most Next.js App Router setups	No	Relies on browser DOM APIs; usually requires next/dynamic with ssr: false
Ant Design Charts	No	No	Canvas-based rendering makes it a poor SSR fit
Apache ECharts	Partial with SVG mode	No	The core library expects DOM APIs; most teams wrap it in a Client Component
visx	Yes for static SVG charts	Closest for static charts	Static, non-interactive charts can stay very server-friendly; interactivity requires client hooks
MUI X Charts	Yes, with constraints	No for interactive charts	SSR requires explicit dimensions and disabled initial animation

A useful rule of thumb: if the chart uses Canvas or browser-only APIs, assume it is client-only. If it uses SVG, it may be able to render server-side, but interactivity still requires hydration.

For React chart pages where SEO, first contentful paint, or no-JavaScript rendering matters, SVG-based libraries are usually safer. For dashboards behind authentication, where charts are mostly interactive and SEO is irrelevant, Canvas libraries may be the better choice.

The best React chart libraries in 2026

Recharts

Recharts is a composable charting library built with React components and D3 submodules. It remains one of the easiest React-first charting libraries to recommend because its API maps cleanly to how React developers already think: compose components, pass props, and customize where needed.

Recharts is especially strong for product dashboards, internal tools, and marketing/product analytics pages where developers need common chart types without building axes, tooltips, legends, and responsive behavior manually. It uses SVG rendering, which makes charts easier to style, inspect, and server-render than Canvas-based alternatives.

Recharts v3 introduced several important changes. Its internal state was rewritten into smaller chunks, the react-smooth and recharts-scale dependencies were removed, and accessibilityLayer is now enabled by default. Recharts v3 also lets you render arbitrary React components inside a chart without the older Customized wrapper.

Install Recharts with npm or Yarn:

npm install recharts
# or
yarn add recharts

A basic Recharts chart looks like this:

import {
  Bar,
  BarChart,
  CartesianGrid,
  ResponsiveContainer,
  Tooltip,
  XAxis,
  YAxis,
} from 'recharts'

const data = [
  { month: 'Jan', revenue: 2400 },
  { month: 'Feb', revenue: 3200 },
  { month: 'Mar', revenue: 2800 },
]

export function RevenueChart() {
  return (
    <ResponsiveContainer width="100%" height={300}>
      <BarChart data={data}>
        <CartesianGrid strokeDasharray="3 3" />
        <XAxis dataKey="month" />
        <YAxis width="auto" />
        <Tooltip />
        <Bar dataKey="revenue" fill="#2563eb" />
      </BarChart>
    </ResponsiveContainer>
  )
}

The main tradeoff is bundle size. Recharts is convenient, but it is not the lightest option and is not as granular as visx. If you are building a highly custom visualization system or an embedded widget where every kilobyte matters, visx may be a better fit.

Recharts summary

• React component syntax
• Built on D3 submodules
• SVG rendering
• Strong ecosystem adoption
• Good fit for shadcn/ui users
• Improved accessibility defaults in v3
• Best for general-purpose React dashboards

react-chartjs-2

react-chartjs-2 is a React wrapper for Chart.js, one of the most widely used JavaScript charting libraries. If your team already knows Chart.js, react-chartjs-2 gives you a familiar path into React without switching charting concepts entirely.

The biggest architectural difference is rendering: react-chartjs-2 uses Canvas through Chart.js. Canvas is often a good fit for dashboards that need frequent updates, many data points, or better runtime performance than SVG can provide. The tradeoff is that Canvas does not produce meaningful chart markup on the server.

In a Next.js App Router project, treat react-chartjs-2 as a Client Component dependency:

'use client'

import {
  Chart as ChartJS,
  CategoryScale,
  LinearScale,
  BarElement,
  Tooltip,
} from 'chart.js'
import { Bar } from 'react-chartjs-2'

ChartJS.register(CategoryScale, LinearScale, BarElement, Tooltip)

export function RevenueBarChart({ data }) {
  return <Bar data={data} />
}

You can install it with Chart.js as a peer dependency:

npm install react-chartjs-2 chart.js
# or
yarn add react-chartjs-2 chart.js

Use react-chartjs-2 for SPAs, authenticated dashboards, and internal monitoring pages where SEO and server-rendered chart markup do not matter. Avoid it when charts need to appear meaningfully in server-rendered HTML.

For more implementation details, see LogRocket’s guide to using Chart.js in React.

react-chartjs-2 summary

• React wrapper for Chart.js
• Canvas rendering
• Strong Chart.js ecosystem
• Good fit for real-time dashboards and SPAs
• No meaningful SSR path for chart markup
• Requires client-side rendering in Next.js App Router

Victory

Victory is a collection of composable React components for building charts and data visualizations. It is opinionated enough to be productive, but customizable enough to support more complex chart layouts.

Victory’s biggest differentiator is React Native parity. If your team wants similar charting APIs across web and mobile, Victory and Victory Native are still compelling. That makes it more attractive for product teams that maintain web and React Native apps together.

Install Victory with npm or Yarn:

npm install victory
# or
yarn add victory

Victory is SVG-based on the web, which gives it a reasonable SSR story for static charts. It also has approachable documentation and a component model that is easier to understand than lower-level visualization primitives.

That said, Victory is better described as stable and production-proven than fast-moving. For new web-only projects, compare its release cadence and bundle size against Recharts, MUI X Charts, or visx before choosing it by default.

Victory summary

• React component syntax
• SVG rendering
• D3-based charting ecosystem
• Similar API story across web and React Native
• Good documentation
• Best for teams that value React Native parity

Nivo

Nivo is a React charting library built around D3, with SVG, Canvas, and HTML rendering options depending on the chart type. It is popular because it gives developers polished visual defaults without requiring the low-level setup that D3 or visx would require.

Nivo is a good choice when you need attractive charts quickly and want access to chart types beyond the usual bar, line, and pie set. Its scoped package architecture, such as @nivo/bar, @nivo/line, and @nivo/pie, also lets teams install only the chart families they need.

Install Nivo’s core package and the chart package you plan to use:

npm install @nivo/core @nivo/bar

If your project is on React 19 and npm reports peer dependency conflicts, check the current package peer dependency range before forcing installation with --legacy-peer-deps. That flag can be useful during migration, but it should not be treated as the default installation path for every project.

The main Next.js gotcha is that Nivo is not RSC-native. Some Nivo chart variants can produce server-rendered output, but in App Router projects, you should expect to wrap Nivo charts in Client Components because they rely on client-side React behavior.

For a deeper walkthrough, see LogRocket’s guide to building charts in React with Nivo.

Nivo summary

• React component syntax
• Built on D3
• SVG, Canvas, and HTML chart variants
• Polished visual defaults
• Scoped package architecture
• Good for teams that want attractive charts without writing low-level visualization code

React ApexCharts

React ApexCharts is a React wrapper for ApexCharts, a JavaScript charting library focused on interactive charts. It supports common chart types like line, bar, area, pie, donut, scatter, bubble, heatmap, and radial bar charts, and it is particularly useful when dashboards need built-in zooming, panning, scrolling, and mixed chart types.

React ApexCharts renders charts using SVG, but it relies on browser DOM APIs. In Next.js App Router, this usually means using a Client Component or a dynamic import with SSR disabled:

import dynamic from 'next/dynamic'

const Chart = dynamic(() => import('react-apexcharts'), {
  ssr: false,
})

export function ApexDashboardChart(props) {
  return <Chart {...props} />
}

Install React ApexCharts with ApexCharts:

npm install react-apexcharts apexcharts

React ApexCharts is a strong fit for interactive dashboards where client-side chart behavior is more important than SSR. It is less compelling for SEO-sensitive pages or static reporting pages where server-rendered SVG is a priority.

React ApexCharts summary

• React wrapper for ApexCharts.js
• SVG rendering
• Strong interactivity: zooming, panning, scrolling, and mixed charts
• Good for dashboards and monitoring UIs
• Usually needs client-only handling in Next.js App Router

Ant Design Charts

Ant Design Charts is a charting library from the Ant Design ecosystem. It is designed for teams already building enterprise dashboards and internal tools with Ant Design components.

The library supports common chart types like line, bar, pie, and area charts, as well as more specialized visualizations such as funnel charts, radar charts, gauges, box plots, and waterfall charts. Its biggest advantage is ecosystem fit: if your UI already uses Ant Design patterns, Ant Design Charts can help charts feel visually consistent with the rest of the application.

Install it with npm or Yarn:

npm install @ant-design/charts
# or
yarn add @ant-design/charts

The tradeoff is weight. Ant Design Charts is not the lightest option, and its Canvas-oriented rendering model is not ideal for server-rendered chart markup. It is a better fit for data-heavy internal dashboards than for public marketing pages, lightweight widgets, or performance-sensitive landing pages.

Ant Design Charts summary

• React component syntax
• Strong fit for Ant Design projects
• Wide chart coverage
• Canvas-oriented rendering
• Heavier than most alternatives
• Best for enterprise dashboards where Ant Design consistency matters

Apache ECharts

Apache ECharts is a powerful charting and data visualization library maintained by Apache. It supports many chart types, including line, bar, pie, scatter, heatmap, Sankey, graph, radar, tree, and map visualizations. It also supports both SVG and Canvas rendering.

ECharts is one of the strongest options for dense dashboards, large datasets, and advanced interactions. It includes features like zooming, panning, progressive rendering, theming, extensions, and mobile-friendly interactions.

Install ECharts with npm or Yarn:

npm install echarts
# or
yarn add echarts

One important implementation detail: do not import all of ECharts unless you actually need all of it. The naive import is convenient, but it can ship far more code than a selective import:

// Avoid this unless you really need the full package
import * as echarts from 'echarts'

For production apps, use the tree-shakeable API and register only the chart types, components, and renderer you need:

import * as echarts from 'echarts/core'
import { BarChart } from 'echarts/charts'
import {
  GridComponent,
  TitleComponent,
  TooltipComponent,
} from 'echarts/components'
import { CanvasRenderer } from 'echarts/renderers'

echarts.use([
  BarChart,
  GridComponent,
  TitleComponent,
  TooltipComponent,
  CanvasRenderer,
])

That added setup is the main tradeoff. ECharts does not ship a first-party React component API, so React teams often use a wrapper package or write a small Client Component around the core API. For complex dashboards, that extra boilerplate can be worth it.

Apache ECharts summary

• Vanilla JavaScript API with React wrapper options
• SVG and Canvas rendering
• Excellent for large datasets and advanced dashboards
• Strong interaction model
• Requires careful imports to control bundle size
• Often needs a custom React wrapper in Next.js projects

visx

visx is not a conventional charting library. It is a collection of low-level visualization primitives built by Airbnb, combining D3’s math and shape utilities with React rendering.

That distinction matters. Recharts gives you a <BarChart />. visx gives you scales, axes, shapes, groups, and utilities for building your own chart components. That makes it more work upfront, but far more flexible when you need a custom visualization system.

Install only the packages you need:

npm install @visx/group @visx/shape @visx/scale

A minimal visx setup is much more explicit than a Recharts setup because you are composing the chart yourself:

import { Group } from '@visx/group'
import { Bar } from '@visx/shape'
import { scaleBand, scaleLinear } from '@visx/scale'

export function SimpleVisxBarChart({ data, width, height }) {
  const xScale = scaleBand({
    domain: data.map((d) => d.label),
    range: [0, width],
    padding: 0.2,
  })

  const yScale = scaleLinear({
    domain: [0, Math.max(...data.map((d) => d.value))],
    range: [height, 0],
  })

  return (
    <svg width={width} height={height}>
      <Group>
        {data.map((d) => (
          <Bar
            key={d.label}
            x={xScale(d.label)}
            y={yScale(d.value)}
            width={xScale.bandwidth()}
            height={height - yScale(d.value)}
          />
        ))}
      </Group>
    </svg>
  )
}

Use visx when your product needs custom visuals, strict bundle control, or a charting layer that your team owns. Avoid it when you need a quick dashboard and do not want to write chart primitives yourself.

visx summary

• Low-level visualization primitives
• Built on D3 utilities
• SVG rendering
• Very flexible and bundle-conscious
• More development effort than component-based chart libraries
• Best for custom design systems and performance-sensitive visualization layers

MUI X Charts

MUI X Charts is the charting package from the MUI X ecosystem. It is the obvious first option for teams already building with Material UI because it integrates with MUI theming, typography, spacing, and component conventions.

MUI X Charts supports common chart types like line, bar, scatter, and pie charts, with more advanced chart types available through MUI X Pro and Premium packages. The Community package is MIT-licensed and covers many standard dashboard needs, while more advanced features require a commercial license.

Install the package with npm or Yarn:

npm install @mui/x-charts
# or
yarn add @mui/x-charts

The package has peer dependencies on @mui/material, react, and react-dom. If your app does not already use Material UI, install the Material UI dependencies as well:

npm install @mui/material @emotion/react @emotion/styled
# or
yarn add @mui/material @emotion/react @emotion/styled

MUI X Charts has also improved its SSR story. Server-side rendering is supported when you provide explicit chart dimensions and disable animation for the initial render:

---

---

import { BarChart } from '@mui/x-charts/BarChart'

export function RevenueChart({ dataset }) {
  return (
    <BarChart
      width={600}
      height={320}
      dataset={dataset}
      xAxis={[{ dataKey: 'month', scaleType: 'band' }]}
      series={[{ dataKey: 'revenue' }]}
      skipAnimation
    />
  )
}

MUI X Charts is not the smallest option if your app does not already use MUI. But if the MUI ecosystem is already part of your bundle and design system, the integration benefits can outweigh the size cost.

For broader MUI layout context, see LogRocket’s guide to the MUI Grid system.

MUI X Charts summary

• React component syntax
• SVG rendering
• Strong MUI theme integration
• Community package is MIT-licensed; advanced features require Pro or Premium
• SSR support with explicit dimensions and skipAnimation
• Best for teams already using Material UI

Bundle size comparison

Bundle size should not be the only factor in your charting decision, but it is too important to ignore. A chart library can quietly add more JavaScript than the rest of a lightweight dashboard.

The exact numbers vary by version, bundler, import pattern, and whether your app already includes shared dependencies. Use the table below as a directional guide, then verify with your own bundler before committing.

Library	Bundle-size profile	Practical note
visx	Usually smallest for custom charts	You import primitives, but you write more chart code yourself
react-chartjs-2 + Chart.js	Moderate if tree-shaken well	Register only the Chart.js pieces you use
Victory	Middle of the pack	Convenient, but not the lightest SVG option
MUI X Charts	Moderate to heavy if MUI is not already installed	Much more reasonable when MUI is already in your app
Nivo	Depends on selected packages	Scoped packages help, but core dependencies still add weight
Recharts	Convenient but not especially small	Good DX, but limited tree-shaking upside
React ApexCharts	Relatively heavy	ApexCharts engine dominates the bundle
Apache ECharts	Very heavy if imported naively; better with selective imports	Use echarts/core and register only what you need
Ant Design Charts	Heavy	Best reserved for Ant Design dashboards where the ecosystem fit matters

The main takeaway: visx wins on raw control and bundle discipline, but it costs more developer time. Recharts wins on ease of use. ECharts can be performant and powerful, but only if you import it carefully. Ant Design Charts should be used when Ant Design integration matters enough to justify the bundle impact.

Frequently asked questions about React chart libraries

What is the best React chart library for most teams?

For most React dashboards, Recharts is the safest default. It has strong ecosystem adoption, a straightforward component API, SVG rendering, and good compatibility with common React UI stacks like shadcn/ui. It is not the smallest or most customizable option, but it is often the fastest route to production-quality charts.

What is the best React chart library for large datasets?

For large datasets, start with Apache ECharts or react-chartjs-2. Canvas rendering generally handles dense data and frequent updates better than SVG. Apache ECharts is especially strong for large interactive dashboards, while react-chartjs-2 is a good fit for teams already familiar with Chart.js.

Regardless of library choice, use aggregation, downsampling, throttling, debouncing, or windowing when data volume gets high. A chart library cannot compensate for rendering too much data too often.

What is the best React chart library for Next.js App Router?

For Next.js App Router projects where SSR matters, start with SVG-based libraries such as Recharts, Victory, MUI X Charts, or static visx charts. Canvas-based libraries such as react-chartjs-2 and Ant Design Charts are better suited to client-rendered dashboard pages.

Remember that 'use client' does not automatically mean “no server-rendered HTML.” Client Components can still be pre-rendered on the server and hydrated in the browser. The real question is whether the library can produce meaningful initial markup and whether it depends on browser-only APIs.

What is the best React chart library for React Native?

Victory is the strongest option if you want similar charting concepts across React web and React Native. Victory Native gives mobile teams a more direct path than most browser-focused charting libraries.

What is the best React chart library for custom visualizations?

Use visx when you want to build your own visualization components from primitives. It gives you D3-powered scales and shapes while letting React own rendering. It is not the fastest option for a simple dashboard, but it is one of the best options for bespoke visualization systems.

Which React chart library is best for real-time data?

Apache ECharts and react-chartjs-2 are the strongest starting points for real-time data. Both are better suited to frequent updates than SVG-only libraries in many high-volume cases. React ApexCharts can also work well for interactive dashboard updates, but evaluate performance with your actual data shape and update frequency.

Common pain points when using React chart libraries

Visualizing large datasets

Large datasets can cause slow rendering, memory pressure, and browser crashes. Canvas or WebGL rendering usually performs better than SVG for very dense charts, but the bigger fix is often reducing the number of points you render.

Use techniques like:

• Downsampling
• Aggregation
• Pagination or windowing
• Throttling and debouncing updates
• Server-side data preparation
• Canvas rendering for dense or frequently changing data

Unnecessary re-rendering

Charts are often expensive to re-render because data transformation, layout calculation, and animation can all happen during render cycles. Use useMemo to memoize transformed chart data and useCallback for stable event handlers when needed.

Avoid pushing complex chart-specific transformations into global stores unless multiple components need the same derived data. In many cases, selectors or local memoized computations are easier to reason about.

Mobile responsiveness

Chart responsiveness depends on more than setting width: 100%. You need to account for labels, tooltips, legends, tap targets, and whether users can read the data on a small screen.

For mobile dashboards:

• Prefer fewer series per chart
• Reduce label density
• Use responsive containers or explicit breakpoints
• Test tooltip behavior on touch devices
• Consider horizontal scrolling for dense timelines
• Avoid relying only on hover interactions

Accessibility

Accessibility support varies widely across chart libraries. SVG can be easier to annotate with semantic labels, while Canvas often requires more work to provide accessible alternatives.

At minimum, provide:

• A text summary of the chart’s takeaway
• Proper labels and legends
• Keyboard-accessible interactions where possible
• Sufficient color contrast
• Non-color encodings for important distinctions
• A data table fallback for critical information

Recharts v3’s accessibilityLayer improvements are a meaningful step, but no chart library removes the need to design accessible data experiences intentionally.

Conclusion

There are more React chart libraries than one article can cover, but the libraries above represent the main tradeoffs most teams face in 2026: ease of use, rendering model, bundle size, SSR behavior, customization, React Native support, and design-system integration.

For most teams, Recharts is still the most practical default. Use react-chartjs-2 or Apache ECharts when performance and Canvas rendering matter. Choose visx when you need a custom visualization layer and can afford the engineering time. Use MUI X Charts or Ant Design Charts when your design system already points you in that direction. Choose Victory when web and React Native parity is the priority.

The best chart library is not the one with the most chart types or GitHub stars. It is the one whose tradeoffs match your product: the amount of data you render, the level of customization you need, the platform you ship on, and the maintenance burden your team is willing to own.

Data tables are more expensive to maintain than they look. What starts as a sorted list of rows can quickly turn into duplicated filter logic, inconsistent pagination behavior, and subtle bugs where the mobile card view runs different sorting code than the desktop table. As the UI grows, table components often become one of the most fragile parts of the codebase.

A headless table engine solves that by separating data behavior from markup. In Vue 3, you can put filtering, sorting, pagination, and table state into a reusable composable, then expose that logic through a renderless component or use it directly in any view. The result is one source of truth for table behavior and multiple rendering options: a classic table, a card grid, a product list, or any other layout your design system needs.

In this tutorial, we’ll build a small headless table engine in Vue 3 with the Composition API. It will not replace a full-featured library like TanStack Table for advanced grids, virtualization, column pinning, or enterprise data workflows. Instead, it gives you a lightweight pattern for shared table logic when your app needs reusable sorting, filtering, and pagination without locking every screen into the same HTML structure.

What we’re building

The goal is to build one reusable data engine and render it three different ways:

Piece	Purpose
useTableEngine	A Vue composable that owns filtering, sorting, pagination, and table state
TableEngine.vue	A renderless component that exposes the composable through a scoped slot
UsersTableView.vue	A classic table layout powered by the engine
UsersCardView.vue	A card grid powered by the same engine
ProductsView.vue	A direct composable example that skips the wrapper component

This is the core benefit of a headless architecture: the engine decides what the data is doing, while each consumer decides how that data should look.

When to use a headless table engine

Headless table logic is useful when table behavior needs to survive UI changes. It is less useful when you only need a simple, one-off table.

Use case	Headless table engine fit
One table on one internal admin page	Probably overkill
Same data shown as a table on desktop and cards on mobile	Strong fit
Shared filtering, sorting, and pagination across multiple screens	Strong fit
Highly customized design system tables	Strong fit
Enterprise grid features like virtualization, resizing, column pinning, and grouping	Use a mature table/grid library
Server-side pagination, search, and sorting	Use this pattern as a client wrapper, but move the heavy data work to the API

The pattern in this tutorial is intentionally small. That makes it easier to understand, adapt, and extend, but it also means you should be honest about where the abstraction stops.

The stack

We’ll use:

• Vue 3 with the Composition API
• Vite for project setup
• Tailwind CSS utility classes for quick styling
• A Vue composable for reusable table logic
• A renderless component with scoped slots for flexible rendering

Vue composables are a natural fit here because they let you extract reusable stateful logic out of a component and reuse it across different UI surfaces. LogRocket has a deeper introduction to Vue composables if you want more background on the pattern.

What is a headless component?

A headless component provides behavior without rendering its own UI. It manages state and actions, such as the active page, active sort column, sort direction, and current filter query, but leaves all markup to the consumer.

In Vue, one common way to do this is with scoped slots. A renderless component passes its state and methods into a slot, and the parent component uses those values to render whatever HTML it needs. The logic and layout stay separate.

That separation matters for tables because table logic is often useful outside a <table>. A desktop view might need <thead>, <tbody>, and <tr> elements. A mobile view might need cards. A compact sidebar might need a list. If each layout owns its own sorting and filtering, the implementations drift over time.

A headless engine avoids that drift by making the data behavior reusable. If you want a broader explanation of slots and renderless components, see LogRocket’s guide to slots in Vue.js.

The cost of tightly coupled tables

Component-level coupling usually starts harmlessly. You write a DataTable component. It sorts when users click a column header. It paginates at 10 rows per page. It works.

Then the design team asks for a mobile card view. The card view needs the same sorting and pagination behavior, but it cannot use table rows and cells. So you copy the logic into a new component.

Now two components own the same behavior. A bug gets fixed in one and not the other. The filter behavior on mobile quietly diverges from the desktop version. Later, the pagination page size changes from 10 to 25, and you find three hardcoded values but update only two. Tables are very good at becoming boring until they are suddenly not boring at all.

The headless pattern addresses this by placing state management in one location and letting any number of consumers render it however they need.

Setting up the Vue project

Create a new Vue project with Vite:

npm create vite@latest headless-table -- --template vue
cd headless-table
npm install

Vite’s current docs support this template-based setup for Vue projects. Make sure your local Node.js version satisfies Vite’s current requirements before starting.

Now create two directories:

mkdir src/composables
mkdir src/views

The src/composables directory will hold the reusable table logic. Vue does not require this folder name, but it is a common convention for Composition API code. The src/views directory will hold the page-level examples that consume the table engine.

For the tutorial, we’ll use Tailwind’s browser-based CDN so the examples are easy to run without extra configuration. Tailwind’s docs describe the Play CDN as a development/prototyping tool, not a production setup, so use the official Vite or PostCSS setup for real applications.

Open index.html and add the Tailwind browser script inside the <head> tag:

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <link rel="icon" type="image/svg+xml" href=" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>headless-table</title>
  <script src="
</head>
<body>
  <div id="app"></div>
  <script type="module" src="/src/main.js"></script>
</body>
</html>

Start the dev server:

npm run dev

Open in your browser. You should see the default Vite welcome page. Once that is working, clear out src/App.vue; we’ll replace it as we build each view.

Building the useTableEngine composable

The composable is the core of the headless table engine. It accepts raw data and an options object, then returns a stable API for filtering, sorting, and pagination. It contains no HTML and does not know whether its data will be rendered as a table, grid, or list.

Create src/composables/useTableEngine.js and start with the imports and function signature:

import { ref, computed, watch } from 'vue'

export function useTableEngine(rawData, options = {}) {

The rawData argument should be a reactive ref, such as ref([...]) or toRef(props, 'data'). Passing a ref keeps the engine synchronized if the source array changes.

Next, extract the options with defaults:

  const {
    defaultPageSize = 10,
    defaultSortKey = null,
    defaultSortDirection = 'asc',
  } = options

These options let each consumer decide the starting page size, default sort column, and default sort direction without changing the engine.

Now add the internal state:

  const currentPage = ref(1)
  const pageSize = ref(defaultPageSize)
  const sortKey = ref(defaultSortKey)
  const sortDirection = ref(defaultSortDirection)
  const filterQuery = ref('')

Each value is a ref, so Vue tracks changes and recomputes any dependent values. The filterQuery ref is what we’ll bind to a search input in the views.

Add the filtered data computed property:

  const filteredData = computed(() => {
    const query = filterQuery.value.trim().toLowerCase()

    if (!query) {
      return rawData.value
    }

    return rawData.value.filter((row) =>
      Object.values(row).some((value) =>
        String(value ?? '').toLowerCase().includes(query)
      )
    )
  })

This performs a simple global search across every value in each row. For production tables, you may want column-specific filtering, custom filter functions, or server-side filtering. For this tutorial, a global text search keeps the engine readable while demonstrating the pattern.

Now add sorting:

  const sortedData = computed(() => {
    if (!sortKey.value) {
      return filteredData.value
    }

    return [...filteredData.value].sort((a, b) => {
      const aValue = a[sortKey.value]
      const bValue = b[sortKey.value]

      if (aValue == null && bValue == null) return 0
      if (aValue == null) return 1
      if (bValue == null) return -1

      if (typeof aValue === 'number' && typeof bValue === 'number') {
        return sortDirection.value === 'asc'
          ? aValue - bValue
          : bValue - aValue
      }

      const comparison = String(aValue).localeCompare(String(bValue))
      return sortDirection.value === 'asc' ? comparison : -comparison
    })
  })

The spread operator creates a copy before sorting so the original array is not mutated. Numeric values use a numeric comparison. Other values use localeCompare, which handles string ordering better than raw > and < comparisons.

Add pagination:

  const totalRows = computed(() => filteredData.value.length)

  const totalPages = computed(() =>
    Math.max(1, Math.ceil(totalRows.value / pageSize.value))
  )

  const paginatedData = computed(() => {
    const start = (currentPage.value - 1) * pageSize.value
    return sortedData.value.slice(start, start + pageSize.value)
  })

The page count is based on filteredData, not the raw dataset, so it updates correctly when users search. paginatedData is the final array consumers render: filtered, sorted, and sliced to the current page.

Next, add actions for sorting and navigation:

  function toggleSort(key) {
    if (sortKey.value === key) {
      if (sortDirection.value === 'asc') {
        sortDirection.value="desc"
      } else {
        sortKey.value = null
        sortDirection.value="asc"
      }

      return
    }

    sortKey.value = key
    sortDirection.value="asc"
  }

  function goToPage(page) {
    currentPage.value = Math.min(Math.max(1, page), totalPages.value)
  }

  function nextPage() {
    goToPage(currentPage.value + 1)
  }

  function prevPage() {
    goToPage(currentPage.value - 1)
  }

toggleSort cycles through three states: ascending, descending, and unsorted. goToPage clamps the requested page between 1 and totalPages, preventing consumers from accidentally navigating out of bounds.

Add watchers to keep pagination valid as the dataset changes:

  watch([filterQuery, sortKey, sortDirection, pageSize], () => {
    currentPage.value = 1
  })

  watch(totalPages, () => {
    if (currentPage.value > totalPages.value) {
      goToPage(totalPages.value)
    }
  })

The first watcher resets the page when the filter, sort, or page size changes. Without this, a user could filter down to two rows while still sitting on page three. The second watcher handles cases where the raw dataset changes and the current page is no longer valid.

Finally, return the public API:

  return {
    filterQuery,
    currentPage,
    pageSize,
    sortKey,
    sortDirection,
    filteredData,
    sortedData,
    paginatedData,
    totalRows,
    totalPages,
    toggleSort,
    goToPage,
    nextPage,
    prevPage,
    isSorted: (key) => sortKey.value === key,
    sortDirectionFor: (key) =>
      sortKey.value === key ? sortDirection.value : null,
  }
}

This return object is the contract between the engine and its consumers. Everything else can change internally as long as this API stays stable.

Here is the complete composable:

import { ref, computed, watch } from 'vue'

export function useTableEngine(rawData, options = {}) {
  const {
    defaultPageSize = 10,
    defaultSortKey = null,
    defaultSortDirection = 'asc',
  } = options

  const currentPage = ref(1)
  const pageSize = ref(defaultPageSize)
  const sortKey = ref(defaultSortKey)
  const sortDirection = ref(defaultSortDirection)
  const filterQuery = ref('')

  const filteredData = computed(() => {
    const query = filterQuery.value.trim().toLowerCase()

    if (!query) {
      return rawData.value
    }

    return rawData.value.filter((row) =>
      Object.values(row).some((value) =>
        String(value ?? '').toLowerCase().includes(query)
      )
    )
  })

  const sortedData = computed(() => {
    if (!sortKey.value) {
      return filteredData.value
    }

    return [...filteredData.value].sort((a, b) => {
      const aValue = a[sortKey.value]
      const bValue = b[sortKey.value]

      if (aValue == null && bValue == null) return 0
      if (aValue == null) return 1
      if (bValue == null) return -1

      if (typeof aValue === 'number' && typeof bValue === 'number') {
        return sortDirection.value === 'asc'
          ? aValue - bValue
          : bValue - aValue
      }

      const comparison = String(aValue).localeCompare(String(bValue))
      return sortDirection.value === 'asc' ? comparison : -comparison
    })
  })

  const totalRows = computed(() => filteredData.value.length)

  const totalPages = computed(() =>
    Math.max(1, Math.ceil(totalRows.value / pageSize.value))
  )

  const paginatedData = computed(() => {
    const start = (currentPage.value - 1) * pageSize.value
    return sortedData.value.slice(start, start + pageSize.value)
  })

  function toggleSort(key) {
    if (sortKey.value === key) {
      if (sortDirection.value === 'asc') {
        sortDirection.value="desc"
      } else {
        sortKey.value = null
        sortDirection.value="asc"
      }

      return
    }

    sortKey.value = key
    sortDirection.value="asc"
  }

  function goToPage(page) {
    currentPage.value = Math.min(Math.max(1, page), totalPages.value)
  }

  function nextPage() {
    goToPage(currentPage.value + 1)
  }

  function prevPage() {
    goToPage(currentPage.value - 1)
  }

  watch([filterQuery, sortKey, sortDirection, pageSize], () => {
    currentPage.value = 1
  })

  watch(totalPages, () => {
    if (currentPage.value > totalPages.value) {
      goToPage(totalPages.value)
    }
  })

  return {
    filterQuery,
    currentPage,
    pageSize,
    sortKey,
    sortDirection,
    filteredData,
    sortedData,
    paginatedData,
    totalRows,
    totalPages,
    toggleSort,
    goToPage,
    nextPage,
    prevPage,
    isSorted: (key) => sortKey.value === key,
    sortDirectionFor: (key) =>
      sortKey.value === key ? sortDirection.value : null,
  }
}

From here, we can consume the engine in two ways: through a renderless component or by importing the composable directly.

Building the renderless TableEngine component

The renderless component is a convenience wrapper around useTableEngine. It accepts data and initial options as props, creates the engine, then exposes that engine through a scoped slot.

Create src/components/TableEngine.vue:

<script setup>
import { reactive, toRef, watch } from 'vue'
import { useTableEngine } from '../composables/useTableEngine'

const props = defineProps({
  data: {
    type: Array,
    required: true,
  },
  pageSize: {
    type: Number,
    default: 10,
  },
  defaultSortKey: {
    type: String,
    default: null,
  },
  defaultSortDirection: {
    type: String,
    default: 'asc',
  },
})

const engine = reactive(
  useTableEngine(toRef(props, 'data'), {
    defaultPageSize: props.pageSize,
    defaultSortKey: props.defaultSortKey,
    defaultSortDirection: props.defaultSortDirection,
  })
)

watch(
  () => props.pageSize,
  (newSize) => {
    engine.pageSize = newSize
    engine.currentPage = 1
  }
)
</script>

<template>
  <slot :engine="engine"></slot>
</template>

There are two details worth calling out:

• toRef(props, 'data') passes the data prop into the composable as a reactive reference, so the engine stays synchronized with parent updates.
• reactive(useTableEngine(...)) lets templates access engine.filterQuery and engine.currentPage directly, without adding .value everywhere.

This component renders only a slot. That is the whole point: TableEngine.vue owns behavior, while the parent owns markup.

Rendering a classic table layout

Now we’ll build the first consumer: a traditional HTML table. Sorting, filtering, and pagination come from the engine. The view only decides how to render rows and controls.

Create src/views/UsersTableView.vue and add the script block:

<script setup>
import { ref } from 'vue'
import TableEngine from '../components/TableEngine.vue'

const users = ref([
  { id: 1, name: 'Amara Nwosu', role: 'Engineer', status: 'Active', joined: 2021 },
  { id: 2, name: 'Luca Ferretti', role: 'Designer', status: 'Active', joined: 2022 },
  { id: 3, name: 'Sara Lindqvist', role: 'Manager', status: 'Inactive', joined: 2019 },
  { id: 4, name: 'Kenji Mori', role: 'Engineer', status: 'Active', joined: 2023 },
  { id: 5, name: 'Priya Mehta', role: 'Analyst', status: 'Active', joined: 2020 },
])

const columns = ['name', 'role', 'status', 'joined']
</script>

There are no local sorting, filtering, or pagination methods here. The component only owns its sample data and column list.

Now add the template:

<template>
  <TableEngine :data="users" :page-size="3" default-sort-key="name">
    <template #default="{ engine }">
      <div class="mx-auto max-w-4xl rounded-2xl border border-gray-200 bg-white p-6 shadow-sm">
        <div class="mb-4 flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
          <div>
            <h1 class="text-lg font-semibold text-gray-900">Users</h1>
            <p class="text-sm text-gray-500">
              Shared filtering, sorting, and pagination from the table engine.
            </p>
          </div>

          <input
            v-model="engine.filterQuery"
            type="search"
            placeholder="Search users..."
            class="w-full rounded-md border border-gray-300 px-4 py-2 text-sm sm:w-64"
          />
        </div>

        <div class="overflow-x-auto rounded-lg border border-gray-200">
          <table class="w-full text-left text-sm text-gray-700">
            <thead class="bg-gray-50 text-xs uppercase text-gray-500">
              <tr>
                <th
                  v-for="col in columns"
                  :key="col"
                  scope="col"
                  class="px-6 py-3"
                  :aria-sort="
                    engine.sortKey === col
                      ? engine.sortDirection === 'asc'
                        ? 'ascending'
                        : 'descending'
                      : 'none'
                  "
                >
                  <button
                    type="button"
                    class="flex items-center gap-1 font-semibold uppercase hover:text-gray-900"
                    @click="engine.toggleSort(col)"
                  >
                    {{ col }}
                    <span class="text-gray-400">
                      {{ engine.sortKey === col ? (engine.sortDirection === 'asc' ? '↑' : '↓') : '↕' }}
                    </span>
                  </button>
                </th>
              </tr>
            </thead>

            <tbody class="divide-y divide-gray-100 bg-white">
              <tr
                v-for="row in engine.paginatedData"
                :key="row.id"
                class="hover:bg-blue-50"
              >
                <td class="px-6 py-4 font-medium">{{ row.name }}</td>
                <td class="px-6 py-4">{{ row.role }}</td>
                <td class="px-6 py-4">
                  <span
                    :class="[
                      'rounded-full px-2 py-0.5 text-xs font-semibold',
                      row.status === 'Active'
                        ? 'bg-green-100 text-green-700'
                        : 'bg-gray-100 text-gray-500',
                    ]"
                  >
                    {{ row.status }}
                  </span>
                </td>
                <td class="px-6 py-4">{{ row.joined }}</td>
              </tr>

              <tr v-if="engine.paginatedData.length === 0">
                <td colspan="4" class="px-6 py-12 text-center text-gray-400">
                  No results found.
                </td>
              </tr>
            </tbody>
          </table>
        </div>

        <div class="mt-4 flex items-center justify-between text-sm text-gray-600">
          <span>
            {{ engine.totalRows }} result{{ engine.totalRows !== 1 ? 's' : '' }}
          </span>

          <div class="flex items-center gap-2">
            <button
              type="button"
              @click="engine.prevPage"
              :disabled="engine.currentPage === 1"
              class="rounded border border-gray-300 px-3 py-1 hover:bg-gray-50 disabled:opacity-40"
            >
              Previous
            </button>

            <span>Page {{ engine.currentPage }} of {{ engine.totalPages }}</span>

            <button
              type="button"
              @click="engine.nextPage"
              :disabled="engine.currentPage === engine.totalPages"
              class="rounded border border-gray-300 px-3 py-1 hover:bg-gray-50 disabled:opacity-40"
            >
              Next
            </button>
          </div>
        </div>
      </div>
    </template>
  </TableEngine>
</template>

The important line is v-for="row in engine.paginatedData". By the time the template sees the data, the engine has already applied filtering, sorting, and pagination.

The sort controls also call the engine directly:

@click="engine.toggleSort(col)"

The table layout does not own the sort algorithm. It only chooses how users trigger it.

To render this view, replace src/App.vue with:

<template>
  <main class="min-h-screen bg-gray-50 p-8">
    <UsersTableView />
  </main>
</template>

<script setup>
import UsersTableView from './views/UsersTableView.vue'
</script>

Save the file. You should now see a working table with search, sorting, and pagination.

Rendering the same data as a card grid

The second consumer uses the same engine for a card-based layout. None of the data logic changes. Only the markup changes.

Create src/views/UsersCardView.vue:

<script setup>
import { ref } from 'vue'
import TableEngine from '../components/TableEngine.vue'

const users = ref([
  { id: 1, name: 'Amara Nwosu', role: 'Engineer', status: 'Active', joined: 2021 },
  { id: 2, name: 'Luca Ferretti', role: 'Designer', status: 'Active', joined: 2022 },
  { id: 3, name: 'Sara Lindqvist', role: 'Manager', status: 'Inactive', joined: 2019 },
  { id: 4, name: 'Kenji Mori', role: 'Engineer', status: 'Active', joined: 2023 },
  { id: 5, name: 'Priya Mehta', role: 'Analyst', status: 'Active', joined: 2020 },
])
</script>

Now add the template:

<template>
  <TableEngine :data="users" :page-size="4">
    <template #default="{ engine }">
      <div class="mx-auto max-w-4xl rounded-2xl border border-gray-200 bg-white p-6 shadow-sm">
        <div class="mb-4 flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
          <input
            v-model="engine.filterQuery"
            type="search"
            placeholder="Search users..."
            class="w-full rounded-xl border border-gray-200 px-4 py-3 text-sm sm:w-64"
          />

          <div class="flex flex-wrap gap-2">
            <button
              v-for="col in ['name', 'role', 'joined']"
              :key="col"
              type="button"
              @click="engine.toggleSort(col)"
              class="rounded-full border border-gray-300 px-3 py-1 text-xs capitalize hover:bg-gray-100"
            >
              Sort by {{ col }}
            </button>
          </div>
        </div>

        <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">
          <article
            v-for="user in engine.paginatedData"
            :key="user.id"
            class="rounded-2xl border border-gray-200 bg-white p-5"
          >
            <div class="flex items-start justify-between">
              <div>
                <p class="font-semibold text-gray-900">{{ user.name }}</p>
                <p class="text-sm text-gray-500">{{ user.role }}</p>
              </div>

              <span
                :class="[
                  'rounded-full px-2 py-0.5 text-xs font-semibold',
                  user.status === 'Active'
                    ? 'bg-green-100 text-green-700'
                    : 'bg-gray-100 text-gray-400',
                ]"
              >
                {{ user.status }}
              </span>
            </div>

            <p class="mt-3 text-xs text-gray-400">Joined {{ user.joined }}</p>
          </article>
        </div>

        <p
          v-if="engine.paginatedData.length === 0"
          class="py-12 text-center text-sm text-gray-400"
        >
          No results found.
        </p>

        <div class="mt-6 flex justify-center gap-3">
          <button
            type="button"
            @click="engine.prevPage"
            :disabled="engine.currentPage === 1"
            class="rounded-full border px-4 py-2 text-sm disabled:opacity-40"
          >
            Previous
          </button>

          <button
            type="button"
            @click="engine.nextPage"
            :disabled="engine.currentPage === engine.totalPages"
            class="rounded-full border px-4 py-2 text-sm disabled:opacity-40"
          >
            Next
          </button>
        </div>
      </div>
    </template>
  </TableEngine>
</template>

This view uses engine.paginatedData, engine.filterQuery, and engine.toggleSort, just like the table view. But the UI is completely different. That is the whole payoff: the engine stays fixed while the rendering changes freely.

Update App.vue to render the card view:

<template>
  <main class="min-h-screen bg-gray-50 p-8">
    <UsersCardView />
  </main>
</template>

<script setup>
import UsersCardView from './views/UsersCardView.vue'
</script>

Refresh the browser. The card grid appears with the same search, sorting, and pagination behavior.

Using the composable directly

You do not always need the renderless wrapper component. If a team prefers less indirection, or if a component only needs the table logic locally, it can import useTableEngine directly.

This approach is closer to standard Composition API usage and may feel more familiar if your team already organizes reusable logic through composables. LogRocket’s guide to the Vue Composition API covers the broader pattern in more detail.

Create src/views/ProductsView.vue:

<script setup>
import { ref } from 'vue'
import { useTableEngine } from '../composables/useTableEngine'

const products = ref([
  { id: 1, name: 'Widget Pro', category: 'Hardware', price: 49.99 },
  { id: 2, name: 'SoftSuite', category: 'Software', price: 199.0 },
  { id: 3, name: 'Cable Pack', category: 'Hardware', price: 12.5 },
  { id: 4, name: 'CloudStorage 1TB', category: 'Software', price: 9.99 },
  { id: 5, name: 'ErgoMouse', category: 'Hardware', price: 85.0 },
  { id: 6, name: 'DevFlow IDE', category: 'Software', price: 250.0 },
  { id: 7, name: '4K Monitor', category: 'Hardware', price: 349.99 },
  { id: 8, name: 'Security Shield', category: 'Software', price: 59.0 },
  { id: 9, name: 'Mechanical Keyboard', category: 'Hardware', price: 129.5 },
])

const {
  paginatedData,
  filterQuery,
  toggleSort,
  nextPage,
  prevPage,
  currentPage,
  totalPages,
  totalRows,
} = useTableEngine(products, {
  defaultPageSize: 4,
})
</script>

Because the composable returns refs and computed refs, Vue templates automatically unwrap them. That means v-model="filterQuery" and v-for="product in paginatedData" work naturally in the template.

Add the template:

<template>
  <div class="mx-auto max-w-2xl rounded-2xl border border-gray-200 bg-white p-6 shadow-sm">
    <div class="mb-4">
      <h1 class="text-lg font-semibold text-gray-900">Products</h1>
      <p class="text-sm text-gray-500">
        This view uses the composable directly, without the renderless component.
      </p>
    </div>

    <input
      v-model="filterQuery"
      type="search"
      placeholder="Filter products..."
      class="mb-4 w-full rounded border border-gray-300 p-2"
    />

    <div class="mb-4 flex gap-2">
      <button
        type="button"
        @click="toggleSort('name')"
        class="rounded-full border px-3 py-1 text-sm hover:bg-gray-50"
      >
        Sort by name
      </button>

      <button
        type="button"
        @click="toggleSort('price')"
        class="rounded-full border px-3 py-1 text-sm hover:bg-gray-50"
      >
        Sort by price
      </button>
    </div>

    <ul class="space-y-2">
      <li
        v-for="product in paginatedData"
        :key="product.id"
        class="flex justify-between rounded-lg border bg-white p-4"
      >
        <span class="font-medium">{{ product.name }}</span>
        <span class="text-gray-500">{{ product.category }}</span>
        <span class="font-semibold">${{ product.price }}</span>
      </li>
    </ul>

    <p
      v-if="paginatedData.length === 0"
      class="py-10 text-center text-sm text-gray-400"
    >
      No products found.
    </p>

    <div class="mt-4 flex items-center justify-between">
      <span class="text-sm text-gray-500">
        {{ totalRows }} result{{ totalRows !== 1 ? 's' : '' }}
      </span>

      <div class="flex gap-2">
        <button
          type="button"
          @click="prevPage"
          :disabled="currentPage === 1"
          class="rounded border px-3 py-1 disabled:opacity-40"
        >
          Prev
        </button>

        <button
          type="button"
          @click="nextPage"
          :disabled="currentPage === totalPages"
          class="rounded border px-3 py-1 disabled:opacity-40"
        >
          Next
        </button>
      </div>
    </div>
  </div>
</template>

Update App.vue one more time:

<template>
  <main class="min-h-screen bg-gray-50 p-8">
    <ProductsView />
  </main>
</template>

<script setup>
import ProductsView from './views/ProductsView.vue'
</script>

Refresh the browser. You now have a product list with filtering, sorting, and pagination, powered directly by the composable.

Choosing between the wrapper and direct composable

Both approaches are valid. The better choice depends on how your team wants to expose table behavior.

Approach	Best for	Tradeoff
TableEngine.vue renderless component	Teams that want a declarative template API and reusable slot contract	Scoped slot syntax adds some indirection
Direct useTableEngine composable	Teams comfortable with Composition API and local setup in each view	Each consumer has to import and wire the composable manually
Pre-styled table component on top of the engine	Product teams that need a fast default table	Less flexible than the headless layer

In practice, many teams use all three layers: a low-level composable, a renderless component for flexible screens, and a default styled table for standard admin pages. That gives developers a fast path without closing off customization.

Tradeoffs and practical limits

Headless architecture is useful, but it is not free. It moves responsibility from the component to the consumer, and that affects how your team writes and maintains UI.

Consumers become more verbose

A standard table component such as <DataTable :data="users" /> can produce a working table in one line. The headless approach requires the consumer to write the <thead>, <tbody>, every row, and every control. For one-off internal tools or quick prototypes, that may not be worth it.

A practical compromise is to build a pre-styled DefaultTable.vue on top of the engine. Teams can use the default renderer for speed and drop down to the headless API when they need full control.

Scoped slots require team familiarity

The pattern <template #default="{ engine }"> is straightforward once explained, but it may be unfamiliar to junior developers or teams coming from React. A short internal guide with two or three approved examples is usually enough to make the pattern comfortable.

The simple engine is not an enterprise grid

The engine in this tutorial covers filtering, sorting, and pagination. It does not include:

• Virtualized rows for very large datasets
• Server-side filtering, sorting, or pagination
• Column resizing or pinning
• Row selection
• Keyboard navigation for a full spreadsheet-like grid
• Complex accessibility behavior for advanced data grids

That is intentional. The goal is not to rebuild a full grid library. It is to make shared table behavior reusable across layouts. If your requirements include thousands of rows, column virtualization, resize handles, grouping, or advanced keyboard interaction, use a mature table or grid library instead.

Client-side data work has limits

This tutorial filters and sorts in the browser. That is fine for small to moderate datasets. For larger datasets, move filtering, sorting, and pagination to the server, then use the headless engine to manage UI state and display the current page.

For example, the engine can still track filterQuery, sortKey, and currentPage, but those values would become request parameters sent to your API rather than being applied to a local array.

Conclusion

Maintaining data tables does not have to mean rewriting the same logic every time the design changes. By placing filtering, sorting, and pagination in a composable, then leaving rendering to the consumer, you avoid the duplication that causes table behavior to drift across an application.

The headless pattern works well when the same data behavior needs to power multiple UI shapes: a table on desktop, a card grid on mobile, or a compact list in a sidebar. It also gives teams a clean place to extend table behavior over time without tying every decision to one component’s markup.

The engine we built here is intentionally small, but the architecture scales. The composable handles what the data is doing. The consumer decides how it looks. When one changes, the other does not need to.

Suggested next steps

• Convert useTableEngine to TypeScript and make the row type generic
• Add column-specific filters
• Add server-side pagination support
• Build a pre-styled DefaultTable.vue on top of the engine
• Add accessibility tests for keyboard and screen reader behavior

“Dolphin, do a flip!” my 2.5-year-old yells enthusiastically from his seat next to me. Carefully choreographed, a dolphin launches out of the water and over the person sitting on a small boat, like so:

As the dolphins perform their show, I’m connected to an SSH session of a virtual machine at home. This computer has OpenCode installed and is quietly puzzling through how to implement a requested feature.

An orchestrator agent takes my simple requests and delegates them out to specialized agents with specific roles. Each request tries to implement my requested feature, and after it’s done, commit the changes to Git, and push them to GitHub. Another virtual machine on the same computer sees that the repository has changed, clones the repository, builds the app, and sends it to Firebase App Testing. Simultaneously, Dokploy rebuilds the Docker containers for the app and runs the database migrations to upgrade the schema if required.

We’re at the penguin enclosure when my phone buzzes, telling me a new version is available. I update the app and check if my new feature has been implemented, and it has. Mostly, it looks and feels good, but it needs some minor adjustments. I give these comments back to OpenCode, it makes the changes, pushes the code, and the cycle repeats.

What am I doing? I’ve got four weeks to go from zero to app: backend, database, authentication, everything. Why only four weeks? Because I’m participating in the RevenueCat Shipyard competition for a grand prize of $20,000 USD.

As you may have guessed from reading this article (and how I am very much not on a worldwide cruise at the moment), I did not win. But what if the real win was the lessons I learned along the way? I tell myself that in order to cope with, you know, not being $20,000 USD richer. Anyway, moving on.

A call to action

I was at a random cafe when I got an email about the Shipyard competition. I read this pitch, and it really resonated with me.

“Rebecca hears it constantly: mums are short on time, want financial independence, and need practical help. Build an app that offers everyday money-saving guidance (shopping swaps, batch cooking, cost comparisons, home reno savings) plus an approachable path into investing basics so users can grow what they have, without overwhelm.”

I mean, it’s hard to picture how this wouldn’t be an app that had way too many features. Recipes and investing are fairly disparate, so how would you mesh them into one app? Plus, investment apps don’t really give third-party apps a window into how investments are going.

My approach: instead of trying to deliver on everything, just deliver well on two things: the recipe list and the upcycling projects. For recipes, I would focus on batch-cooking and using one base recipe to spin off multiple other recipes. For upcycling, I would encourage a community-based approach, where people could list the things they wanted to upcycle and sell, and possibly get the help of others.

All good ideas. And then I saw that the deadline for delivering the app was only four weeks away.

A developer that I worked with once, pre-AI era, commented that it would cost fifty grand for a “Hello World” app in the corporate marketplace. Just the time involved to stand up a project team, define requirements, get a developer to write it, and then manage the deployment, etc., was cost-prohibitive. It would take longer than four weeks to deploy an app from zero to usable in a professional corporate environment, even if that app were only “Hello World”.

Four weeks is not a long time. Traditionally, I would set up a basic database schema and then rough out some API actions for the app to interact with. If I were making this app back in the day, the schedule would probably look like this:

• Week 1: Rough out API and database schema
• Week 2: Rough out phone app, work out authentication and interaction with API
• Week 3: Work on API and phone app concurrently, implement features
• Week 4: Publish app to Play Store, work on publishing pipeline, and final polish

Of note: if any of the above steps went overtime (as they frequently did), then it would push everything back. Sometimes this would be immensely discouraging, as you would feel like you couldn’t possibly get the app done in the time allotted.

For all of this, where would I be? At my computer desk. Not that I resent that, of course, I like what I do for a job. It’s just that, being at a computer with a small human who demands constant entertainment is a non-starter.

Four weeks. One app. This is how it went.

Week One: Google is the best and the worst at AI

I already had access to some AI tooling when the competition timeframe began. At the start, my Google AI Pro subscription had an online app called Jules. In the beginning, Jules seemed like the best option, as I would prompt it to do things, and it would slowly chip away at the issue, and then open a pull request on GitHub, which I would merge.

This cycle was okay, but it was let down by the fact that Google’s AI models probably wouldn’t know whether to run away from or towards a fire. Google released Google Gemini 3.1 Pro, but again, the quality of the models and their ability to concoct a working solution, well, it couldn’t. I wasted a day or so on this.

In Gemini’s defense, the prompts were quite complex. Something like, create a Flutter app and a .NET API app. I want the Flutter app to connect to the API and use Firebase to authenticate. Users will get a JWT key from Firebase which will be used as authentication for this app.

There are quite a few steps in that: make the .NET app, make the Flutter app, wire it all up, etc. But Gemini would also choke on other simpler requests. I’d achieved similar results with Junie by JetBrains only a few months prior; I thought it was too complex of a query.

Fortunately, having a Google AI subscription meant I had access to other models, like Claude 4.5 Opus. But there was another problem. For some reason, while Google has definitive access to the most data on the web for scraping due to their search engines, and some of the best software engineers in the world working for them, they appear physically incapable of producing an IDE that interacts with their own services without breaking.

The problem is best summarized by this post on Reddit:

Sometimes you would start a conversation in Antigravity and hit the “terminated due to error” error. Other times, it would happen halfway through the agent’s response. Most annoyingly, the agent would sometimes proceed through a long-winded query and do a good job, only to crash out with the “agent terminated due to error” message. And the only way to get it to proceed was to click the “continue” button. Half-completed queries still used (and wasted) my token allotment, which was annoying.

To give you an example of just how mediocre a design this is: Antigravity is a VS Code fork, which is itself based on Chrome. This means you can open the Developer Tools side-menu. I used AI to write JavaScript that looked for a “continue” button, and if it existed, it clicked it. This opened up productivity, as I wouldn’t be away from my PC only to have it choke mid-query, to then wait for me to show up and hit continue.

Other people’s experiences are subjective, but the only good things about what Google had to offer were that the Gemini 3 Flash model was kind of okay at giving design advice, that they hosted Opus 4.5, and the free tier was far, far, far too generous. Everything else that Google offered (like Antigravity or their own models) was almost unusably bad.

To draw out special condemnation in this regard, Antigravity felt like it was built reluctantly and under constant pressure. Like what you would turn in for a high-school project if you didn’t really understand the source material but knew it was responsible for 90% of your grade.

So I kind of struggled along with using Opus 4.5 through Antigravity with the “continue” button wired up to be pressed when it appeared. The only issue with this was that Antigravity was still bad, and I spent a lot of my time outside of the house chasing my toddler around. If this was going to work, I had to be able to do this, no matter where I was.

Week 2: OpenCode on the road

OpenCode exists as a neat way to interact with various LLM’s from the terminal, providing something that resembles what you get with Claude Code, but from any LLM.

What really supercharged this, however, was the extensions for OpenCode. oh my opencode would take my prompts, process them via an “Orchestrator”, and then give other tasks to other agents across certain boundaries. A dedicated documentation agent would write documentation, and a dedicated designer agent would come up with designs. This had two benefits: the best agent for the job would take on my task, and those agents would complete their work in parallel before returning their results to the master orchestrator agent.

The biggest benefit this had was that if I asked Opus 4.5 to design an app, it would make the UI as a part of that design, but it would look pretty boring. Having OMO (oh my opencode) delegate the task out to an agent exclusively for design, before folding that back into the app itself, led to some pretty good UI designs. Check it out for yourself:

Critically, I wouldn’t have to hack Antigravity to make it work, as OpenCode worked entirely from the terminal. I would just access my virtual machine over SSH and tell it what I wanted. My spelling was atrocious when doing this, as I was trying to type it in on a phone keyboard. But impressively, the various LLM’s at play understood what I wanted each time:

But, it wasn’t all sunshine and roses.

Going down the wrong rabbit hole

I would have an idea for a new feature that I would like to implement, and so I would prompt OpenCode to implement it. It would chip away at the feature, before coming up with something, and then having those changes implemented into the app I was building.

Most of the time, I would pull in the new build to see how it looked and see that my new feature was implemented. Then I could guide Opus as to what I wanted next. However, sometimes I would check to see how a new feature looked and… there would be nothing. Opus would tell me it had implemented something, only for me to check and see that nothing had been done. I’d then keep prompting Opus, it would keep going, before eventually I would say, “This isn’t implemented, I can’t see it on the xyz screen”, and then the new feature would be visible.

What I realized after was that Opus had tried to implement my feature where it thought I wanted it, because I wasn’t precise enough. When I was actually using my app at a later date in more detail, some screens had a surprising amount of depth in the wrong places. For example, when trying to tune the batch cooking feature, somehow I gave Opus the idea that I wanted the batch cooking functionality on the recipe page itself:

This doesn’t make sense because the point of the app is to create a lot of base recipes and then spin off those base recipes into multiple other final recipes.

Week 3 – Hallucinations a’plenty

Because my attention had been split between trying to tell Claude what app to make and trying to convince my toddler that, unfortunately, patting the polar bear at SeaWorld was not going to happen, some of my prompts were a little shaky. I got very focused on what I wanted to do, not how I wanted to do it.

As a senior software developer, I more-or-less know the right way to achieve a given objective, or at least, the least gross way to do something. Assigning this responsibility to an LLM carte blanche essentially makes it attempt a calculated guess at how something should be implemented. This led to some pretty wild results.

In one case, my project was built, and then the bin directory was accidentally checked in. This introduced a weird bug where, for some reason, the build started failing because it thought it couldn’t find a certain file. The solution was simple: the bin directory just needed to be excluded from the commit. But Claude/Gemini didn’t know that, so it kept ruminating on the problem, adding regex exclusions, adding in and removing things, and just generally tinkering to try to solve the issue.

Because these models can’t just say “I don’t know how to solve that,” they just continue down the most probabilistic pathway to solve the issue. In the end, I had to Google the issue and manually exclude the directory. This is a good example of why replacing your entire test suite with AI agents requires careful oversight — the same blind spots that cause hallucinations in feature development can be just as costly during testing.

At the same time, some surprisingly complex queries were processed, and the right decisions were made. For example, I wanted to know what recipes I could make from a list of ingredients, but also to include a list of ingredients the user already had from their pantry staples. These kinds of difficult queries were produced more or less accurately.

Finally, in this week I also got OpenCode to produce some integration tests, and run them on the virtual machine. It was able to configure a lightweight X Server with XFCE, launch the app with an appropriate PPI (pixels-per-inch), and then tap through the various options and buttons to check that most of it still worked.

All in all, I was pleasantly surprised by how complicated queries and non-intuitive requests were handled.

Week 4: Burning tokens and time

At this stage, I had a mostly working app that just needed some fine-tuning. But also at about this point, integration between OpenCode and Antigravity stopped working. Worse still, Google heavily neutered the allowance of Opus 4.5 to users, so rate-limiting was happening very quickly.

Because I was so close to having something working, I decided to give Kilo.ai a shot. They would double whatever money I added to it at the time, so I gave $20 and wound up with $40 of credit.

Within the Kilo.ai tool, which is actually based on OpenCode, I got down to fixing the last few issues. However, the CLI tool actually tells you how much money your prompt is costing in real-time.

It is a totally different feeling when you are using something like Antigravity and working through a provided bucket of tokens, as opposed to watching your bucket of money get expended, ten cents at a time. Opus would sometimes go on a bit of a wild goose chase trying to fix something, which would cause it to infer quite a lot, which would mean some simple-ish queries could cost $3-$4 to complete. If you’re looking to avoid this kind of runaway spending, there are practical ways to cut token usage that can save you real money.

Two days before the deadline, I submitted the app and got it all working on the Play Store, and it joined all the other seven thousand submissions.

I won zero dollars. But look on the bright side, I don’t have to pay tax on that!

4 lessons I learned about AI development

Would I rather have won 20,000 American dollars? I can say with some confidence that, yes, I would have liked that. But even without that, it was a cool experience in using the wide variety of AI tools that were available to bring together a new app in such a short amount of time. Here were the key takeaways:

• Opus 4.5/4.6 is dominating for app development, especially when combined with oh my opencode. Other models like Gemini 3.1 Pro Low, High, or Flash would frequently write code that didn’t work or didn’t compile, or was too verbose. Even writing the code originally with Opus and then getting Gemini to fix it would frequently break working code, and then make it even worse as it was trying to fix it. For a side-by-side look at how these tools stack up, the AI dev tool power rankings are worth checking out.
• Don’t fear the CLI. 30 years ago, we were all staring at the terminal to use our computers. Now we’re staring at it to use AI. But the use of CLI tools like OpenCode allows incredible flexibility in where you use it, and when embedded in a CI/CD workflow, changes can be pushed somewhere where you can test them quite quickly. It’s just not the same with a desktop app.
• Using AI without a plan, and just paying for tokens directly like on kilo.ai shows how extremely expensive AI can be. Even for comparatively simple things, using frontier models like Opus 4.5/4.6 without a subscription to Claude Code can wind up costing tens of dollars quite quickly. Even with all of the bonuses like a 2x increase on the money I was sending in, this showed me how truly expensive AI can be, and how heavily these LLM’s are being subsidized by the companies offering them at the moment to breed widespread adoption.
• Web-based tools for this, like Codex web or Jules, are vastly inferior to something like OpenCode on a VM. If you have the ability to run OpenCode on a local virtual machine, this will outstrip any of these web-based tools. Also, for some reason, when I used Jules or Codex web, both had memory leaks and used up a huge amount of RAM and would frequently crash or become unresponsive on my phone.

If you’re making an app for work or something serious, obviously, don’t try to vibe code it on OpenCode in one hand while keeping your toddler from throwing rocks at cars with the other hand. But for a hackathon, or something that you and your friends might use, it’s probably worth a shot.

Most of the product and engineering teams I talk to are building and deploying AI agents, but these agents are blind to how customers are actually experiencing your product.

This is why I’m excited to announce that the LogRocket MCP is now available to everyone.

Let’s suppose your conversion rate dropped last week. You ask Claude or Cursor what went wrong, but find nothing obviously amiss.

When you enable the LogRocket MCP, you and your agents can watch thousands of session replays in minutes.

So now if conversion rate dips, the LogRocket MCP identifies the problem immediately: on mobile Chrome, autofill triggers a spinner that never resolves. This context, and a suggested fix, is delivered wherever you need it: Claude, Cursor, or right to your agent.

Let’s dive into how the MCP is changing the way our customers monitor their products.


What is the LogRocket MCP?

The LogRocket MCP connects your agents directly to LogRocket’s Galileo AI, which is already watching session replays, listening to customer calls, reading support tickets, and tracking product changes.

Galileo detects issues, diagnoses root causes, quantifies user impact, and suggests fixes. Via the MCP, it sends this context to your agent, without anyone on your team needing to pull up LogRocket:

How are product and engineering teams using the LogRocket MCP?

Rippling, the HR, payroll, and IT software provider, is using the MCP to identify customer issues in near-realtime.

Matt MacInnis, Rippling’s President and Chief Product Officer, posted about it on X:

Nick Ciubotariu, CTO at ShipStation Global, the shopping and logistics provider behind products like ShipStation and Stamps.com, shared how his team is connecting its coding agents to the MCP to generate PRs to fix user issues.

“We’re using the LogRocket MCP to feed real user session data directly to our AI agents,” Nick said. “When an issue surfaces, the agent doesn’t wait for us to investigate; it pulls the sessions, diagnoses the root cause, and opens a pull request automatically. That’s an amazing advantage, and it’s a great accelerator for our engineering teams and a huge benefit to our customers.”

The pattern we’re seeing across early customers: their agents flag issues faster, which means they ship fixes faster.

What can you use the LogRocket MCP for?

Three examples of agents real LogRocket customers are building:

• An issue resolution agent that watches user sessions, surfaces usability and technical problems, and routes those issues to their coding agents to fix automatically.
• A product research agent that connects to the code base, identifies new features being shipped, and shows how customers are using and responding to them.
• A customer support agent that, when a customer has a problem, can see exactly what they experienced and help accordingly.

And that’s just a sampling. What agents will your team build?

Why this matters

When we founded LogRocket in 2016, the goal was to give teams a complete understanding of how users experience their product, without consuming all of their time.

Ask Galileo took us a big step forward. Teams could answer almost any question about their product experience in seconds.

The MCP takes it another step.

Galileo’s intelligence stops being something your team has to go look at. Now it helps you surface issues, resolve tickets, and propose fixes on its own.

The blindfold is off. We’re one step closer to software that fixes itself.

How to get started with the LogRocket MCP

The LogRocket MCP Server is available now.

Existing LogRocket customers can connect via the hosted server at mcp.logrocket.com/mcp: no local setup required, OAuth authentication, works with Cursor, Claude Desktop, Claude Code, Codex, and any MCP-compatible client.

If you’re new to LogRocket, you can learn more by checking out our docs or trying it for yourself at logrocket.com.

When you introduce a new feature, you probably notice that your product numbers spike almost immediately. Your signups double, traffic surges, and dashboards start glowing with positive indicators. For a moment, everything points to success.

But after a few weeks, your customers’ enthusiasm fades. Daily active users stagnate. You notice that retention decreases faster than expected.

On top of all that, the majority of new users don’t return after their first engagement. What appeared to be growth is actually something completely different. I’m sure you’ve seen this problem before.

Teams usually link acquisition with progress, assuming that more users equals a stronger product. However, growth by itself is an imperfect indicator. It shows you how many people showed up, not whether they found value or chose to keep using the product.

Understanding where this misconception comes from, and how to remedy it, is critical for anyone looking to create something that’ll last. Keep reading to learn why you should stop paying so much attention to acquisition spikes and what you should be measuring instead.

How teams misread growth metrics

Most product teams rely mainly on acquisition metrics to determine success. These might include signups, app installs, traffic, and campaign conversion rates. They’re simple to assess, explain, and are often linked to growth targets.

At their core, acquisition metrics measure interest rather than outcomes. A signup only indicates that the user was inquisitive enough to try the product. That curiosity could stem from a variety of sources, including marketing initiatives, social chatter, incentives, or even accidental clicks. It may not necessarily indicate a genuine need for the product.

This creates a subtle yet dangerous illusion. When acquisition numbers increase, teams believe that the product is better. In reality, they may just be getting better at catching attention.

A more accurate approach to think about this is to separate intent from value:

• Acquisition demonstrates intent — Users showing up
• Retention demonstrates value — Users choosing to stay

If retention doesn’t follow acquisition, then growth fails to result in meaningful progress. Without this distinction, teams risk praising indicators with little impact on long-term success.

What “low-quality growth” actually looks like

Not all growth is equally beneficial to a product’s success. Some users become long-term, engaged customers. Others leave almost as soon as they arrive.

---

---

The distinction is in the quality of growth. Low-quality growth can appear powerful on the surface but show flaws when user behavior is examined more thoroughly.

One common trend is high acquisition followed by low activation. Users sign up in significant numbers but don’t perform the crucial actions that establish the product’s value. This usually indicates that either the onboarding process is unclear or that the product doesn’t quickly express why it’s important.

Another pattern is high initial usage followed by a sharp drop-off. Users participate during their first session, usually motivated by curiosity or outside factors, but never return. This indicates that the product failed to provide a compelling reason for continued use.

In certain cases, growth is driven solely by incentives. Referral programs, discounts, and prizes can attract a large number of users, but they’re often driven by the incentive rather than the product itself. When the reward is gone, their engagement fades.

There’s also the issue of shallow engagement. Users may briefly interact with the product by clicking through features or exploring the interface but never use its main functionality. This type of action can exaggerate engagement metrics while obscuring true value.

Vanity metrics vs. product signals

To make sense of growth, you must differentiate between vanity metrics and product signals.

Vanity metrics are data that appear spectacular but provide no insight into whether the product is actually working. This category includes total sign-ups, page views, and number of downloads. These metrics assess visibility and reach, but they don’t disclose whether users find value.

Product signals, on the other hand, are metrics that capture actual user outcomes. They demonstrate if users are engaging actively with the product and whether that engagement is sustained over time.

Activation rate is one of the most important product signals. It calculates the percentage of users who execute a critical activity that reflects the product’s value. If users aren’t activating, that means acquisition isn’t resulting in substantial usage.

Retention is even more important. It tracks whether users return after their first contact. Strong retention suggests that the product is addressing an actual problem. Weak retention indicates that users either didn’t find value or found inadequate value to return.

The key difference between these two categories is simple: Vanity metrics tell you how many people you reached, whereas product signals tell you how many people you actually helped.

Diagnosing the problem: Where growth breaks down

When growth doesn’t translate into retention, the problem is typically with the product experience rather than the acquisition strategy.

One of the most common issues is a slow or delayed “aha moment.” This is the point where users realize the value of the product. If this moment is difficult to achieve or poorly articulated, users are unlikely to stay long enough to experience it.

Incentives may also affect growth. While they can be helpful for short-term acquisition, they usually attract users who are more concerned with the reward than the product itself. This leads to a gap between user behavior and product value.

Finally, effective onboarding is critical. Even if users are a good fit, a complex or stressful onboarding process can keep them from using the product effectively. Retention issues are often disguised as onboarding issues.

What PMs should measure instead

To move beyond misleading growth metrics, you need to prioritize indicators that represent actual user behavior. Here’s the five things I recommend keeping an eye on:

1. Activation rate

This is the basis for product success. If users don’t activate, nothing else matters.

To improve activation:

• Identify the key action that represents value
• Remove friction from the onboarding process
• Guide users toward that action

2. Time to value (TTV)

The faster users experience value, the more likely they are to stay.

Reducing TTV involves:

• Simplifying onboarding
• Highlighting key features
• Removing unnecessary steps

3. Retention curves

Retention curves explain how user engagement varies over time.

A strong product usually has:

• A steady decline followed by stabilization

A weak product usually shows:

• A sharp drop-off without any recovery

4. Cohort analysis

Cohort analysis groups users depending on when or how they joined.

This helps answer:

• What acquisition channels generate the most users?
• Do specific features increase retention?

5. Depth of engagement

Instead of just measuring activity, measure meaningful activity:

• Are users taking advantage of core features?
• Are they finishing important tasks?

A shift from acquisition to retention

Shifting from acquisition-focused to retention-focused thinking necessitates a fundamental shift in how product teams work.

---

---

The first stage is to validate the product before scaling growth. If users aren’t activating or retaining, increasing acquisition will only worsen the problem. Growth should occur after, not before, product validation.

Next, growth strategies should be consistent with the product’s primary value. The goal isn’t simply to attract users, but to attract the appropriate users — the ones who’ll gain the most from the product.

The initial user experience should also be properly optimized. Retention can often be determined within the first session, so clarity, simplicity, and immediate value are essential.

Finally, every growth initiative should be assessed based on what happens after signup. It’s not enough to count how many users were acquired. Teams must understand how those users interact, whether they activate or return.

Final thoughts

Growth isn’t necessarily misleading, but it’s often misinterpreted. Acquisition metrics are useful, but they’re just the start of the story.

What happens after the users come determines true product success. You need your users to discover value, return, and make the product part of their habit.

This means shifting the focus of your work from attracting users to retaining them. As a parting piece of advice, remember that long-term growth is based on consistent, compounded value.

Do you have a story of a time you misread an acquisition spike? Let us know in the comments below.

Featured image source: IconScout

Testing a Nuxt application is not the same as testing plain Vue components. Vue is a frontend framework for building reactive UI components; Nuxt is a full-stack framework built on top of Vue that adds server-side rendering, file-based routing, auto-imports, layouts, middleware, Nitro server routes, and deployment conventions.

That extra framework layer is exactly why Nuxt testing needs its own strategy. A standard Vue unit test can verify a component’s props and rendered output, but it will not automatically reproduce Nuxt behavior like useFetch, NuxtLink, route middleware, or auto-imported composables. For that, you need the right combination of Vitest environments and Nuxt-specific testing utilities.

In this guide, we’ll test a Nuxt application across three tiers:

• Unit tests for isolated Vue components, composables, and pure logic
• Nuxt runtime tests for components and pages that depend on Nuxt context
• End-to-end tests for full app behavior in a real server or browser flow

We’ll use @nuxt/test-utils, @vue/test-utils, @testing-library/vue, Vitest, and Playwright-powered browser utilities. If you are new to mocks, spies, and Vitest’s core APIs, my previous LogRocket guide on advanced Vitest testing and mocking covers those fundamentals in more depth.

Why Nuxt testing needs its own guide

Plain Vue testing libraries like @vue/test-utils and @testing-library/vue work well when you are testing ordinary Vue components. They fall short when the component depends on Nuxt-specific behavior.

Here are a few common examples:

• Auto-imports: Nuxt makes components and composables globally available, but a standard Vitest setup will not resolve them without Nuxt context
• useFetch and useAsyncData: These composables are tied to Nuxt’s data-fetching lifecycle and SSR context
• useRoute, navigateTo, and route middleware: Routing behavior is difficult to reproduce accurately outside a Nuxt runtime
• Layouts: Testing a page component in isolation skips the layout wrapper and can miss integration bugs
• Nitro API routes: Server endpoints need a different testing strategy than client-side Vue components

The following diagram shows how Vitest concepts, Vue testing utilities, and Nuxt-specific testing APIs fit together:

The practical takeaway is simple: use the lightest test environment that still reproduces the behavior you need. Pure Vue behavior can stay in a fast unit test. Nuxt behavior usually needs the nuxt Vitest environment. Full user journeys need e2e coverage.

Companion project and testing environments

This article comes with a companion GitHub project that you can follow along with. It is a Nuxt 4 implementation of the popular TodoMVC app, and its tests live in the test folder.

Although the examples use Nuxt 4, most of the testing ideas also apply to current Nuxt 3 projects that use @nuxt/test-utils. Before copying code into an existing app, check your installed Nuxt and @nuxt/test-utils versions against the official docs because imports and setup details can change between major versions.

The companion project uses three testing tiers. Each tier has a different balance of speed, setup complexity, and confidence:

Test tier	Vitest environment	Main tools	Best for	Tradeoff
Unit	happy-dom, jsdom, or node	Vitest, @testing-library/vue, @vue/test-utils	Pure functions, simple components, isolated composables, isolated store logic	Fastest, but may miss Nuxt integration bugs
Nuxt runtime / integration	nuxt	@nuxt/test-utils/runtime, mountSuspended, renderSuspended, registerEndpoint, mockNuxtImport	Components or pages that depend on Nuxt routing, auto-imports, modules, useFetch, or middleware	More realistic, but more setup
E2E	node with @nuxt/test-utils/e2e	setup, $fetch, fetch, createPage, Playwright	Full flows involving SSR, routing, API handlers, hydration, and browser interaction	Highest confidence, but slowest and most brittle

You usually need all three kinds of tests. The goal is not to optimize for one tier, but to choose the lowest tier that gives you enough confidence.

Vitest environments for Nuxt testing

Every test runs in a specific Vitest environment. In a Nuxt app, the environment determines how much of the Nuxt runtime is available:

• happy-dom or jsdom: Lightweight browser-like environments for unit tests. There is no Nuxt runtime, so you must stub Nuxt-specific APIs like NuxtLink, useRouter, or auto-imported composables yourself.
• nuxt: Boots a Nuxt runtime inside Vitest. Auto-imports work, Nuxt modules initialize, and @nuxt/test-utils/runtime APIs like registerEndpoint become available. This is useful for integration-style tests that need Nuxt context but not a real browser.
• node with @nuxt/test-utils/e2e: Starts a real Nuxt server for e2e tests. You can call real server API routes, fetch SSR-rendered HTML, or create a Playwright page for browser interaction.

One important constraint: @nuxt/test-utils/runtime and @nuxt/test-utils/e2e run in different environments, so keep runtime tests and e2e tests in separate files.

Setting up Vitest in a Nuxt project

According to Nuxt’s testing documentation, @nuxt/test-utils ships with optional peer dependencies so you can choose the DOM environment and e2e runner that fit your project. For the examples in this article, install the following packages:

npm i --save-dev @nuxt/test-utils vitest @vue/test-utils @testing-library/vue happy-dom playwright-core

Nuxt’s official setup command includes @nuxt/test-utils, vitest, @vue/test-utils, happy-dom, and playwright-core. We also install @testing-library/vue because several examples below use Testing Library’s render and screen APIs.

Use playwright-core when you want Nuxt test-utils to drive Playwright through its own e2e utilities. If your project uses Playwright’s standalone test runner instead, Nuxt also supports @playwright/test, but that is a separate setup path.

Next, create a Vitest config. The following example organizes tests into unit, nuxt, and e2e projects:

// vitest.config.mts
import vue from '@vitejs/plugin-vue'
import { defineVitestProject } from '@nuxt/test-utils/config'
import { defineConfig } from 'vitest/config'

export default defineConfig({
  test: {
    projects: [
      {
        plugins: [vue()],
        test: {
          name: 'unit',
          include: ['test/unit/**/*.test.ts'],
          environment: 'happy-dom',
        },
      },
      {
        test: {
          name: 'e2e',
          include: ['test/e2e/**/*.test.ts'],
          environment: 'node',
        },
      },
      await defineVitestProject({
        test: {
          name: 'nuxt',
          include: ['app/**/*.test.ts', 'test/nuxt/**/*.test.ts'],
          environment: 'nuxt',
        },
      }),
    ],
  },
})

This is not the only valid structure. You can also colocate test files next to the components they test and route them into the correct Vitest project through file globs. What matters is that tests using Nuxt runtime utilities run in the nuxt environment, while e2e tests using @nuxt/test-utils/e2e run in node.

Tier 1: Unit tests in happy-dom

Most projects should have many unit tests because they are fast, isolated, and easy to run on every code change. Use them for logic that does not require Nuxt context:

• Pure utility functions
• Simple presentational components
• Pure composables
• Store logic that can be tested without Nuxt plugins

In the companion project, unit tests live in test/unit/ and run in the happy-dom environment. The following Headline.test.ts file renders a simple Vue component without any Nuxt runtime:

import { render, screen } from '@testing-library/vue'
import Headline from '../../app/components/Headline.vue'

describe('Headline', () => {
  it('renders the provided text', () => {
    render(Headline, {
      props: { text: 'todos' },
    })

    expect(screen.getByText('todos')).toBeDefined()
  })
})

This test does not need the nuxt environment because it only verifies that a Vue component renders a prop. There is no NuxtLink, useFetch, auto-imported Nuxt composable, route middleware, or plugin dependency involved.

For more unit testing examples, see my previous guide to Vitest testing and mocking.

Tier 2: Nuxt runtime tests in the nuxt environment

Use the nuxt Vitest environment when the component or page depends on Nuxt-specific behavior. This gives your test access to a Nuxt runtime, including auto-imports, Nuxt modules, routing, and runtime test utilities.

Use mountSuspended for components that need Nuxt context

mountSuspended, provided by @nuxt/test-utils/runtime, wraps mount from @vue/test-utils and mounts a component inside the Nuxt environment. Use it when a component depends on async setup, Nuxt plugins, Nuxt injections, or routing behavior.

The following TodoItem.test.ts example verifies that a todo item renders a NuxtLink to the correct detail route:

import { mountSuspended } from '@nuxt/test-utils/runtime'
import TodoItem from '~/components/TodoItem.vue'

const mockTodo = {
  id: 42,
  label: 'Buy groceries',
  date: '2026-02-13',
  checked: false,
}

describe('TodoItem', () => {
  it('renders a NuxtLink pointing to /todos/:id', async () => {
    const wrapper = await mountSuspended(TodoItem, {
      props: { todo: mockTodo },
    })

    const link = wrapper.findComponent({ name: 'NuxtLink' })
    expect(link.exists()).toBe(true)
    expect(link.props('to')).toBe('/todos/42')
  })
})

You could test this with plain mount, but you would need to wire up the router manually:

it('using mount() requires much more manual setup', () => {
  const router = createRouter({
    history: createMemoryHistory(),
    routes: [
      { path: '/todos/:id', component: { template: '<div />' } },
      { path: '/:pathMatch(.*)*', component: { template: '<div />' } },
    ],
  })

  const wrapper = mount(TodoItem, {
    props: { todo: mockTodo },
    global: { plugins: [router] },
  })

  const link = wrapper.findComponent({ name: 'NuxtLink' })
  expect(link.exists()).toBe(true)
  expect(link.props('to')).toBe('/todos/42')
  expect(link.attributes('href')).toBe('/todos/42')
})

The second test is not wrong, but it obscures the intent. The test is about the component’s route output, not about manually creating a router. mountSuspended keeps the setup closer to how the component actually runs in Nuxt.

Mock Nuxt server routes with registerEndpoint

Nuxt’s data-fetching APIs require a different mocking strategy than ordinary browser fetch calls.

The root page in the demo app fetches todos with useFetch:

const { data } = await useFetch<Todo[]>('/api/todos')

In Nuxt, useFetch and $fetch do not always call the global browser fetch API directly. During SSR, Nuxt can resolve routes like /api/todos through Nitro server handlers, bypassing HTTP. That means mocking global fetch may not affect a useFetch call.

Use registerEndpoint to mock Nuxt server API routes inside the Nuxt runtime:

import { registerEndpoint, renderSuspended } from '@nuxt/test-utils/runtime'
import { screen } from '@testing-library/vue'
import IndexPage from '~/pages/index.vue'

const mockTodos = [
  { id: 1, label: 'Buy groceries', date: '2026-02-11', checked: false },
  { id: 2, label: 'Walk the dog', date: '2026-02-10', checked: true },
  { id: 3, label: 'Write tests', date: '2026-02-09', checked: false },
]

registerEndpoint('/api/todos', () => mockTodos)

describe('Index Page', () => {
  it('renders todos from the mocked /api/todos endpoint', async () => {
    await renderSuspended(IndexPage)

    expect(screen.getByText('Buy groceries')).toBeDefined()
    expect(screen.getByText('Walk the dog')).toBeDefined()
    expect(screen.getByText('Write tests')).toBeDefined()
  })
})

registerEndpoint is an API function, not a macro. The first argument is the route, and the second argument returns the response that the Nuxt data-fetching call should receive.

Because this example uses @testing-library/vue, it uses renderSuspended, which plays the same role as mountSuspended but follows Testing Library’s rendering model.

Stub Nuxt components with mockComponent

Sometimes you want to test a component that renders another nontrivial child component. In the demo app, TodoList renders multiple TodoItem components. To focus the test on the list behavior, we can replace TodoItem with a small stub.

@nuxt/test-utils provides mockComponent for this:

// TodoList.test.ts
import { mockComponent, renderSuspended } from '@nuxt/test-utils/runtime'
import { screen } from '@testing-library/vue'
import { defineComponent, h } from 'vue'
import TodoList from '~/components/TodoList.vue'
import { useTodosStore } from '~/stores/todos'

const mockTodos = [
  { id: 1, label: 'Buy groceries', date: '2026-02-11', checked: false },
  { id: 2, label: 'Walk the dog', date: '2026-02-10', checked: true },
  { id: 3, label: 'Write tests', date: '2026-02-09', checked: false },
]

mockComponent('~/components/TodoItem.vue', () =>
  defineComponent({
    props: { todo: Object },
    setup(props) {
      return () =>
        h('div', {
          'data-testid': 'todo-item-stub',
          'todo-label': props.todo?.label,
        })
    },
  })
)

describe('TodoList', () => {
  it('renders one stub per todo seeded into the store', async () => {
    const store = useTodosStore()
    store.setTodos(mockTodos)

    await renderSuspended(TodoList)

    const stubs = screen.getAllByTestId('todo-item-stub')
    expect(stubs).toMatchSnapshot()
  })
})

The TodoList component reads from the Pinia store, so the test seeds the store before rendering the component.

The render-function version above is explicit, but it can be hard to read. Because the Nuxt test environment includes Vue’s runtime template compiler, you can write the stub more simply with a template:

mockComponent('~/components/TodoItem.vue', {
  props: ['todo'],
  template: '<div data-testid="todo-item-stub" :todo-label="todo?.label" />',
})

One caveat: mockComponent is a macro that is hoisted to the top of the file. In practice, that means it is best for file-level stubs. If you need a different stub per test, use a global stub through @vue/test-utils instead:

// TodoList.globalstub.test.ts
test('renders one stub per todo seeded into the store', async () => {
  const store = useTodosStore()
  store.setTodos(mockTodos)

  await renderSuspended(TodoList, {
    global: {
      stubs: {
        TodoItem: {
          props: ['todo'],
          template: '<div data-testid="todo-item-stub" :todo-label="todo?.label" />',
        },
      },
    },
  })

  const stubs = screen.getAllByTestId('todo-item-stub')
  expect(stubs).toMatchSnapshot()
})

A good rule of thumb: use mockComponent when one file-level stub is enough, and use global stubs when each test needs more flexibility.

Mock auto-imports with mockNuxtImport

Nuxt auto-imports composables like useRuntimeConfig, useState, and useHead. When you need to replace one of those imports in a test, use mockNuxtImport.

For example, the default layout reads the app title from runtime config:

// layouts/default.vue
const { appTitle } = useRuntimeConfig().public

To test this layout, mock useRuntimeConfig and return a custom value:

// DefaultLayout.test.ts
import { mockNuxtImport, renderSuspended } from '@nuxt/test-utils/runtime'
import { screen } from '@testing-library/vue'
import DefaultLayout from '~/layouts/default.vue'

mockNuxtImport('useRuntimeConfig', () => {
  return () => ({
    app: { baseURL: '/' },
    public: {
      appTitle: 'My Custom Title',
    },
  })
})

describe('Default Layout', () => {
  test('renders the appTitle from useRuntimeConfig in the headline', async () => {
    await renderSuspended(DefaultLayout)

    expect(screen.getByText('My Custom Title')).toBeDefined()
  })
})

mockNuxtImport can only be used once per imported symbol per test file because it is transformed into a hoisted vi.mock. When you need to reuse the same mock with different values, pair it with vi.hoisted.

Consider this useDarkMode composable, which relies on Nuxt’s auto-imported useState:

// app/composables/useDarkMode.ts
import themeConfig from '@/utils/theme'

export const useDarkMode = () => {
  const isDark = useState('darkMode', () => true)
  const theme = computed(() =>
    isDark.value ? themeConfig.DARK : themeConfig.LIGHT,
  )

  function toggleDarkMode() {
    isDark.value = !isDark.value
  }

  return { isDark, theme, toggleDarkMode }
}

In the test, create one hoisted mock function and set its return value inside each test:

// useDarkMode.test.ts
import { mockNuxtImport } from '@nuxt/test-utils/runtime'
import { ref } from 'vue'
import themeConfig from '~/utils/theme'
import { useDarkMode } from '~/composables/useDarkMode'

const { useStateMock } = vi.hoisted(() => ({ useStateMock: vi.fn() }))

mockNuxtImport('useState', () => useStateMock)

describe('useDarkMode', () => {
  test('starts in dark mode and toggles to light', () => {
    useStateMock.mockReturnValue(ref(true))

    const { isDark, theme, toggleDarkMode } = useDarkMode()

    expect(isDark.value).toBe(true)
    expect(theme.value).toEqual(themeConfig.DARK)

    toggleDarkMode()

    expect(isDark.value).toBe(false)
    expect(theme.value).toEqual(themeConfig.LIGHT)
  })

  test('starts in light mode and toggles to dark', () => {
    useStateMock.mockReturnValue(ref(false))

    const { isDark, theme, toggleDarkMode } = useDarkMode()

    expect(isDark.value).toBe(false)
    expect(theme.value).toEqual(themeConfig.LIGHT)

    toggleDarkMode()

    expect(isDark.value).toBe(true)
    expect(theme.value).toEqual(themeConfig.DARK)
  })
})

The important pattern is this pair:

const { useStateMock } = vi.hoisted(() => ({ useStateMock: vi.fn() }))

mockNuxtImport('useState', () => useStateMock)

That gives you one hoisted mock that each test can configure independently.

Test dynamic routes and Nuxt middleware

Dynamic routes are a common source of integration bugs in Nuxt because they combine several framework features: route params, middleware, server fetching, error handling, and head management.

The demo project has a todo detail page at pages/todos/[id].vue:

// pages/todos/[id].vue
import type { Todo } from '@/stores/todos'

definePageMeta({
  middleware: ['validate-todo-id'] as const,
})

const route = useRoute()
const todoId = Number(route.params.id)

const { data: todo, error: fetchError } = await useFetch<Todo>(`/api/todos/${todoId}`)

if (fetchError.value) {
  throw fetchError.value
}

useHead({
  title: `Todo: ${todo.value?.label}`,
})

This page uses multiple Nuxt features:

• definePageMeta to attach route middleware
• useRoute to read the dynamic id parameter
• useFetch to load a todo from a Nitro server route
• useHead to set the page title
• Nuxt error handling for invalid or missing todos

Start with the happy path. The test registers a mock server endpoint, renders the page at /todos/42, and verifies both the visible content and useHead call:

// DetailPageHappyPath.test.ts
import { mockNuxtImport, registerEndpoint, renderSuspended } from '@nuxt/test-utils/runtime'
import { screen } from '@testing-library/vue'
import { describe, expect, test, vi } from 'vitest'
import type { Todo } from '~/stores/todos'
import DetailPage from '~/pages/todos/[id].vue'

const mockTodo: Todo = {
  id: 42,
  label: 'Buy groceries',
  date: '2026-03-26',
  checked: false,
}

registerEndpoint('/api/todos/42', () => mockTodo)

const { useHeadMock } = vi.hoisted(() => ({ useHeadMock: vi.fn() }))

mockNuxtImport('useHead', () => useHeadMock)

describe('Detail Page - happy path', () => {
  test('renders the todo title and date and sets the title correctly', async () => {
    await renderSuspended(DetailPage, { route: '/todos/42' })

    expect(screen.getByText('Buy groceries')).toBeDefined()
    expect(screen.getByText(/2026-03-26/)).toBeDefined()
    expect(useHeadMock).toHaveBeenCalledWith({ title: 'Todo: Buy groceries' })
  })
})

For good coverage, also test the error paths. If the route contains a valid integer but the server route has no matching todo, the page should throw a 404:

// DetailPageErrorCase.test.ts
import { registerEndpoint, renderSuspended } from '@nuxt/test-utils/runtime'
import { screen } from '@testing-library/vue'
import type { NuxtError } from '#app'
import DetailPage from '~/pages/todos/[id].vue'
import ErrorPage from '~/error.vue'

registerEndpoint('/api/todos/999', () => {
  throw createError({
    statusCode: 404,
    statusMessage: 'Todo with id 999 not found',
  })
})

test('throws a 404 when the todo does not exist', async () => {
  await expect(
    renderSuspended(DetailPage, {
      route: '/todos/999',
    }),
  ).rejects.toMatchObject({
    statusCode: 404,
    statusMessage: 'Todo with id 999 not found',
  })
})

If the route parameter is not a valid integer, the middleware should throw a 400:

test('throws a 400 when the todo id is not a valid integer', async () => {
  await expect(
    renderSuspended(DetailPage, { route: '/todos/abc' }),
  ).rejects.toMatchObject({
    statusCode: 400,
    statusMessage: 'Invalid todo id: "abc"',
  })
})

You can also test the error page itself:

test('renders status code, message, and back to home button', async () => {
  await renderSuspended(ErrorPage, {
    props: {
      error: { status: 500, message: 'Something went wrong' } as NuxtError,
    },
  })

  expect(screen.getByText('500')).toBeDefined()
  expect(screen.getByText('Something went wrong')).toBeDefined()
  expect(screen.getByText('← Back to home')).toBeDefined()
})

Test Nuxt middleware in isolation

The previous examples test middleware through a real page render. That gives you confidence that the middleware is wired into the route correctly. Sometimes, though, you only want to test the middleware logic quickly.

For that, import the middleware directly and call it with minimal fake route objects.

Here is the middleware implementation:

// app/middleware/validate-todo-id.ts
export default defineNuxtRouteMiddleware((to) => {
  const id = to.params.id as string

  if (!/^\d+$/.test(id)) {
    abortNavigation(
      createError({
        statusCode: 400,
        statusMessage: `Invalid todo id: "${id}"`,
      }),
    )
  }
})

The test mocks abortNavigation and createError, creates fake route objects, and verifies both the allowed and rejected cases:

// ValidateTodoIdMiddleware.test.ts
import { mockNuxtImport } from '@nuxt/test-utils/runtime'
import type { RouteLocationNormalized } from 'vue-router'
import validateTodoId from '~/middleware/validate-todo-id'

const { abortNavigationMock, createErrorMock } = vi.hoisted(() => {
  return {
    abortNavigationMock: vi.fn(),
    createErrorMock: vi.fn((err) => err),
  }
})

mockNuxtImport('abortNavigation', () => abortNavigationMock)
mockNuxtImport('createError', () => createErrorMock)

function fakeRoute(id: string): RouteLocationNormalized {
  return { params: { id } } as unknown as RouteLocationNormalized
}

const homeRoute = {
  name: 'index',
  path: '/',
  fullPath: '/',
} as RouteLocationNormalized

describe('validate-todo-id middleware', () => {
  beforeEach(() => {
    vi.clearAllMocks()
  })

  test('allows navigation for a valid numeric id', () => {
    validateTodoId(fakeRoute('42'), homeRoute)

    expect(abortNavigationMock).not.toHaveBeenCalled()
  })

  test('aborts navigation for a non-numeric id', () => {
    validateTodoId(fakeRoute('abc'), homeRoute)

    expect(createErrorMock).toHaveBeenCalledWith(
      expect.objectContaining({
        statusCode: 400,
        statusMessage: 'Invalid todo id: "abc"',
      }),
    )
    expect(abortNavigationMock).toHaveBeenCalled()
  })

  test('aborts navigation for an empty id', () => {
    validateTodoId(fakeRoute(''), homeRoute)

    expect(createErrorMock).toHaveBeenCalledWith(
      expect.objectContaining({
        statusCode: 400,
        statusMessage: 'Invalid todo id: ""',
      }),
    )
    expect(abortNavigationMock).toHaveBeenCalled()
  })
})

Use isolated middleware tests for fast validation of route rules. Keep at least one page-level runtime test to confirm the middleware is actually connected to the route.

Tier 3: End-to-end tests in the node environment

E2E tests exercise the full Nuxt stack. Unlike happy-dom tests, they do not assert against a fake DOM. Unlike nuxt environment tests, they can run against a real Nuxt server and, if needed, a real browser.

Use e2e tests for critical flows where SSR, routing, middleware, API handlers, hydration, and browser interaction all need to work together.

Smoke test SSR output with setup and $fetch

By the time you reach this tier, you usually leave most mocking behind. You do not use registerEndpoint or mockNuxtImport because a real Nuxt server starts before the suite runs and tears down afterward.

The simplest e2e smoke test starts the Nuxt server and fetches the SSR-rendered HTML:

// e2e/app.test.ts
import { $fetch, setup } from '@nuxt/test-utils/e2e'

describe('app', async () => {
  await setup()

  test('checks availability of input', async () => {
    const html = await $fetch('/')
    expect(html).toContain('What needs to be done?')
  })
})

When using setup, await it at the top of the describe block before any tests run. The server stays up for the duration of the suite and is torn down automatically.

Test server API routes with $fetch and fetch

@nuxt/test-utils/e2e provides two similar APIs for server requests:

API	Use it when	Return behavior
$fetch	You care about parsed HTML or JSON payloads	Uses ofetch, parses responses, and throws on non-2xx status codes
fetch	You need the raw response object or status code	Returns a response so you can assert status, headers, and body
createPage	You need real browser interaction	Creates a Playwright page connected to the running Nuxt server

For example, use $fetch when you only need the payload:

test('fetches the homepage', async () => {
  const html = await $fetch<string>('/')

  expect(html).toContain('<!DOCTYPE html>')
})

test('fetches JSON API endpoint', async () => {
  const data = await $fetch('/api/health')

  expect(data).toEqual({ status: 'ok' })
})

Use fetch when you need to assert on response status codes:

// e2e/api.test.ts
import { $fetch, fetch, setup } from '@nuxt/test-utils/e2e'
import type { FetchError } from 'ofetch'

interface Todo {
  id: number
  label: string
  date: string
  checked: boolean
}

describe('server API routes', async () => {
  await setup()

  test('POST /api/todos creates a todo and returns status 201', async () => {
    const response = await fetch('/api/todos', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ label: 'test todo' }),
    })

    const todo: Todo = await response.json()

    expect(response.status).toBe(201)
    expect(todo.label).toBe('test todo')
    expect(todo.checked).toBe(false)

    const todos = await $fetch<Todo[]>('/api/todos')
    expect(todos.length).toBe(1)
  })

  test('GET /api/todos/:id returns the todo by id', async () => {
    const created = await $fetch<Todo>('/api/todos', {
      method: 'POST',
      body: { label: 'Fetch by id' },
    })

    const todo = await $fetch<Todo>(`/api/todos/${created.id}`)

    expect(todo.id).toBe(created.id)
    expect(todo.label).toBe('Fetch by id')
  })

  test('GET /api/todos/:id returns 404 for an unknown id', async () => {
    const error = await $fetch<never>('/api/todos/0').catch((e: FetchError) => e)

    expect(error.status).toBe(404)
  })
})

Test browser flows with Playwright and createPage

For real browser interaction, use createPage from @nuxt/test-utils/e2e. This gives you a configured Playwright page connected to the Nuxt test server.

The following test creates a todo item, navigates to its detail page, and returns home:

import { createPage, fetch, setup, url } from '@nuxt/test-utils/e2e'
import { beforeEach, describe, expect, test } from 'vitest'

describe('navigation flow', async () => {
  await setup({ browser: true })

  beforeEach(async () => {
    await fetch('/api/todos', {
      method: 'PATCH',
      body: JSON.stringify({ checked: true }),
      headers: { 'Content-Type': 'application/json' },
    })

    await fetch('/api/todos', { method: 'DELETE' })
  })

  test('adds a todo, navigates to detail page, then back home via headline', async () => {
    const page = await createPage()
    await page.goto(url('/'), { waitUntil: 'domcontentloaded' })

    const todoLabel="nav test"
    await page.fill('.todo-input input', todoLabel)
    await page.keyboard.press('Enter')

    const itemLink = page.locator('.item-label', { hasText: todoLabel })
    await itemLink.click()

    await page.waitForSelector('.todo-detail__title')
    const titleText = await page.locator('.todo-detail__title').textContent()
    expect(titleText?.trim()).toBe(todoLabel)

    await page.locator('.layout-headline-link').click()
    await page.waitForSelector('.todo-input input', { state: 'visible' })
  })
})

This test writes data, so it must clean up between runs. The example checks existing todos and deletes them before each test to keep the test isolated.

If you want to debug in a visible browser, set headless to false:

await setup({
  browser: true,
  browserOptions: {
    type: 'chromium',
    launch: { headless: false, slowMo: 600 },
  },
})

Nuxt’s Playwright integration also supports hydration-aware navigation. For example:

await page.goto(url('/'), { waitUntil: 'commit' })
await page.goto(url('/'), { waitUntil: 'hydration' })

This is useful when debugging hydration mismatches. A common example is locale-sensitive formatting: the server renders a date or currency value using the Node.js locale, while the browser formats it using the user’s system locale. The SSR HTML and client output differ, causing Vue to patch the DOM and report a hydration mismatch.

Common Nuxt testing mistakes

Here are the most common mistakes to watch for when building a Nuxt test suite:

Mistake	Why it causes problems	Better approach
Mocking global fetch for a useFetch page	Nuxt may resolve server routes through Nitro rather than browser fetch	Use registerEndpoint in the nuxt environment
Using mount for Nuxt-dependent components	Routing, plugins, and async setup may not be initialized	Use mountSuspended or renderSuspended
Treating mockNuxtImport like a normal per-test mock	It is hoisted, so multiple implementations in one file can be tricky	Use vi.hoisted or split tests into separate files
Forgetting to clear mocks	Call history leaks between tests	Run vi.clearAllMocks() in beforeEach
Overusing e2e tests	They are slower and harder to maintain	Use unit or Nuxt runtime tests when they provide enough confidence
Mixing runtime and e2e utilities in one file	They require different Vitest environments	Keep runtime and e2e tests in separate files

Conclusion

Nuxt ships with @nuxt/test-utils, which builds on Vue Test Utils and provides APIs for testing Nuxt-specific behavior like auto-imports, routing, SSR, and server routes.

This guide covered three testing tiers:

• Unit tests verify components, composables, and pure logic in isolation
• Nuxt runtime tests verify Nuxt-specific wiring, including routing, middleware, modules, and data fetching
• E2E tests verify the full app flow from the user’s perspective, including SSR, hydration, navigation, and server APIs

As a rule of thumb, start with the lowest tier that gives you sufficient confidence. Use unit tests for pure logic, Nuxt runtime tests when framework behavior matters, and e2e tests for critical flows where the whole stack needs to work together.

That balance gives you a Nuxt test suite that is fast enough to run often, realistic enough to catch integration bugs, and focused enough to maintain as your application grows.

When a user signs up for a large platform, one of the first operations is checking whether their desired username is already taken. At a small scale, this is simple: query the database and return a yes or no answer. At scale, that same check can become expensive, especially if your signup form validates availability as users type.

A Bloom filter can reduce that pressure by acting as a fast, in-memory pre-check before the database. It does not replace the database or your unique constraint. Instead, it answers one useful question very quickly: “Is this username definitely not in the existing set?” If the Bloom filter says no, you can skip the database lookup for the availability check. If it says the username might exist, you fall back to the database for confirmation.

This approach works well for username availability because Bloom filters can produce false positives, but not false negatives for items that have actually been inserted into the filter. In practice, that means a new username may occasionally trigger an unnecessary database lookup, but the system will not incorrectly accept a duplicate username as long as the final write still goes through the database.

The repository associated with this article contains the code for the examples below.

Why direct username checks become expensive

The simplest way to check username availability is to query the users table:

SELECT 1 FROM users WHERE username="alice" LIMIT 1;

For a small app, this is perfectly reasonable. But for a large platform, username checks can generate a surprising amount of read traffic. A signup form may validate availability repeatedly as users type, and most of those checks will be for usernames that do not exist.

Even with proper indexing, every lookup still needs to travel through the database path. Caching helps when the same usernames are checked repeatedly, but it is less useful for random or newly typed usernames that have never been requested before.

The question is not whether the database can answer this query. It can. The question is whether the database should be the first system asked every time.

What is a Bloom filter?

A Bloom filter is a probabilistic data structure used to test whether an item may belong to a set. It stores membership information in a compact bit array instead of storing the full values themselves.

When you add a value, such as a username, the Bloom filter runs that value through multiple hash functions. Each hash function maps the username to a position in the bit array, and the filter sets those positions to 1.

When you check a username later, the filter runs the same hash functions again:

Bloom filter result	Meaning	What to do next
One or more bits are 0	The username is definitely not in the filter	Treat it as available for the read-time availability check
All required bits are 1	The username is probably in the filter	Confirm with the database
False positive	The filter says “probably present,” but the username is not in the database	Perform one unnecessary database lookup
False negative	Standard Bloom filters do not produce this for values that were inserted	If this happens in production, the filter is stale or incorrectly maintained

This tradeoff is the main reason Bloom filters are useful: they can rule out non-membership with certainty, while membership is only approximate.

How Bloom filters work

You can think of each inserted username as leaving a small trail of footprints across a bit array. Each hash function marks one position, so inserting a username like "alice" stamps a specific pattern of bits.

When you check "alice" later, the filter follows the same trail. If any footprint is missing, the username was never inserted into the filter.

As more usernames are added, these trails start to overlap. Different usernames may set some of the same bits. Eventually, the filter may find that all required bits are already set for a username that was never inserted. That is a false positive.

In a username availability system, this is acceptable. A false positive only means the application performs a database lookup to confirm whether the username is actually taken. It does not mean the system accepts duplicate usernames.

Building a Bloom filter in Python

To make the idea concrete, we can build a small prototype using the rbloom library. rbloom is a Python Bloom filter library implemented in Rust, and it exposes an API that feels similar to Python’s built-in set.

Install it first:

pip install rbloom

Then create a Bloom filter configured for 1 million expected usernames with a 1 percent false-positive rate:

from rbloom import Bloom

EXPECTED_USERS = 1_000_000
FALSE_POSITIVE_RATE = 0.01

bf = Bloom(EXPECTED_USERS, FALSE_POSITIVE_RATE)

The first argument is the expected number of items. The second controls the target false-positive rate. Lowering the false-positive rate requires more memory, but it reduces the number of unnecessary database lookups.

Next, generate a mock user base and insert each username into the filter:

existing_users = [f"user_{i}" for i in range(EXPECTED_USERS)]

for username in existing_users:
    bf.add(username)

For this prototype, we can represent the database with a Python set. In a real application, this would be your users table, identity service, or another persistent data store:

user_db = set(existing_users)

def check_database(username: str) -> bool:
    return username in user_db

Now we can define the availability check:

def is_username_available(username: str) -> bool:
    if username not in bf:
        return True

    return not check_database(username)

This function uses the Bloom filter as the first gate:

1. If the username is definitely not in the filter, the function returns True without querying the database.
2. If the username might be in the filter, the function checks the database to confirm.

Try it with a new username and an existing username:

print(is_username_available("new_user"))  # True
print(is_username_available("user_42"))   # False

For most new usernames, the Bloom filter can answer the availability check without touching the database.

Measuring false positives

Bloom filters are probabilistic, so it is worth observing false positives directly. We can generate random usernames that are not part of the original dataset and count how often the Bloom filter reports that they may already exist:

import random
import string

def random_username(length: int = 10) -> str:
    return "".join(random.choices(string.ascii_lowercase, k=length))

false_positives = 0
tests = 10_000

for _ in range(tests):
    username = random_username()

    if username in bf and username not in user_db:
        false_positives += 1

print(f"False positives: {false_positives}/{tests}")

With a configured false-positive rate of 1 percent, the number of false positives should stay relatively small and predictable across a large enough sample.

The important point is that false positives do not compromise correctness in this design. They only send the request to the database, which is the same path the system would have used without the Bloom filter.

Why this reduces database load

The performance benefit comes from moving most negative checks out of the database path. In a username availability flow, most requested usernames are not already taken. A Bloom filter can reject those non-members quickly and in memory.

That gives you two advantages:

Benefit	Why it matters
Fewer database reads	Most unavailable-check requests for new usernames never hit the database
Lower latency	In-memory checks are faster than round trips to a persistent data store
Predictable memory usage	Bloom filters store bit patterns, not full usernames
Safe fallback path	Ambiguous cases still go to the database

This pattern is especially useful when the cost of a false positive is low. In this case, the cost is only an extra database lookup. The cost of accepting a duplicate username, however, would be much higher, so the database must remain the final source of truth.

Production considerations

The Python example shows the core idea, but a production username availability system needs additional safeguards.

Keep the database as the source of truth

A Bloom filter should not be the final authority for creating usernames. It should speed up availability checks, but the database should still enforce a unique constraint on the username column.

That final constraint protects you from race conditions. For example, two users could check the same available username at nearly the same time. Even if both read-time checks return “available,” only one final insert should succeed.

Keep the filter up to date

A standard Bloom filter does not produce false negatives for items that were inserted into it. However, a production system can still return incorrect results if the filter is stale.

For example, if a username is written to the database but not added to the Bloom filter, a later availability check may incorrectly skip the database. To avoid this, update the filter when usernames are created, and consider rebuilding it periodically from the source of truth.

Plan for deletions and username changes

Standard Bloom filters do not support deleting individual items. If your product lets users delete accounts or change usernames, the filter may continue to report old usernames as “probably present.”

That does not create a correctness problem, because the database fallback will confirm availability. But it can reduce the filter’s usefulness over time by increasing unnecessary database checks. If deletions matter for your use case, consider a counting Bloom filter, a Cuckoo filter, or a scheduled rebuild.

Use a distributed implementation

A local in-memory Bloom filter may work for a single service instance, but many production systems run across multiple instances or regions. In that case, each instance needs a consistent view of the filter.

Tools such as Redis probabilistic data structures can help here. Redis supports scalable Bloom and Cuckoo filters for membership checks, which makes it a practical option when you need a shared filter layer across services.

When should you use a Bloom filter?

Bloom filters are a good fit when:

• You need fast membership checks against a large set
• Most queries are expected to be negative
• False positives are acceptable
• False negatives are not acceptable for inserted values
• There is a reliable source of truth behind the filter

They are not a good fit when:

• You need exact answers every time
• You need frequent deletions without rebuilding or using a different filter type
• A false positive is expensive or user-visible
• You cannot keep the filter synchronized with the source of truth

For username availability, the fit is strong because a false positive only causes an extra database check, while a negative result can safely avoid one.

Conclusion

Bloom filters are a practical way to reduce database load when checking username availability at scale. By accepting a controlled probability of false positives, you can bypass many unnecessary lookups while preserving correctness through a database fallback.

The key is to use the Bloom filter for what it does best: ruling out usernames that definitely do not exist in the filter. It should not replace the database, the unique index, or the final insert-time check. Instead, it acts as a fast pre-check that keeps the common path lightweight and leaves the database for the cases that actually need confirmation.

That tradeoff appears across many large-scale systems. Bloom filters are useful whenever a compact, approximate membership test can prevent more expensive work downstream, from database lookups to duplicate event filtering to blockchain log searches.