From Black Box to Clear Visibility: Building a CloudWatch Dashboard for Jitsi Meet

At Certible, we conduct certification exams worldwide, and reliable video conferencing is mission-critical. When participants join an exam session, everything needs to work flawlessly.

We chose Jitsi Meet as our open-source video conferencing solution, but like many self-hosted services, it started as somewhat of a black box. When issues arose, we were flying blind, scrambling through logs trying to understand what went wrong.

That’s when we decided to build comprehensive monitoring – and eventually contributed it back to the community as @certible/jitsi-aws-cdk ⤴.

The Challenge: Monitoring a Complex Video System

Jitsi Meet isn’t just one service – it’s an ecosystem:

• Jitsi Web: The frontend interface users interact with

• Jicofo: The conference focus component that manages sessions

• Jibri: Recording and streaming service for exam documentation

• JVB (Jitsi Videobridge): Handles the actual video/audio routing

• Prosody: XMPP server for signaling

Each component generates different types of logs, has unique failure modes, and affects the user experience in different ways. Without proper monitoring, troubleshooting felt like detective work with missing clues.

Our Solution: Infrastructure as Code Monitoring

Rather than building dashboards manually through the AWS console (which doesn’t scale or version well), we created a CDK construct that programmatically builds CloudWatch dashboards with pre-configured widgets for each Jitsi component.

Here’s how we integrated it into our infrastructure:

import { JitsiCloudWatchDashboard } from '@certible/jitsi-aws-cdk';

export class ConferenceStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props: cdk.StackProps) {
    super(scope, id, props);
    
    // Create the dashboard
    const jitsiDashboard = new JitsiCloudWatchDashboard(this, 'ExamDashboard', {
      dashboardId: 'certible-jitsi-monitoring',
    });

    // Add monitoring for each service
    const logGroupName = '/aws/ecs/jitsi-meet';
    jitsiDashboard.addWeb(logGroupName);      // Frontend monitoring
    jitsiDashboard.addJicofo(logGroupName);   // Conference management
    jitsiDashboard.addJibri(logGroupName);    // Recording service
    jitsiDashboard.addJvb(logGroupName);      // Video bridge
  }
}

Getting Logs from Docker to CloudWatch

The key was configuring our Jitsi services to send logs to CloudWatch using the AWS logs driver. Here’s our docker-compose configuration:

services:
  web:
    image: jitsi/web:latest
    logging:
      driver: awslogs
      options:
        awslogs-group: ${AWSLOGS_GROUP}
        awslogs-region: eu-central-1
        tag: '{{ with split .ImageName ":" }}{{join . "_"}}{{end}}-{{.ID}}'

This setup automatically forwards all container logs to CloudWatch with consistent naming patterns, making them easy to query and visualize.

What We Can See Now

Our dashboard provides instant visibility into:

• Participant join/leave patterns

• Connection failure rates

• Jibri recording start/stop events

• and more

Why We Open-Sourced It

Jitsi is an amazing open-source project, but monitoring shouldn’t be an afterthought. We realized other organizations running Jitsi on AWS could benefit from our approach.

The construct handles the complexity of:

• Log parsing patterns for each Jitsi component

• Widget configurations optimized for video conferencing metrics

• Consistent naming and organization

• TypeScript types for better developer experience

Flexible Implementation

You don’t have to use our full construct – individual widget functions are available as standalone utilities:

import { jitsiWidgetsJibri } from '@certible/jitsi-aws-cdk';
import { Dashboard } from 'aws-cdk-lib/aws-cloudwatch';

const myDashboard = new Dashboard(this, 'CustomDashboard');
jitsiWidgetsJibri(myDashboard, '/aws/ecs/jitsi-meet');

This flexibility means you can integrate Jitsi monitoring into existing dashboards or customize the widgets for your specific needs.

The Bigger Picture

Good monitoring transforms operations from reactive firefighting to proactive service management. When your video conferencing affects real people’s careers (like certification exams), visibility isn’t optional.

By packaging our monitoring approach as reusable infrastructure code, we’re helping other teams avoid the same blind spots we experienced.