Bekzod Erkinov
Listen to Article
Loading...Table of contents · 10 sections
Building Real-Time Voice Agents in React With ElevenLabs
Spoken dialogue in web applications has historically suffered from high conversational latency and brittle audio synchronization. By adopting a unified conversational framework, frontend engineers can bypass manual buffer orchestration to deliver full-duplex voice interactions where an AI agent speaks naturally while directly manipulating client-side state.
Some links in this post are affiliate links; see our disclosure. Pricing and SDK verified November 2026.
Quick Verdict: Pick It vs. Skip It
- Pick it if: You are building customer support widgets, interactive onboarding tours, or voice-driven SaaS interfaces where low conversational latency, natural prosody, and the ability to trigger browser actions (like opening modals or navigating routes) matter more than training proprietary models.
- Skip it if: You require strictly on-premise, air-gapped speech processing, cannot accept cloud usage costs of roughly $0.08 per call minute on paid plans, or need a purely text-based LLM workflow without acoustic feedback.
What It Is: Managed Full-Duplex Voice Infrastructure
Traditional browser voice setups required stitching discrete transcription, inference, and synthesis services together, accumulating latency and compounding interruption failures at every boundary. Synthesized audio played via the MDN Web Audio API frequently collided with ongoing user input, requiring complex manual cancellation logic.
ElevenLabs addresses this through its Conversational AI platform, unifying speech recognition, reasoning, and voice generation into a single managed connection. As detailed in the ElevenLabs Conversational AI documentation, the @elevenlabs/react package exposes this engine to React and Next.js applications through declarative hooks. The client establishes a bidirectional stream over WebSockets or WebRTC with integrated voice activity detection (VAD), acoustic echo cancellation (AEC), and native interruption handling: when the user speaks while the assistant is responding, synthesis halts immediately and the platform switches back to listening.
Why It Matters Now: Context-Aware Web Agents
Voice interfaces are evolving from isolated chat widgets toward context-aware web agents that actively drive frontend user experiences. Rather than functioning as detached audio responders, modern voice assistants need to inspect and mutate application state in real time—triggering route changes, opening dialogs, or filtering dashboard metrics on command.
This coordination is powered by client tools. While webhook tools execute server-side to query external APIs or databases, client tools run directly inside the browser runtime, as outlined in the ElevenLabs Client Tools guide. Furthermore, @elevenlabs/react decouples stable action triggers from high-frequency audio visualizer data streams, preventing unnecessary component re-renders and preserving 60 FPS UI performance.
If you are packaging your voice assistant as a commercial software product, you can launch your frontend quickly with the ai-saas-landing template.
Pros and Cons: Evaluating ElevenLabs Conversational AI
Evaluating ElevenLabs Conversational AI for web applications requires balancing turnkey developer convenience against proprietary cloud constraints:
Pros
- Turnkey Full-Duplex Delivery: Manages bidirectional WebRTC and WebSocket streaming with built-in voice activity detection (VAD), acoustic echo cancellation (AEC), and real-time interruption handling out of the box, eliminating the need to orchestrate separate ASR, LLM, and TTS pipelines.
- Client Tool Execution in Browser Runtime: The
useConversationClientToolhook allows the agent to execute client-side JavaScript functions directly in the browser, enabling seamless state manipulation, modal toggling, and page navigation without backend round-trips. - Natural Prosody and Expressive Voice Library: Delivers industry-leading speech naturalness, emotional pacing, and expressive voice cloning options that significantly outperform conventional chained robotic voices.
- Decoupled React Architecture: The
@elevenlabs/reactSDK separates high-frequency audio visualization streams from stable session control dispatchers, preventing unnecessary component re-renders and protecting UI responsiveness.
Cons
- Closed-Source Cloud Lock-In: The orchestration layer, speech models, and conversational state machine are proprietary and hosted entirely on ElevenLabs infrastructure; teams cannot self-host on-premises or deploy into air-gapped environments.
- Idle Session Minute Costs: Conversational billing accrues based on active connection time (~$0.08 per minute after plan allocations). Forgotten or unclosed browser sessions continue consuming credits while silent unless aggressive client-side inactivity timeouts are enforced.
- Tier-Enforced Concurrency Caps: Base plans impose hard simultaneous call limits (4 concurrent calls on Free, 6 on Starter, 10 on Creator, and 20 on Pro), causing connection rejections during traffic spikes unless enterprise scaling terms are arranged.
- Third-Party Model and Telephony Costs: Utilizing custom external LLMs or external telephony carriers incurs secondary per-token or SIP trunking charges beyond the base subscription minutes.
Architectural Comparison: ElevenLabs vs. Realtime API vs. Custom Pipelines
Developers building conversational voice interfaces typically choose among three primary architectures: a managed conversational platform, a direct speech-to-speech foundation model API, or a custom pipeline of stitched microservices.
| Dimension | ElevenLabs Conversational AI | OpenAI Realtime API (gpt-realtime-2.1) |
Custom Pipeline (Whisper + LLM + TTS) |
|---|---|---|---|
| Architecture | Unified ASR + LLM + TTS managed as one bidirectional stream | Direct speech-to-speech multi-modal neural network | Discrete services chained via custom backend orchestrator |
| Transport | WebRTC and WebSockets (wss://) |
WebRTC and WebSockets (wss://) |
HTTP/REST or WebSockets per service |
| Voice Realism | High naturalness with expressive voice library and cloning | High naturalness with expressive speech tokens | Varies by TTS provider; prone to prosody mismatches |
| Client UI Integration | Native React SDK with scoped useConversationClientTool |
Raw WebSocket/WebRTC events requiring custom event parsers | Custom event bus required across multiple service sockets |
| Interruption Handling | Built-in server VAD with automatic playback cutoff | Native speech-to-speech interruption detection | Complex manual state machine required to abort TTS buffers |
| Audio Processing | Built-in Echo Cancellation (AEC) & noise suppression | WebRTC-level AEC; manual config on WebSockets | Developer must implement client DSP or Web Audio filters |
| Pricing Model | Predictable tiers (Free $0, Starter $6/mo, Creator $22/mo, Pro $99/mo) + ~$0.08/min overage | Token-based ($32/1M input audio, $64/1M output audio tokens; ~$0.08–$0.24+/min normalized) | Sum of individual service fees (Whisper ~$0.006/min + LLM tokens + TTS $/1k characters) |
| Maintenance Burden | Low: prompt, voice, and tools configured via dashboard/API | Moderate: requires building client session managers and token handlers | High: managing multiple vendor APIs, WebSocket drops, and buffer synchronization |
Normalizing Comparative Pricing Metrics
Comparing operational costs across voice architectures requires normalizing distinct billing units—namely flat connection minutes versus multi-modal token consumption:
- Turn Duration and Volume Assumptions: A representative conversational voice session averages 4 to 6 conversational turns per minute. Each turn consists of approximately 3 to 5 seconds of user speech (input audio) and 4 to 6 seconds of assistant synthesis (output audio).
- Token-to-Minute Conversion: OpenAI API Realtime models (
gpt-realtime-2.1) bill strictly per audio token ($32.00 per 1M uncached input audio tokens, $0.40 per 1M cached input audio tokens, and $64.00 per 1M output audio tokens). Standard 24kHz audio streams generate approximately 100 to 133 audio tokens per second (roughly 6,000 to 8,000 audio tokens per continuous minute of speech). In a balanced turn-taking scenario with 30 seconds of user input and 30 seconds of assistant speech, base generation alone generates ~$0.015 input tokens and ~$0.038 output tokens, yielding a baseline cost of ~$0.05 to $0.07 per active minute. - Caching Dynamics and Session Longevity: Over multi-turn sessions, the Realtime API appends conversational history to subsequent turns. If prompt caching is disabled or invalidated by variable tool schemas, re-transmitting previous conversation turns balloons input token consumption to 15,000–25,000+ tokens per minute, pushing real-world operational costs to $0.08–$0.24+ per minute. When OpenAI prompt caching is fully utilized, input audio costs drop to $0.40/1M tokens, bringing sustained costs back near the lower $0.08/min threshold.
- Flat Minute Predictability: In contrast, the ElevenLabs pricing schedule bills strictly on connected wall-clock minutes. Included plan quotas range from 15 to 1,238 minutes, with additional conversational time billed at a predictable ~$0.08 per minute, regardless of prompt length, turn frequency, or dynamic client tool invocations. Custom pipelines offer the lowest raw component pricing (Whisper at ~$0.006/min + LLM text tokens at ~$0.15–$2.50/1M + TTS at ~$15–$30/1M characters), but demand significant engineering overhead to manage latency, streaming chunk buffers, and interruption logic.
Plan Breakdown: Tiers, Quotas, and Buyer Workload Recommendations
Pricing, quotas, and tier terms verified November 2026 against official ElevenLabs documentation.
Selecting the right subscription tier depends on required conversational minutes, simultaneous call traffic, and licensing compliance. The platform structures its self-serve plans as follows:
| Plan | Monthly Billing | Annual Billing (Effective Rate) | Included Quota Minutes | Concurrency Cap | Commercial Usage Rights | Overage Rate |
|---|---|---|---|---|---|---|
| Free | $0 / mo | $0 / mo | 15 min / mo | 4 concurrent calls | Non-commercial only (attribution required) | N/A (hard cap) |
| Starter | $6 / mo ($1 first mo) | $5 / mo ($60 / yr) | 75 min / mo | 6 concurrent calls | Commercial license included | ~$0.08 / min |
| Creator | $22 / mo ($11 first mo) | $18.33 / mo ($220 / yr) | 275 min / mo | 10 concurrent calls | Commercial license included | ~$0.08 / min |
| Pro | $99 / mo | $82.50 / mo ($990 / yr) | 1,238 min / mo | 20 concurrent calls | Commercial license included | ~$0.08 / min |
Buyer Workload Recommendations
To match tier parameters to practical engineering milestones, align your deployment scale with the following workload profiles:
- Free Tier (Local Prototyping & SDK Evaluation): Designed for individual developers validating
@elevenlabs/reacthooks, testing signed URL endpoints, and exploring client tool callbacks in local development (localhost). The 15-minute quota and non-commercial attribution requirement make it suitable solely for sandbox experimentation. - Starter Tier (Internal Proof-of-Concept & Executive Demos): Best suited for early-stage validation, hackathons, and internal stakeholder demos. The 75-minute quota provides ample buffer for building a working proof-of-concept, while the commercial license ensures intellectual property compliance. With a concurrency cap of 6 simultaneous calls, it comfortably supports single-presenter demonstrations.
- Creator Tier (Staged Beta Rollouts & Pilot Cohorts): Engineered for customer discovery cohorts, staged closed betas, and low-volume SaaS onboarding tours. The 275-minute quota and 10 concurrent call limit accommodate small groups of test users exploring voice navigation without risking immediate concurrency lockouts during peak testing sessions.
- Pro Tier (Production SaaS with Concurrency Needs): Essential for customer-facing commercial SaaS products, live support widgets, and scalable voice workflows. The 1,238-minute allocation reduces per-minute anxiety, while the 20-call concurrency ceiling prevents session drops during concurrent user traffic surges. Additional usage scales at ~$0.08 per minute without service disruption.
How It Works Under the Hood: WebSockets, WebRTC, and the React State Loop
Building a reliable voice interface requires understanding the session lifecycle and security boundaries between browser, server, and ElevenLabs infrastructure.
1. Connection Transport and Signed URL Security
ElevenLabs supports both WebSockets (wss://api.elevenlabs.io/v1/convai/conversation) and WebRTC. For browsers, WebRTC provides lower latency over UDP and enables native Acoustic Echo Cancellation (AEC).
To protect account credentials, master API keys (xi-api-key) must never reside in frontend code. Instead, applications use an ephemeral token workflow documented in the ElevenLabs Signed URL API reference:
- The client requests a session token from an internal backend endpoint.
- The server queries
GET https://api.elevenlabs.io/v1/convai/conversation/get-signed-urlwith theagent_idand secret API key. - ElevenLabs returns a signed URL with a temporary token (valid for 15 minutes).
- The client uses this signed URL to establish a direct, authenticated audio session.
2. The Decoupled React Hook Architecture
As documented in the ElevenLabs React SDK guide, in @elevenlabs/react (version 1.23.0), state is divided across specialized sub-contexts inside <ConversationProvider>:
useConversationControls: Returns stable action methods (startSession,endSession,sendUserMessage,sendContextualUpdate,setVolume,changeInputDevice). These references remain stable across renders so control buttons do not re-render as speech streams.useConversationStatus: Reports connection state ("disconnected","connecting","connected", or"error").useConversationMode: Tracks whether the agent is currently"speaking"or"listening".useConversationClientTool: Binds frontend functions to agent tool calls using a React ref pattern to ensure execution captures fresh component state without stale closures.
Step-by-Step Walkthrough: Building an Interactive Voice Assistant in React
The following walkthrough demonstrates how to build an interactive voice assistant in Next.js and React that updates application state via voice.
Step 1: Generating a Secure Signed URL on the Server
Install the React SDK via npm:
npm install @elevenlabs/react
Create a Next.js App Router route handler at app/api/elevenlabs/signed-url/route.ts to keep the API key on the server:
// app/api/elevenlabs/signed-url/route.ts
// (Verified against ElevenLabs API documentation; not executed in an end-to-end browser session.)
import { NextResponse } from "next/server";
export async function GET() {
const agentId = process.env.ELEVENLABS_AGENT_ID;
const apiKey = process.env.ELEVENLABS_API_KEY;
if (!agentId || !apiKey) {
return NextResponse.json({ error: "Missing ElevenLabs credentials" }, { status: 500 });
}
const url = new URL("https://api.elevenlabs.io/v1/convai/conversation/get-signed-url");
url.searchParams.set("agent_id", agentId);
const response = await fetch(url.toString(), {
method: "GET",
headers: { "xi-api-key": apiKey },
cache: "no-store",
});
if (!response.ok) {
return NextResponse.json({ error: "Failed to generate signed URL" }, { status: response.status });
}
const data: { signed_url: string } = await response.json();
return NextResponse.json({ signedUrl: data.signed_url });
}
Step 2: Configuring the Root ConversationProvider
Wrap the client tree with <ConversationProvider>:
// components/VoiceWrapper.tsx
// (Verified against @elevenlabs/react v1.23.0 exports; not executed in an end-to-end browser session.)
"use client";
import React, { ReactNode } from "react";
import { ConversationProvider } from "@elevenlabs/react";
export function VoiceWrapper({ children }: { children: ReactNode }) {
return (
<ConversationProvider>
<div className="min-h-screen bg-slate-900 text-slate-100 p-8">{children}</div>
</ConversationProvider>
);
}
Step 3: Managing Microphone Permissions and Session Controls
Browser security requires explicit user permission inside a Secure Context (https:// or localhost), as documented on MDN Web Docs for MediaDevices.getUserMedia.
Build a control component to request microphone access and start the session:
// components/VoiceControls.tsx
// (Verified against @elevenlabs/react v1.23.0 type definitions; not executed in an end-to-end browser session.)
"use client";
import React, { useState } from "react";
import { useConversationControls, useConversationStatus, useConversationMode } from "@elevenlabs/react";
export function VoiceControls() {
const { startSession, endSession } = useConversationControls();
const { status } = useConversationStatus();
const { mode } = useConversationMode();
const [loading, setLoading] = useState(false);
const handleStart = async () => {
setLoading(true);
try {
await navigator.mediaDevices.getUserMedia({ audio: true });
const res = await fetch("/api/elevenlabs/signed-url");
const { signedUrl } = await res.json();
startSession({
signedUrl,
onError: (err) => console.error("Session runtime error:", err),
});
} catch (err) {
console.error("Microphone or handshake failure:", err);
} finally {
setLoading(false);
}
};
const isConnected = status === "connected";
return (
<div className="flex flex-col items-center gap-4 p-6 bg-slate-800 rounded-xl border border-slate-700">
<p className="text-sm">Status: <strong className="capitalize">{status}</strong> {isConnected && `(${mode})`}</p>
{isConnected ? (
<button onClick={endSession} className="px-5 py-2 bg-rose-600 hover:bg-rose-500 rounded font-medium">
End Session
</button>
) : (
<button onClick={handleStart} disabled={loading} className="px-5 py-2 bg-indigo-600 hover:bg-indigo-500 rounded font-medium disabled:opacity-50">
{loading ? "Connecting..." : "Start Talking"}
</button>
)}
</div>
);
}
Step 4: Registering Dynamic Client Tools with useConversationClientTool
In the ElevenLabs agent dashboard under Tools, declare a tool with type Client named set_active_view with a required string parameter viewName.
Then register the tool inside your view component:
// components/DashboardView.tsx
// (Verified against @elevenlabs/react v1.23.0 type definitions; not executed in an end-to-end browser session.)
"use client";
import React, { useState } from "react";
import { useConversationClientTool } from "@elevenlabs/react";
type View = "overview" | "analytics" | "settings";
export function DashboardView() {
const [activeView, setActiveView] = useState<View>("overview");
// Registers handler with nearest ConversationProvider; avoids stale closures via React refs
useConversationClientTool("set_active_view", (params: Record<string, unknown>) => {
const target = String(params.viewName).toLowerCase();
if (target === "overview" || target === "analytics" || target === "settings") {
setActiveView(target as View);
return `Interface successfully transitioned to ${target}.`;
}
return `Invalid view: ${params.viewName}. Supported views: overview, analytics, settings.`;
});
return (
<div className="mt-6 p-6 bg-slate-800/80 rounded-xl border border-slate-700">
<h3 className="font-semibold text-lg mb-4">Current View: <span className="text-indigo-400 capitalize">{activeView}</span></h3>
<div className="grid grid-cols-3 gap-3">
{(["overview", "analytics", "settings"] as View[]).map((v) => (
<div key={v} className={`p-4 rounded border text-center ${activeView === v ? "border-indigo-500 bg-indigo-500/20 font-bold" : "border-slate-700 text-slate-400"}`}>
{v.toUpperCase()}
</div>
))}
</div>
</div>
);
}
When a user says, "Open the analytics view," the assistant executes set_active_view({ viewName: "analytics" }). The React component updates activeView, and the confirmation message is returned to the agent so it can verbally confirm the change.
Step 5: Visualizing Real-Time Audio Output
useConversationControls provides getOutputByteFrequencyData, which returns a Uint8Array of audio frequencies (100–8000 Hz) to render visual feedback:
// components/VoiceVisualizer.tsx
// (Verified against @elevenlabs/react v1.23.0 type definitions; not executed in an end-to-end browser session.)
"use client";
import React, { useEffect, useRef } from "react";
import { useConversationControls, useConversationStatus } from "@elevenlabs/react";
export function VoiceVisualizer() {
const { getOutputByteFrequencyData } = useConversationControls();
const { status } = useConversationStatus();
const canvasRef = useRef<HTMLCanvasElement | null>(null);
useEffect(() => {
if (status !== "connected") return;
let animId: number;
const draw = () => {
const canvas = canvasRef.current;
if (!canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const data = getOutputByteFrequencyData();
ctx.clearRect(0, 0, canvas.width, canvas.height);
const barWidth = (canvas.width / data.length) * 2.5;
for (let i = 0; i < data.length; i++) {
const barHeight = (data[i] / 255) * canvas.height;
ctx.fillStyle = "#6366f1";
ctx.fillRect(i * (barWidth + 1), canvas.height - barHeight, barWidth, barHeight);
}
animId = requestAnimationFrame(draw);
};
draw();
return () => cancelAnimationFrame(animId);
}, [status, getOutputByteFrequencyData]);
if (status !== "connected") return null;
return (
<div className="mt-4 flex flex-col items-center">
<span className="text-xs text-slate-400 mb-1">Agent Voice Output</span>
<canvas ref={canvasRef} width={240} height={36} className="bg-slate-950 rounded border border-slate-800" />
</div>
);
}
Step 6: Assembling the Full Application in app/page.tsx
To make the voice assistant 100% turnkey, assemble VoiceWrapper, VoiceControls, DashboardView, and VoiceVisualizer inside the Next.js root page at app/page.tsx. Because VoiceWrapper encapsulates the <ConversationProvider>, all child components safely gain access to the decoupled conversation hooks:
// app/page.tsx
// (Verified against @elevenlabs/react v1.23.0 component hierarchy; not executed in an end-to-end browser session.)
import { VoiceWrapper } from "@/components/VoiceWrapper";
import { VoiceControls } from "@/components/VoiceControls";
import { DashboardView } from "@/components/DashboardView";
import { VoiceVisualizer } from "@/components/VoiceVisualizer";
export default function Page() {
return (
<VoiceWrapper>
<main className="max-w-2xl mx-auto flex flex-col items-center gap-6">
<header className="text-center">
<h1 className="text-3xl font-bold tracking-tight">Interactive Voice Dashboard</h1>
<p className="text-slate-400 mt-2 text-sm">
Speak naturally to navigate views or trigger UI state changes in real time.
</p>
</header>
<VoiceControls />
<VoiceVisualizer />
<DashboardView />
</main>
</VoiceWrapper>
);
}
Package details and source files can be checked directly on the ElevenLabs TypeScript repository on GitHub and the @elevenlabs/react registry page on npm.
Pitfalls and Technical Limitations
When deploying browser-based voice agents, several practical limitations require attention:
1. Insecure Context Failures
The browser navigator.mediaDevices.getUserMedia API is strictly restricted to Secure Contexts (https:// or localhost). Testing a staging build over raw HTTP or local network IP on mobile causes getUserMedia to fail with an immediate TypeError. Ensure all staging environments enforce TLS.
2. Autoplay Restrictions in Mobile Safari
iOS Safari restricts media capture and audio playback unless initiated by an explicit user gesture. Invoking startSession() inside an unlinked asynchronous callback causes Safari to reject audio. Always bind session initialization directly to user click or touch handlers.
3. Acoustic Feedback Loops
Using laptop speakers without headphones can cause synthesized voice output to leak into the microphone. While WebRTC includes Acoustic Echo Cancellation (AEC), low-quality hardware or non-standard sound cards can cause self-transcription loops. Always test your agent with both built-in laptop microphones and external headsets.
4. Concurrent Call Quota Limits
Every subscription plan enforces hard concurrent call caps: 4 on Free, 6 on Starter ($6/month), 10 on Creator ($22/month), and 20 on Pro ($99/month). Traffic spikes exceeding these caps return errors until active calls end. High-traffic apps must plan capacity or negotiate enterprise limits.
5. Idle Session Credit Consumption
Conversational time costs roughly $0.08 per call minute after plan limits, meaning abandoned open sessions continuously consume account credits. Implement client-side inactivity timeouts to automatically call endSession() if no user speech or UI activity is detected after 90 seconds.
Who Should Skip It (and What to Build Instead)
ElevenLabs Conversational AI is effective for interactive assistants, but specific architectural constraints warrant alternative approaches:
1. High-Volume, Low-Margin Consumer Apps
If you are developing a free consumer product where users chat for hours daily, paying ~$0.08 per call minute ($4.80 per hour) will rapidly exceed ad or subscription margins.
- Alternative: Use turn-based push-to-talk with self-hosted Whisper on an open-source inference backend paired with standard browser speech synthesis.
2. Air-Gapped or Regulated Environments
If your application handles healthcare data subject to strict on-premise mandates, classified data, or isolated intranet environments, streaming audio to an external cloud platform is prohibited.
- Alternative: Deploy on-premise WebRTC nodes using Whisper.cpp and local LLMs (via vLLM or Ollama) on private hardware.
3. High-Density Data Workflows
Voice input is inefficient for editing tables, diffing code, or configuring complex cloud infrastructure. Forcing voice controls into operational dashboards often adds friction compared to standard keyboard shortcuts.
- Alternative: Maintain structured forms, tables, and typed command bars.
What to Do Next
To implement and evaluate real-time voice agents in your own stack, follow this practical checklist:
- Create an agent: In the ElevenLabs dashboard, create a Conversational Agent, choose an expressive voice, and set prompt instructions to keep verbal replies concise (under two sentences per turn).
- Define client tools: Add a tool under the agent's Tools tab with type
Client, specifying the exact tool name and parameter schema your UI requires. - Set up signed URL route: Create a backend route handler that calls
GET https://api.elevenlabs.io/v1/convai/conversation/get-signed-urlusing your secretxi-api-key. - Install
@elevenlabs/react: Wrap your application in<ConversationProvider>and manage connections withuseConversationControls. - Attach UI handlers: Use
useConversationClientToolinside view components to update local React state when the agent triggers actions. - Add inactivity guards: Disconnect sessions automatically after 90 seconds of silence to prevent unnecessary minute consumption.
Worth a look: ElevenLabs fits teams building real-time voice interfaces who want polished speech synthesis and client tool execution without wiring up separate audio streaming infrastructure; skip it if your budget requires sub-$0.01 self-hosted inference or if your application cannot transmit audio off-premises.
Keep reading
React vs Angular: Which Framework to Choose in 2026
26 min · 226 views
AI WorkflowsMulti-Tenant SaaS Architecture with Laravel and React: Battle-Tested Patterns from Production
33 min · 192 views
Cloud ComputingReact Server Components: When to Use vs Client Components
23 min · 182 views
Bekzod Erkinov
AuthorFounder of NextGenBeing. Software engineer working with Laravel, Python, and cloud infrastructure. Writes about patterns that actually hold up in production. Based in Tashkent, Uzbekistan.
Get the AI-Assisted Developer's Field Guide
The workflow, prompts, and tools I use to ship faster with AI — free when you subscribe. Plus new deep-dives in your inbox. No spam, unsubscribe anytime.
Comments (0)
Please log in to leave a comment.
Log In