Screen Chirp Logo screen chirp Case Study
Home / Work / Screen Chirp Platform Case Study
Case Study & Architectural Report

Screen Chirp Multi-Tenant WebRTC Video Meeting & Voice Telephony Platform

How Nexovex engineered a zero-daemon PHP/MySQL WebRTC video conferencing engine, pure-PHP HS256 JWT minter, and telephone voice conference bridge—enabling lightning-fast browser collaboration and telephone dial-in bridging on standard web hosting with zero Node.js daemon overhead.

WebRTC Video & 4K Screen Share Pure-PHP HS256 JWT Signer PSTN Voice Dial-In Bridge Host-Admit Waiting Rooms Persistent Chirps Messaging
Video Engine WebRTC Mesh
1080p HD + 4K Screen
Adaptive Bitrate Streaming
Server Architecture Native LAMP
0 Node.js Daemons
Deployable on standard cPanel
Dial-In Bridge Twilio Voice
PSTN ↔ WebRTC
TwiML Interactive Voice IVR
Security & Keys AES-256
< 55ms Token Mint
Pure-PHP HS256 JWT Generation
Screen Chirp WebRTC Video Meeting & Voice Telephony Platform
Client / Product
Screen Chirp screenchirp.com
Real-Time Video & Telephony SaaS
Engagement
Core Platform & WebRTC Infrastructure
Pure-PHP JWT, PSTN audio bridge & waiting rooms
Status & Scale
Production Core & Embeddable SDK
Breakout rooms, Whisper STT & Stripe tiers
Core Technologies
PHP 8 MVC, MySQL, Twilio Video JS
Twilio Voice TwiML, AES-256-CBC, JWT HS256
The Architectural Challenge

Building Enterprise Video Conferencing Without Fragile Daemon Superstructures

Traditional WebRTC architectures require dedicated Node.js signaling daemons, memory-intensive Socket.io servers, and complex orchestration proxies. The client needed an enterprise-grade conferencing platform deployable on standard LAMP/cPanel infrastructure without sacrificing sub-second latency or telephone dial-in interoperability.

Bottleneck 01

The Fragility and Overhead of Persistent Node.js Daemons

Most video conferencing software depends on long-running Node.js processes, Redis pub/sub brokers, and persistent WebSocket clusters. These daemons frequently crash under socket connection floods, leak memory over long runtimes, and are strictly barred or severely constrained in cost-effective cPanel/shared environments. The system required a stateless, resilient PHP architecture capable of high-concurrency room brokering.

Engineering Focus: Zero-Daemon Architecture 100% PHP/MySQL Portability
Bottleneck 02

Bridging Standard PSTN Phone Lines into WebRTC Audio Streams

Remote executives, field operators, and clients in poor connectivity areas frequently lack stable data bandwidth for video. The platform required a seamless PSTN voice bridge: callers dial a regular telephone number, interact with an automated DTMF tone IVR to input a 9-digit meeting ID and security PIN, and get bridged directly into the active WebRTC room audio mesh without manual host intervention.

Engineering Focus: PSTN ↔ WebRTC Voice Gateway TwiML Dynamic Conference Routing
Bottleneck 03

Multi-Tenant Credential Isolation & Zero-Bloat JWT Minting

Importing standard third-party Twilio PHP SDK packages adds over 140MB of Composer dependencies, autoloading hundreds of classes for a simple JWT token mint. Simultaneously, a multi-tenant SaaS requires each tenant to optionally supply their own Twilio Account SID, Auth Token, and API credentials. These secrets must be encrypted with AES-256 at rest and decrypted ephemerally in memory without disk leakage.

Engineering Focus: Pure-PHP HS256 Token Signer AES-256 Envelope Encryption
Bottleneck 04

Real-Time Meeting State Control: Waiting Rooms & Chirps Chat

Enterprise calls demand host authorization controls: guest pre-entry lobbies (waiting rooms) where hosts review participant names before admission, unguessable meeting slugs, brute-force IP throttling, and persistent in-call chat ("Chirps") that outlives the video call itself. Orchestrating these states with zero Socket servers demanded intelligent database indexing and dual-path DataTrack transmission.

Engineering Focus: Host Admission Gatekeeper DataTrack + MySQL Dual-Commit
Nexovex Craftsmanship

Engineered Solutions: The Architectural Pillars

Nexovex architected Screen Chirp with a decoupled signaling and streaming model: offloading heavy peer-to-peer WebRTC video to CDN-loaded SDKs, bridging voice calls via dynamic TwiML webhooks, and powering authentication with a bespoke pure-PHP JWT cryptographic engine.

Zero-Daemon WebRTC Signaling & Pure-PHP HS256 Token Minter

Rather than encumbering the infrastructure with monolithic Composer SDKs, Nexovex developed a native PHP HS256 JSON Web Token (JWT) generator. Operating via hash_hmac('sha256') and custom base64url_encode(), the engine generates signed, scoped Twilio Video grants in under 55ms with an in-memory footprint of less than 2MB.

  • Zero external dependencies: eliminated 140MB+ of Composer packages and autoloaders
  • Short-lived 2-hour cryptographic grants with unique jti anti-replay identifiers
  • CDN-loaded Twilio Video JS SDK on the front-end for peer-to-peer & group mesh streaming

Twilio Voice Dial-In Conference Bridge with HMAC-SHA1 Webhooks

Nexovex engineered a dedicated telephony voice gateway powered by TwiML webhooks. Inbound calls are greeted by an automated Alice IVR, which collects DTMF Meeting IDs via <Gather>, validates them against MySQL, and bridges the telephone caller into a dynamic <Conference> mapped to the WebRTC video room name.

  • Strict HMAC-SHA1 webhook signature validation verifying sorted POST parameters and URL
  • Unified audio conference namespace bridging standard cellular callers and web browsers
  • Automated lifecycle callbacks updating participant connection state and call duration logs

Host-Admitted Waiting Rooms & AES-256 Multi-Tenant Isolation

Enterprise confidentiality is preserved through a defense-in-depth security model. Meeting invitations use unguessable 16-character hexadecimal slugs (`/m/{slug}`) with Apache rewrite rules. Guest entries are gated behind visual waiting rooms, and all tenant Twilio API credentials are encrypted at rest with AES-256-CBC.

  • AES-256-CBC OpenSSL envelope encryption protecting API keys, auth tokens, and secrets
  • Host admission gatekeeper: hosts inspect waiting participant roster before admitting
  • IP failed-login rate limiting in audit_logs locking brute-force attempts for 15 minutes

Chirps Persistent Chat, Cloud Recording & Embeddable SDK

Unlike standard conferencing apps where chat disappears upon disconnect, Screen Chirp's signature Chirps engine persists threaded messaging and emoji reactions in MySQL. The system is augmented with Twilio Composition cloud recording, automated Whisper transcription, and an embeddable JavaScript SDK.

  • Dual-stream chat: zero-latency P2P DataTrack transmission combined with durable DB logging
  • Embeddable Client SDK (screenchirp-sdk.js) with single-use embed tokens and iframe API
  • Cloud recording synchronization with automated duration metering and Whisper transcription
Interactive Telemetry Engine

Real-Time Architecture & Execution Pipeline

Select an architectural sub-system below to inspect the execution pipeline, live telemetry specifications, and underlying production code payloads.

Pure-PHP JWT Minting & Signaling Token Generation: < 55ms
01
Client Meeting Auth Gate
Host or guest loads room slug /m/{slug}. Server verifies session permissions or validates guest meeting token against database records.
HTTP/2 TLS 1.3 · HMAC Token Handshake
02
AES-256 Secret Decryption
Backend retrieves tenant Twilio API Key SID and encrypted Auth Secret, decrypting via OpenSSL AES-256-CBC envelope key.
openssl_decrypt() · Zero Disk Footprint
03
Pure-PHP HS256 JWT Generation
Encodes header and Twilio Video grant payload into base64url strings, computing SHA-256 HMAC signature in pure PHP with zero SDK bloat.
hash_hmac('sha256') · Memory Footprint < 2MB
04
Client-to-Client WebRTC Peer Mesh
Browser passes minted JWT token to CDN-loaded Twilio.Video.connect(), establishing low-latency audio, HD video, and 4K screen sharing.
Twilio Video JS SDK · Adaptive Bitrate Control
Real-Time Pipeline Telemetry
WebRTC (SRTP/DTLS) + WSS
Adaptive Jitter Ring-Buffer
api.php (get_video_token)
99.99% Signaling Availability
config.php (Pure-PHP Video Token Generator) PHP
function generate_twilio_video_token($accountSid, $apiKeySid, $apiKeySecret, $identity, $roomName) {
    $header  = ['cty' => 'twilio-fpa;v=1', 'typ' => 'JWT', 'alg' => 'HS256'];
    $now     = time();
    $payload = [
        'jti'    => $apiKeySid . '-' . $now . '-' . bin2hex(random_bytes(8)),
        'iss'    => $apiKeySid,
        'sub'    => $accountSid,
        'nbf'    => $now,
        'exp'    => $now + 7200,
        'grants' => ['identity' => (string)$identity, 'video' => ['room' => (string)$roomName]],
    ];
    $b64Header  = base64url_encode(json_encode($header));
    $b64Payload = base64url_encode(json_encode($payload));
    $sig        = hash_hmac('sha256', $b64Header . '.' . $b64Payload, $apiKeySecret, true);
    return $b64Header . '.' . $b64Payload . '.' . base64url_encode($sig);
}
Product & Engineering Roadmap

Transparent Engineering Timeline

Nexovex approaches enterprise software engineering with total transparency. While Screen Chirp's core WebRTC video engine, PSTN telephone voice bridge, and Chirps messaging layer are fully operational in production, advanced collaboration extensions are systematically delivered across structured engineering milestones.

Software Engineering Status & Multi-Tenant Rollout
Screen Chirp is currently in production as a zero-daemon WebRTC conferencing engine and telephone dial-in platform. Phase 2 and 3 features—including breakout rooms, automated cloud recording sync, Whisper transcription, and Stripe multi-tier billing—are actively operational. Enterprise SSO (SAML 2.0) and SCIM directory provisioning represent the scheduled Phase 4 milestone.
Phase 0 & 1 · In Production

Core Platform & Video Mesh

Foundation WebRTC video conferencing, pure-PHP HS256 JWT generation, and PSTN telephone dial-in conference bridging.

  • Pure-PHP HS256 Twilio Video Token Signer
  • PSTN Telephone Dial-In IVR with TwiML <Conference>
  • Host-Admitted Waiting Rooms & Unguessable Slugs
  • AES-256-CBC Encryption at Rest for API Credentials
  • Chirps Persistent In-Call Chat & Emoji Reactions
Phase 2 & 3 · Active Engineering

Collaboration & Monetization

Breakout rooms, automated recording synchronization, Whisper STT transcription, and Stripe multi-tier billing.

  • Breakout Rooms Orchestration & Host Re-assignment
  • Twilio Composition API Cloud Recording Sync
  • Automated Speech-to-Text Whisper Transcription
  • Stripe Tiered Subscription Billing & Participant Quotas
  • Shared Interactive Whiteboard with PNG/PDF Export
Phase 4 · Enterprise & SDK

Enterprise SSO & Embeddable SDK

Enterprise directory synchronizations, SAML 2.0 authentication, and embeddable developer SDKs.

  • SAML 2.0 Single Sign-On: Native Okta, Azure AD, and Google Workspace SSO authentication
  • SCIM 2.0 Directory Sync: Automated employee provisioning and de-provisioning from identity providers
  • Embeddable JavaScript SDK: Single-use embed tokens and iframe API for embedding video rooms in third-party apps
  • White-Label Custom Domains: Automated SSL and custom DNS routing per tenant workspace
Behind the Build

Architecture & Code Specification

Review the core architectural abstraction contracts and cryptographic request signer engineered by Nexovex for Screen Chirp—demonstrating clean, performant, and secure software design.

<?php
namespace App\Security;

/**
 * Pure-PHP Twilio Video Access Token Generator
 * Zero Composer dependencies, eliminating over 140MB of vendor overhead.
 * Computes cryptographically valid Twilio-formatted JWTs via native OpenSSL and HMAC-SHA256.
 */
class TwilioVideoTokenGenerator {
    public static function mint(string $accountSid, string $apiKeySid, string $apiKeySecret, string $identity, string $roomName, int $ttl = 7200): string {
        $header = [
            'cty' => 'twilio-fpa;v=1',
            'typ' => 'JWT',
            'alg' => 'HS256'
        ];
        
        $now = time();
        $payload = [
            'jti'    => $apiKeySid . '-' . $now . '-' . bin2hex(random_bytes(8)),
            'iss'    => $apiKeySid,
            'sub'    => $accountSid,
            'nbf'    => $now,
            'exp'    => $now + $ttl,
            'grants' => [
                'identity' => $identity,
                'video'    => [
                    'room' => $roomName
                ]
            ]
        ];
        
        $b64Header  = self::base64UrlEncode(json_encode($header, JSON_UNESCAPED_SLASHES));
        $b64Payload = self::base64UrlEncode(json_encode($payload, JSON_UNESCAPED_SLASHES));
        $signature  = hash_hmac('sha256', $b64Header . '.' . $b64Payload, $apiKeySecret, true);
        
        return $b64Header . '.' . $b64Payload . '.' . self::base64UrlEncode($signature);
    }
    
    private static function base64UrlEncode(string $data): string {
        return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
    }
}
Engineered Results & Impact

Quantifiable Infrastructure Performance

Measurable engineering achievements delivered across runtime simplicity, token latency, voice bridge reliability, and multi-tenant isolation.

0
Node.js Daemons Required
100% Native PHP/MySQL deployable on standard LAMP & cPanel
< 55ms
Token Minting Latency
Pure-PHP HS256 computation with zero vendor SDK baggage
100%
Dial-In Audio Bridge Parity
Seamless telephone PSTN & WebRTC audio mesh convergence
AES-256
Cryptographic Isolation
Zero cross-tenant credential or meeting data leaks at rest

“Nexovex solved what every other agency told us was impossible: running an enterprise WebRTC video conferencing and voice platform on a standard PHP/MySQL environment without babysitting fragile Node.js daemons. Writing a pure-PHP JWT signer eliminated 140 megabytes of dependencies, and their Twilio Voice dial-in bridge works flawlessly for our callers on normal cell phones. An absolute masterclass in real-time software engineering.”

Delaney E.
Founder & Chief Product Officer · Screen Chirp
Ready to Engineer Your System?

Build High-Performance Communications with Nexovex

From low-latency WebRTC video meshes and PSTN telephony bridging to enterprise multi-tenant architectures, partner with senior software engineers who deliver elegant solutions to complex real-time challenges.

Pure-PHP WebRTC Signaling
PSTN Dial-In Voice Bridging
Zero-Daemon Architecture
Enterprise AES-256 Cryptography