Today, we're giving you a sneak peek at the solution. Introducing plugNmeet's Hybrid Integration, a powerful new way to build a custom, self-hosted video conferencing app for iOS, Android, Flutter, React Native, or desktop. It combines the raw power of native media handling with the complete, feature-rich plugNmeet web client, giving you an accelerated path to launching your own white-label video app.

A quick note on our philosophy: plugNmeet's core focus has always been on delivering a powerful, browser-first video conferencing experience. We are not shifting to become an app-first company. Instead, this hybrid integration is our answer to the many developers in our community who need to build native mobile or desktop applications.

You might be wondering why we didn't create our own dedicated mobile SDK. The answer is simple: we don't need to! plugNmeet is built on LiveKit, which already provides robust native SDKs for every major platform, including Android, React Native, and Flutter. Our hybrid approach leverages these battle-tested LiveKit SDKs for native media publishing, combined with our feature-rich web client in a WebView. This means you get the best of both worlds: ready-to-use native media capabilities and plugNmeet's comprehensive UI, all without us having to duplicate effort. We are providing a robust, flexible pathway for you to build your own app, your way, without compromising on the self-hosted, open-source principles that define plugNmeet.

The Best of Both Worlds: Native Power, Web Simplicity​

The hybrid model is a game-changer for developers who need more than just a generic, third-party meeting link. It gives you the flexibility of native development and the speed of using the existing plugNmeet meeting UI.

Here’s why this is such a big deal:

• Native Media Performance: Capture and publish media using platform-native APIs. This is a must-have for features like mobile screen sharing, which is not supported by most mobile browsers. It also opens the door for advanced features like native virtual backgrounds or custom audio processing.
• Faster App Development: Your team can focus on building the native shell and core application experience. You don't have to spend months recreating participant lists, chat, a whiteboard, moderation controls, and complex video layouts. We’ve already built that for you.
• True White-Label Customization: You control the entire user experience, from the app icon and login screen to the in-meeting branding. The meeting feels like a core part of your application, not a bolted-on third-party service.
• Self-Hosted and Secure: As always with plugNmeet, you own your infrastructure and your data. All communications are routed through your on-premise server, ensuring maximum privacy, compliance, and control.

How It Works: An Elegant Architecture​

The core idea is simple yet powerful: one logical user is represented by two participants connected to your self-hosted LiveKit instance.

• The web participant runs in a WebView inside your app. It handles the entire user interface and subscribes to all media streams from other users.
• The native participant runs in your native app code. Its only job is to capture and publish the user's own camera, microphone, and screen share using native APIs.

A lightweight communication "bridge" allows the web UI and the native code to communicate seamlessly. When a user taps the "Mute" button in the web interface, a message is sent across the bridge, telling your native code to mute the microphone. This architecture provides a seamless user experience while giving you the performance benefits of native code.

Get a Head Start on Your Custom Video App​

While the official release is just around the corner, you can start building today. We believe in building in the open, and we're excited to see what our community creates.

Ready to build your own video conferencing app?

• Explore the Technical Guide for a deep dive into the architecture and API.
• Check out the Demo Apps on GitHub to see the pattern in action.
• Try the Live Demo to explore plugNmeet's features.
• Follow our Installation Guide to get your self-hosted server running.

With this integration, you can bring powerful AI features to your self-hosted video conferencing server, including live transcription, real-time translation, live chat translation, spoken translations using text-to-speech, AI meeting summaries, and an in-meeting AI chatbot.

Even better, the provider is designed around the standard OpenAI API format, which means you can use OpenAI directly or connect plugNmeet to any OpenAI-compatible API, including alternative AI providers and self-hosted LLM platforms.

Why This Matters for Self-Hosted Video Conferencing​

AI features are becoming essential for modern online meetings. Teams increasingly expect searchable transcripts, multilingual communication, automated summaries, and intelligent meeting assistants.

However, many hosted video conferencing platforms lock these features behind proprietary services. plugNmeet takes a different approach.

With the OpenAI provider, you can choose the AI backend that best fits your needs:

• Use OpenAI for high-quality managed AI services.
• Use Azure OpenAI or another cloud provider with an OpenAI-compatible interface.
• Use Groq, Together AI, Anyscale, or another compatible API provider.
• Use Ollama, LocalAI, or another self-hosted LLM platform for more control over privacy and infrastructure.
• Optimize your setup for cost, performance, latency, compliance, or data ownership.

This makes plugNmeet a strong choice for organizations that want AI-powered video conferencing without giving up control of their infrastructure.

Key Features of the plugNmeet OpenAI Provider​

By enabling the OpenAI provider in plugNmeet, you can unlock a full set of AI-powered meeting features.

Live Transcription​

The OpenAI provider supports real-time speech-to-text through a WebSocket-based connection. This enables low-latency transcription during live meetings.

Live transcription is useful for:

• Accessibility
• Meeting notes
• Searchable conversation history
• Real-time translation workflows
• Post-meeting summaries

Real-Time Multilingual Translation​

plugNmeet can translate finalized transcription text during the meeting. This helps participants communicate across languages and reduces language barriers in international meetings, online classes, webinars, and remote team discussions.

Spoken Translations with Text-to-Speech​

The integration also supports spoken translations using text-to-speech. A translator bot can join the meeting and speak translated content aloud using an AI-generated voice.

This is especially useful for:

• Multilingual events
• Remote classrooms
• Global team meetings
• Cross-border business calls
• Accessibility-focused deployments

Live Chat Translation​

The OpenAI provider can also translate chat messages in real time. This allows participants from different linguistic backgrounds to communicate seamlessly through text chat, making meetings more inclusive and productive. Each user can select their preferred language and view translated messages instantly.

Automated Meeting Summarization​

After a meeting ends, plugNmeet can generate a concise AI-powered summary from the meeting transcript.

Summaries can include:

• Key discussion points
• Important decisions
• Action items
• Follow-up tasks
• Meeting outcomes

This helps users save time and makes recorded meetings easier to review.

In-Meeting AI Chatbot​

The OpenAI provider can also power an AI chatbot inside plugNmeet conference rooms. Participants can interact with the assistant during the meeting for contextual help, questions, and AI-powered support.

How to Configure OpenAI in plugNmeet​

Configuring the OpenAI integration on your self-hosted server is straightforward. All you need is an active API key and a quick update to your config.yaml.

1. Define Your Provider Account​

Add your provider account under the insights.providers section:

insights:
  enabled: true
  providers:
    openai:
      - id: "default-openai" # A unique name for this account
        credentials:
          api_key: "YOUR_API_KEY"
        options:
          # This is the magic key for compatibility! For local LLMs (Ollama), use e.g. "http://localhost:11434/v1"
          endpoint: "https://api.openai.com/v1"

Beyond OpenAI: Universal API Compatibility​

The endpoint option is your gateway to a universe of AI providers. Because our integration is built on the standard OpenAI API specification, you can use any service that offers an OpenAI-compatible API.

This means you are not locked into a single vendor. You can point plugNmeet to:

• Alternative AI Providers: Services like Groq, Together AI, or Anyscale.
• Self-Hosted Open Source Models: Run your own LLMs locally using tools like Ollama or LocalAI.
• Major Cloud Providers: Use services like Azure OpenAI which provide a compatible API layer.

This flexibility allows you to optimize for cost, privacy, and performance without changing your plugNmeet setup.

Important: Enabling Live Transcription Translation​

One of the most powerful features is the ability to translate live transcriptions in real time. To enable this, there is a crucial dependency to be aware of:

You must have both the transcription and translation services configured and enabled.

The translation process works by taking the finalized text from the transcription service and passing it to the language model configured in the translation service. Without the translation configuration, the system won't know which model to use for the translation task, and it will fail silently.

Therefore, a minimal setup for live transcription with translation would look like this:

services:
  transcription:
    provider: "openai"
    id: "default-openai"

  translation:
    provider: "openai"
    id: "default-openai"
    options:
      # This model will be used for real-time transcription and chat translation.
      model: "gpt-5.4-mini"
      max_selected_trans_langs: 5

Complete Service Configuration Examples​

Here is a comprehensive guide to all the services and their available options. You can uncomment and adjust them to fine-tune the behavior.

services:
  # Service 1: Live Transcription (Real-time Speech-to-Text)
  # This service uses a real-time WebSocket API for live audio streams.
  transcription:
    provider: "openai"
    id: "default-openai"
    options:
      # The model for real-time transcription.
      realtime_transcription_model: "gpt-realtime-whisper"
      #
      # --- Advanced Customization (Optional) ---
      #
      # Use a custom authentication header if your provider (like Azure)
      # expects something other than the default 'Authorization' header.
      # realtime_auth_header: "api-key"
      #
      # Latency vs. accuracy tradeoff for gpt-realtime-whisper.
      # Supported values: "minimal", "low", "medium", "high", "xhigh".
      # transcription_delay: "medium"
      #
      # Voice Activity Detection (VAD) mode. For gpt-realtime-whisper,
      # this should effectively be 'manual', where plugNmeet commits audio.
      # Other modes like 'server_vad' may be supported by other models.
      # transcription_turn_detection: "manual"
      #
      # Fine-tune the 'manual' VAD behavior.
      # transcription_min_commit_ms: 1500       # Min duration of speech to be a valid segment.
      # transcription_silence_commit_ms: 900    # Silence duration that triggers a final transcript.
      # transcription_max_commit_ms: 12000      # Max duration of a segment before forcing a final transcript.
      # transcription_speech_rms: 500           # Audio level (RMS) threshold to detect speech.
      # transcription_max_buffered_silence_ms: 400 # Pre-speech silence to include for better context.

  # Service 2: Real-time and Chat Translation
  translation:
    provider: "openai"
    id: "default-openai"
    options:
      # The model to use for translating text (from chat or transcriptions).
      model: "gpt-5.4-mini"
      #
      # --- Advanced Customization (Optional) ---
      #
      # Maximum number of languages a user can select for translation.
      # max_selected_trans_langs: 5

  # Service 3: Text-to-Speech (TTS) for Spoken Translations
  speech-synthesis:
    provider: "openai"
    id: "default-openai"
    options:
      # The TTS model to use (e.g., "tts-1", "tts-1-hd").
      model: "gpt-4o-mini-tts"
      #
      # --- Advanced Customization (Optional) ---
      #
      # OpenAI's TTS models require a 24000Hz sample rate. This is set
      # automatically but can be overridden if your provider requires a different rate.
      # tts_sample_rate: 24000
      #
      # The default voice to use if a language-specific one isn't set.
      # Voices: alloy, echo, fable, onyx, nova, shimmer.
      # default_voice: "alloy"
      #
      # Assign specific voices to different languages.
      # voice-en: "alloy"
      # voice-es: "nova"
      # voice-fr: "shimmer"

  # Service 4: AI-Powered Chat
  ai_text_chat:
    provider: "openai"
    id: "default-openai"
    options:
      # This model is used for the in-meeting AI assistant.
      chat_model: "gpt-5.4"
      #
      # --- Advanced Customization (Optional) ---
      #
      # The model used to summarize chat history when the context window is full.
      summarize_model: "gpt-5.4-mini"
      #
      # Number of recent messages to keep in memory before summarizing.
      # context_window: 5

  # Service 5: Post-Meeting Summarization (Batch Audio File)
  # This service transcribes a recorded audio file and then summarizes it.
  meeting_summarizing:
    provider: "openai"
    id: "default-openai"
    options:
      # The model for the initial audio-to-text transcription.
      transcription_model: "gpt-4o-transcribe"
      #
      # --- Advanced Customization (Optional) ---
      #
      # The model for the final summarization of the transcript.
      summarize_model: "gpt-5.4-mini"

A More Intelligent and Open Future​

The new OpenAI provider is a powerful addition to the plugNmeet Insights framework, offering more choice, flexibility, and intelligence than ever before. By embracing the OpenAI API standard, we're giving you the freedom to choose the best tools for the job—whether that's OpenAI's own models, a major cloud service like Azure, or a self-hosted solution.

Ready to build your own video conferencing platform?

• Follow our Installation Guide to get your self-hosted server running in minutes.
• Try the Live Demo to explore the features.

Until now, solving these challenges often required modifying the core application code, making updates difficult and maintenance a chore.

Today, we're thrilled to announce a powerful new feature that changes everything: Scripting and Storage Hooks. This new mechanism allows you to extend and customize plugNmeet's media workflow by executing your own custom scripts—either as efficient, long-lived processes or simple one-shot commands—at key stages. All communication happens via newline-delimited JSON over standard I/O, so you can integrate your own logic without touching a single line of the core code.

Why Hooks? The Power of a Decoupled Architecture​

So, why is this a game-changer? Hooks allow you to decouple your business logic from the application's logic. Instead of being locked into local disk storage, you can now integrate with virtually any external service.

Here’s what you can do with hooks:

• Integrate Any Storage Provider: Use AWS S3, Google Cloud Storage, Backblaze, MinIO, or even a custom FTP server. If you can write a script for it, you can use it.
• Automate Custom Workflows: Automatically send a Slack notification when a recording is processed, call a CRM API with meeting analytics, or trigger a video indexing service.
• Enable Complex, Scalable Deployments: In a multi-server cluster, hooks are essential. A recorder node can automatically upload a raw recording to a central S3 bucket, and a separate transcoder node can be triggered to download it, process it, and re-upload the final MP4.
• Future-Proof Your Setup: Your storage strategy can evolve without being tied to the plugNmeet release cycle.

How It Works: Core Concepts​

The new system is divided into two distinct but related mechanisms: Recorder Hooks and Server Storage Hooks. Before diving into the specifics, let's cover the core concepts that apply to all hooks.

Execution Models: Long-Lived vs. One-Shot​

For maximum flexibility, you can run your hooks in two ways:

• Long-Lived Processes (Recommended): Your script is launched once and runs continuously, listening for requests on stdin. This is highly efficient as it avoids process startup overhead for every event.
• One-shot Commands: For simpler tasks, you can execute a command for each event. This is great for curl, wget, or the built-in utility.

Speaking of which, we've included a handy one-shot command to simplify calling external APIs:

• Built-in http-request Utility: A simple command for sending the hook's JSON payload to an HTTP/HTTPS endpoint.
  • Usage: http-request <URL>

The Pipeline Model​

If you define multiple scripts for a single hook, they form a pipeline. The stdout response from the first script becomes the stdin request for the second, and so on. If a script in the chain doesn't need to modify the data, it must still pass the original, unmodified JSON object through to stdout.

Communication Protocol​

• stdin: Your script must read from stdin in a loop. Each line it reads will be a complete JSON object representing a single request from the plugNmeet component.
• stdout: For each request it receives, your script MUST print a single line of JSON to stdout. This line is the response.
• stderr: You can use stderr for logging within your script. This output is ignored by plugNmeet but is invaluable for debugging your custom logic.

Error Handling​

If your script encounters an error, it should populate the error field in its JSON response to stdout. The main application will log this error. It is crucial to always return the complete input JSON object, with the error field populated, to ensure subsequent scripts in a pipeline receive the expected data structure.

If the response is not valid JSON, plugNmeet logs a warning and discards the output. The original JSON data (the stdin to your script) is passed to the next script in the pipeline. This prevents a single faulty script from breaking the entire chain.

Server Hooks: Managing Artifacts and Downloads​

These hooks are designed to manage how the main plugNmeet server handles files, primarily the various room artifacts and user-facing downloads.

• upload_hook: Triggered when the server creates an artifact (e.g., a meeting analytics file). Your script takes the local file (input_path) and uploads it to your provider, returning a unique output_path that tells the server how to find it later.
• download_hook: Triggered when a user requests to download an artifact or a recording. Your script receives the file's identifier (input_path) and tells the server how to proceed (e.g., by providing a redirect_url or a serve_local path).
• delete_hook: Triggered when a file needs to be removed. Your script receives the file's identifier (input_path) and handles the deletion from your external storage.
• resumable_upload_hook: Handles chunked file uploads for the chat feature. Your script manages checking, uploading, and merging file parts, which is ideal for offloading to services like S3 Multipart Upload.
• room_end_hook: Performs cleanup tasks after a room session ends, such as cleaning up any abandoned resumable upload chunks.

The recommended approach for downloads is to return a temporary, pre-signed URL (action: "redirect"). This way, the user downloads the file directly from your storage provider (e.g., S3), and the traffic doesn't even hit your plugNmeet server, saving you bandwidth and resources.

Recorder Hooks: Automating the Recording Pipeline​

These hooks give you control over the recording and transcoding pipeline. While there are hooks for every stage (post_recording, pre_transcoding, post_transcoding), the most common use case is managing the final, processed file.

Example 1: Full S3 Integration for Server Hooks​

Let's walk through a real-world example of integrating S3 for all server-side file management using Node.js. With these three scripts, you have a complete, robust, and scalable storage solution for your plugNmeet server.

Project Setup​

mkdir plugnmeet-hooks
cd plugnmeet-hooks
npm init -y
npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner

Server Configuration (server/config.yaml)​

hooks:
  upload_hook:
    pool_size: 2 # Optional: controls parallel execution
    scripts:
      - script: "/path/to/plugnmeet-hooks/upload.js"
        is_one_shot: false # This is a long-lived script
  download_hook:
    scripts:
      - script: "/path/to/plugnmeet-hooks/download.js"
        is_one_shot: false
  delete_hook:
    scripts:
      - script: "/path/to/plugnmeet-hooks/delete.js"
        is_one_shot: false
  room_end_hook:
    scripts:
      - script: "http-request http://localhost:8090/room-ended-notification"
        is_one_shot: true

The Upload Script (upload.js)​

This script uploads server-generated artifacts (like analytics) to S3.

#!/usr/bin/env node
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { createReadStream, unlinkSync } from "fs";
import { basename } from "path";
import readline from "readline";

const s3Client = new S3Client({ region: "us-east-1" });
const BUCKET_NAME = "my-plugnmeet-artifacts"; // A bucket for artifacts
const log = (message) => console.error(`S3Upload: ${message}`);

const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });

log("S3 artifact upload hook script started.");

rl.on("line", async (line) => {
  let request;
  try {
    request = JSON.parse(line);
    const { input_path, room_id } = request;
    const output_path = `artifacts/${room_id}/${basename(input_path)}`;

    const command = new PutObjectCommand({ Bucket: BUCKET_NAME, Key: output_path, Body: createReadStream(input_path) });
    await s3Client.send(command);
    log(`Successfully uploaded to ${output_path}`);

    try {
      unlinkSync(input_path);
      log(`Cleaned up local file: ${input_path}`);
    } catch (cleanupError) {
      log(`Error cleaning up file: ${cleanupError.message}`);
    }

    request.output_path = output_path;
    process.stdout.write(JSON.stringify(request) + "\n");
  } catch (e) {
    log(`Error: ${e.message}`);
    const errorResponse = request ? { ...request, error: e.message, output_path: "" } : { error: `JSON parse error: ${e.message}` };
    process.stdout.write(JSON.stringify(errorResponse) + "\n");
  }
});

The Download Script (download.js)​

This script is triggered when a user needs to access a file. It receives the S3 key in input_path and generates a temporary, secure, pre-signed URL for the user to download the file directly from S3.

#!/usr/bin/env node
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import readline from "readline";

const s3Client = new S3Client({ region: "us-east-1" });
const BUCKET_NAME = "my-plugnmeet-artifacts"; 
const log = (message) => console.error(`S3Download: ${message}`);

const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });

log("S3 download hook script started.");

rl.on("line", async (line) => {
  let request;
  try {
    request = JSON.parse(line);
    const { input_path } = request;

    // Note: You might have different buckets for artifacts and recordings.
    // A real-world script would have logic to determine the correct bucket.
    const bucket = input_path.startsWith("recordings/") ? "my-plugnmeet-recordings" : BUCKET_NAME;

    const command = new GetObjectCommand({
      Bucket: bucket,
      Key: input_path,
    });

    const redirect_url = await getSignedUrl(s3Client, command, { expiresIn: 3600 });
    log(`Generated pre-signed URL for ${input_path}`);

    request.action = "redirect";
    request.redirect_url = redirect_url;
    process.stdout.write(JSON.stringify(request) + "\n");
  } catch (e) {
    log(`Error: ${e.message}`);
    const errorResponse = request ? { ...request, error: e.message } : { error: `JSON parse error: ${e.message}` };
    process.stdout.write(JSON.stringify(errorResponse) + "\n");
  }
});

The Delete Script (delete.js)​

This script handles the removal of a file from your S3 bucket when it's deleted from plugNmeet.

#!/usr/bin/env node
import { S3Client, DeleteObjectCommand } from "@aws-sdk/client-s3";
import readline from "readline";

const s3Client = new S3Client({ region: "us-east-1" });
const BUCKET_NAME = "my-plugnmeet-artifacts";
const log = (message) => console.error(`S3Delete: ${message}`);

const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });

log("S3 delete hook script started.");

rl.on("line", async (line) => {
  let request;
  try {
    request = JSON.parse(line);
    const { input_path } = request;

    const bucket = input_path.startsWith("recordings/") ? "my-plugnmeet-recordings" : BUCKET_NAME;

    const command = new DeleteObjectCommand({
      Bucket: bucket,
      Key: input_path,
    });

    await s3Client.send(command);
    log(`Successfully deleted ${input_path}`);

    request.msg = "File deleted successfully";
    process.stdout.write(JSON.stringify(request) + "\n");
  } catch (e) {
    log(`Error: ${e.message}`);
    const errorResponse = request ? { ...request, error: e.message } : { error: `JSON parse error: ${e.message}` };
    process.stdout.write(JSON.stringify(errorResponse) + "\n");
  }
});

Example 2: Completing the Workflow with a Recorder Hook​

Now, let's create the most important script for the recording workflow: the post_transcoding hook. In many setups, you only need to act after the final MP4 is ready. This hook runs on the recorder/transcoder node and is perfect for uploading the final file to its permanent storage location.

Recorder Configuration (recorder/config.yaml)​

hooks:
  post_transcoding:
    scripts:
      - script: "/path/to/plugnmeet-hooks/post-transcoding-upload.js"
        is_one_shot: false

The Post-Transcoding Upload Script (post-transcoding-upload.js)​

This script runs after a recording has been successfully transcoded to MP4. It receives the path to the final MP4 on the local disk via input_path, uploads it to a permanent S3 bucket, and returns the S3 object key in output_path for the server to store.

#!/usr/bin/env node
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { createReadStream, unlinkSync } from "fs";
import readline from "readline";

const s3Client = new S3Client({ region: "us-east-1" });
const BUCKET_NAME = "my-plugnmeet-recordings"; // Use a dedicated bucket for recordings
const log = (message) => console.error(`PostTranscoding: ${message}`);

const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });

log("Post-transcoding upload hook started.");

rl.on("line", async (line) => {
  let request;
  try {
    request = JSON.parse(line);
    log(`Received request: ${JSON.stringify(request)}`);

    // In the post_transcoding stage, `input_path` contains the path to the final MP4 on the local disk.
    const { input_path, file_name } = request;
    
    // Use the canonical file_name from the hook data to construct the final S3 key.
    const final_s3_key = `recordings/${file_name}`;

    const command = new PutObjectCommand({
      Bucket: BUCKET_NAME,
      Key: final_s3_key,
      Body: createReadStream(input_path),
      ContentType: "video/mp4",
    });

    await s3Client.send(command);
    log(`Successfully uploaded to ${final_s3_key}`);

    // This script is responsible for cleaning up the local MP4 file it was given.
    try {
      unlinkSync(input_path);
      log(`Cleaned up local transcoded file: ${input_path}`);
    } catch (cleanupError) {
      log(`WARN: Failed to clean up local file: ${cleanupError.message}`);
    }

    // Set the final S3 key in `output_path` for the server to store in the database.
    request.output_path = final_s3_key;
    
    process.stdout.write(JSON.stringify(request) + "\n");
  } catch (e) {
    log(`ERROR: ${e.message}`);
    const errorResponse = request ? { ...request, error: e.message, output_path: "" } : { error: `JSON parse error: ${e.message}` };
    process.stdout.write(JSON.stringify(errorResponse) + "\n");
  }
});

Get Started Today​

This new hooking system opens up a world of possibilities for automation and advanced, cloud-native architectures. It’s designed for developers and system administrators who want to build a truly custom, scalable, and robust video conferencing platform.

Ready to dive in? Check out our new, comprehensive Scripting & Storage Hooks Documentation for detailed technical specifications, payload structures, and more examples.

We can't wait to see the incredible workflows you build!

Ready to build your own video conferencing platform?

• Follow our Installation Guide to get your self-hosted server running in minutes.
• Try the Live Demo to explore the features.

Today, we are excited to launch the all-new, deeply integrated plugNmeet plugin for WordPress. This plugin is your gateway to transforming any WordPress page or post into a powerful, self-hosted video conferencing room.

More Than Just a Meeting—It's Part of Your Site​

While our original plugin allowed you to launch your own no-code video conferencing service, this new version is a major leap forward, rebuilt from the ground up for an even deeper and more seamless integration. We focused on a user experience that feels like a native part of WordPress, both for you as the administrator and for your site visitors. From creating rooms in the backend to managing post-session artifacts, every tool you need is right where you'd expect it—inside your WordPress dashboard.

Let's explore the features that make this plugin the ultimate solution for self-hosted video conferencing on WordPress.

Seamless Integration and Powerful Management​

We built this plugin to be incredibly easy to use while offering the powerful features our users love.

• Embed Anywhere with Shortcodes: Once you create a room, the plugin gives you a simple shortcode (e.g., [plugnmeet_room_view id="your_room_id"]). Paste it into any page, post, or even a widget, and you have a live meeting room. It works flawlessly with the classic editor, Gutenberg, and popular page builders.
• Clean, Shareable URLs: Want a clean, professional link to share for your meetings? The plugin allows you to set a "Host Page," giving every room its own dedicated URL like yoursite.com/meetings/your-room-id/. This is perfect for direct sharing in emails or social media.
• Full Backend Control: Manage everything from your WordPress admin area. The Plug-N-Meet > Rooms page is your command center to create, edit, and configure rooms, as well as access all post-session assets.

Effortless Recording Management with Merging​

Managing your session recordings is now more powerful than ever. If a session was stopped and restarted, you no longer have to deal with multiple video files. Our new Merge Recordings feature allows you to select multiple video segments and combine them into a single, continuous MP4 file directly from the WordPress backend. It’s a simple, intuitive way to create a polished, final version of your recording for distribution.

The New Artifacts Menu: Analytics and AI at Your Fingertips​

We've introduced a dedicated Artifacts menu for each room, centralizing all the valuable data your sessions produce. This is where you'll find:

• Actionable Classroom Analytics: Go beyond simple participant counts. Download comprehensive Excel reports detailing participant engagement, talk time, connection quality, and more. Use this data to understand your audience and improve your presentations, turning raw numbers into pedagogical insights. For a deeper dive, see our guide on Classroom Analytics for Educators.
• AI-Powered Summaries & Transcripts: Access and download meeting summaries and full speech-to-text transcription files generated by our AI Meeting Assistant. For more on our AI capabilities, see our guide on how to add an AI meeting assistant.

Built for Customization and Control​

We believe in giving you full control over your platform.

• 100% White-Label Experience: The meeting room loads directly within your WordPress site's design. There are no third-party logos or branding. It's your meeting, on your website. For a deeper dive into customization, read our deep integration and white-label guide.
• Granular, Role-Based Permissions: The plugin leverages standard WordPress user roles to give you fine-grained control. In the room settings, you can define exactly which roles can join as moderators versus attendees, and who gets access to view, download, or manage recordings.
• Theme Developer Friendly: For those who need to customize the front-end display, the plugin features a powerful template overriding system. Developers can copy template files from the plugin into their own theme directory to safely modify the HTML structure, from minor tweaks to a complete redesign.
• Extend with Webhooks: The plugin fires a plugnmeet_webhook_data action hook, allowing developers to easily process real-time meeting data. Use it to build custom logging, send data to a CRM, or create unique workflows. Learn more in our guide to building workflows with webhooks.

Ready to bring your meetings home to your WordPress site?

• Download the official WordPress Plugin
• Try the Live Demo to explore the features.
• Follow our Installation Guide to get your self-hosted server running in minutes.

Plug-N-Meet's API-first approach, combined with its robust RTMP broadcasting capabilities and the new room/broadcastToRoom API, provides the perfect solution. This guide will show you how to build a custom, curated Q&A system that allows your audience to submit questions through your own platform, which are then seamlessly delivered to your webinar host in real-time.

The Power of RTMP Broadcasting for Professional Webinars​

For webinars that demand high production value and reach a large audience, RTMP (Real-Time Messaging Protocol) broadcasting is the gold standard. It allows you to broadcast your Plug-N-Meet session directly to platforms like YouTube, Facebook, or your own website. This session, which includes all participants, screen shares, and whiteboards, becomes your "broadcast studio," ensuring a high-quality experience for thousands of viewers.

This "Broadcast Studio Model" is ideal for hosting large-scale events. The meeting itself is private to your hosts and presenters, but the output is streamed publicly.

The Q&A Dilemma: Why Standard Chat Falls Short​

In a large webinar, the public chat can quickly become a firehose of comments, greetings, and questions. While great for general interaction, it's a poor tool for managing a structured Q&A session. Important questions get buried, and the host can easily miss critical inquiries.

A custom Q&A system, integrated directly into your website or application, offers several advantages:

• Moderation: Questions can be reviewed and approved before reaching the host.
• Prioritization: Important questions can be highlighted or reordered.
• Branding: The Q&A experience is seamlessly integrated into your platform.
• Control: You dictate the flow and presentation of questions.

Building Your Custom Q&A System with room/broadcastToRoom​

This is where the new room/broadcastToRoom API becomes invaluable. It allows your custom backend system to send messages directly into an active Plug-N-Meet room, appearing as if they came from a participant.

Here's the concept:

1. Audience Submission: Your audience watches the RTMP stream on your website. On the same page (or a linked one), they see a custom form to submit questions.
2. Backend Moderation: These questions are sent to your custom backend, where a moderator can review, edit, or approve them.
3. API Injection: Once a question is approved, your backend uses the room/broadcastToRoom API to send it as a chat message directly to the host (or all admins) within the Plug-N-Meet broadcast studio room.

How the room/broadcastToRoom API Works for Q&A​

The room/broadcastToRoom API allows you to send either a chat_msg or a notification_msg. For Q&A, we'll use the chat_msg payload. You can target specific users (like your host) or all admins.

Endpoint: /room/broadcastToRoom

Key Parameters for Q&A:

• room_id: The ID of your Plug-N-Meet broadcast studio room.
• only_to_admins: Set to true to ensure only your host(s) and co-hosts see the questions.
• chat_msg.message: The actual question text.
• chat_msg.to_user_id (Optional): If you want to send the question to a specific host, you can use their user_id.

Step-by-Step Implementation Idea​

Let's outline how you can set this up:

Step 1: Set up Your Plug-N-Meet Webinar Room Create your Plug-N-Meet room via the Create Room API, ensuring RTMP is enabled. This will be your private "broadcast studio" where your presenters and production team will gather.

Step 2: Configure RTMP Broadcast To broadcast your webinar to a public audience, the moderator can initiate the live stream from within the Plug-N-Meet room.

1. Open the More Options menu (...) in the footer control bar and select Start Live Stream.
2. Enter the Stream Key and Stream URL provided by your streaming platform (e.g., YouTube, Facebook).
3. Click Start Streaming to begin broadcasting the session.

Step 3: Develop Your Custom Q&A Frontend (Audience-Facing) Create a simple web form on your website where your audience can type and submit their questions. This form will send the questions to your custom backend server.

Step 4: Implement Your Q&A Backend (Moderation & API Call) This is the core of your custom system:

1. Receive Questions: Your backend receives questions from the audience-facing form.
2. Moderation Dashboard: Build a simple dashboard for your Q&A moderator. Here, they can see incoming questions, approve/reject them, and perhaps reorder them.
3. Call room/broadcastToRoom: When the moderator approves a question, your backend makes an API call to Plug-N-Meet's room/broadcastToRoom endpoint.

Example JSON Payload for your Backend's API Call to Plug-N-Meet:

{
  "room_id": "your-webinar-studio-room-id",
  "only_to_admins": true,
  "chat_msg": {
    "message": "Audience Question: [Approved Question Text Here]"
  }
}

This will deliver the approved question directly into the chat panel of your Plug-N-Meet broadcast studio, visible only to your host(s) and admins. Your host can then read the question aloud or respond as appropriate.

Benefits of this Approach​

• Curated Q&A: Only approved questions reach the host, maintaining professionalism.
• Reduced Distraction: The host can focus on the presentation without a constantly scrolling public chat.
• Enhanced Control: You have full control over the Q&A process, from submission to delivery.
• Branded Experience: The audience interacts with your custom platform, reinforcing your brand.
• Flexibility: You can extend your custom Q&A system with features like upvoting, categorization, or even AI-powered question clustering.

Conclusion: Your Webinar, Your Rules​

Plug-N-Meet's API-first architecture empowers you to go beyond off-the-shelf solutions and design truly bespoke webinar experiences. By combining professional RTMP broadcasting with a custom Q&A system powered by the room/broadcastToRoom API, you can deliver highly engaging, moderated, and branded webinars that stand out.

Stop letting generic tools dictate your audience interaction. Start building a webinar experience that's uniquely yours.

Ready to build your custom Q&A webinar?

• Explore the room/broadcastToRoom API Documentation
• Discover how to host large-scale events
• Check out our API Documentation to start building.

Today, we're excited to solve this problem with the introduction of the /recording/mergeRecordings API—a powerful new tool designed to consolidate multiple recording files into a single, seamless video. This feature is a must-have for anyone running a self-hosted video conference server and looking to provide a polished, professional experience.

The Problem: Fragmented Recordings​

Imagine you're hosting a three-hour workshop on your video call server. You pause the recording during a 15-minute break and then resume it. Or perhaps you have to restart a recording due to a technical issue. At the end of the session, you have two or more separate video files.

This creates a disjointed experience for anyone watching the replay. It also creates extra work for administrators who have to manually download, edit, and re-upload the files to create a single, coherent video.

The Solution: The mergeRecordings API​

The mergeRecordings API automates this entire process. It allows you to programmatically combine multiple recording files from a session into one continuous video. The original files are kept intact, and a new, merged recording is created with its own unique record_id.

This process happens asynchronously in the background, so it doesn’t tie up your system. You simply make the API request, and when the merge is complete, your application receives a webhook notification (recording_proceeded) with the details of the new, unified recording file.

Use Case Spotlight: Seamless Merging in our Moodle Video Conference Plugin​

This isn't just a theoretical feature—it's already enhancing our official Plug-N-Meet Moodle Plugin. As a leading moodle video conference plugin, we believe in providing seamless workflows for educators.

The Scenario: A teacher conducts a long class and records it in two parts. After the session, they see both recordings listed in their Moodle activity.

The Old Way: The teacher would have to instruct students to watch both videos in order, or manually download and edit them together.

The New Way with the API:

1. The teacher navigates to the "Recordings" tab in their Moodle course activity.
2. They select the recordings they want to combine.
3. They click a "Merge" button directly within the Moodle interface.
4. The Moodle backend calls the mergeRecordings API.
5. A short time later, a new, single recording file automatically appears in the list, ready for students to view.

The Result: An incredibly simple, intuitive workflow for educators. They can create a polished, single-session replay without ever leaving their Moodle dashboard, demonstrating the power of this API to create user-friendly features on any video conference server.

How It Works: Two Powerful Merging Strategies​

The API offers two flexible ways to combine your recordings:

1. Merge by Session (by_session): This is the simplest method. You provide a room_sid (the unique identifier for a session), and the API automatically finds all recording files associated with that session and merges them in chronological order. You can even choose to exclude specific recordings if you need to remove a false start or an unwanted segment.

2. Merge by IDs (by_ids): This method gives you granular control. You provide an explicit list of recording_ids in the exact order you want them to be merged. This is perfect for more complex scenarios where you might be combining recordings from different sessions into a single compilation.

Technical Quick-Look​

• Asynchronous Operation: This is a background job. Your application makes the API call and gets an immediate confirmation. The actual processing is handled by a plugnmeet-recorder instance.
• Webhook Notification: You must have a webhook endpoint configured to receive the recording_proceeded event. This event will signal that the merged file is ready and provide its new record_id.
• Originals are Safe: The merge process is non-destructive. Your original recording files are never deleted, giving you the freedom to manage them as you see fit.

For detailed request and response examples, please refer to the official mergeRecordings API Documentation.

Conclusion: A Smoother Experience for Everyone​

The mergeRecordings API is a game-changer for anyone who needs to deliver polished, professional session replays. By automating the consolidation of fragmented recordings, it saves administrators time, simplifies post-production workflows, and provides a seamless viewing experience for your audience.

This feature is a perfect example of our commitment to providing a flexible, API-driven platform that can adapt to your unique needs, making your video call server more powerful than ever.

Ready to simplify your recording management?

• Explore the mergeRecordings API Documentation
• Check out our full API Reference
• Learn more about our Moodle Integration

This API allows your backend application to programmatically upload files directly into an active meeting's whiteboard, opening the door to powerful, seamless, and automated content workflows. This guide will walk you through the key use cases for this new feature and how it can transform your integration.

Why a New Upload API? The Power of Real-Time​

You might be familiar with the preload_file option in our Create Room API. While useful, it's designed for a different purpose: loading a document before a session begins.

The new uploadWhiteboardFile endpoint is fundamentally different. It's designed to inject content into a live, running session. This real-time capability is a game-changer for dynamic applications. When your backend calls this API, the file instantly appears in the presenter's file list within the live meeting, ready to be displayed.

Let's explore what you can build with this.

Use Case 1: Seamless Cloud Storage Integration (Google Drive, Dropbox, etc.)​

The Scenario: A user in your application wants to present a file stored in their Google Drive.

The Old Way: The user would have to download the file from Google Drive to their computer, then manually upload it through the Plug-N-Meet UI. This is a clunky, multi-step process.

The New Way with the API:

1. Your application's UI provides a button: "Present from Google Drive."
2. Using the Google Drive API, you allow the user to select a file.
3. Your backend server securely downloads the file from Google Drive.
4. Your backend then immediately calls the uploadWhiteboardFile API, pushing the file directly into the live Plug-N-Meet session.

The Result: A seamless, professional experience. The user goes from selecting a file in your app to having it ready to present in the meeting in a single click.

Pro-Tip: For an even more efficient workflow, you can use the document_link parameter. Instead of downloading the file to your server first, you can generate a publicly accessible temporary URL for the file in cloud storage and pass that link to the API. The Plug-N-Meet server will handle the download directly.

Use Case 2: Centralized Asset Library for Corporate & Education​

The Scenario: A company wants to ensure all sales presentations use the latest approved template, or a university wants to provide lecturers with a library of official course materials.

The Old Way: Presenters would have to find and download the correct file from a separate portal or shared drive before every meeting.

The New Way with the API:

1. You build a "Resource Library" directly into your application's dashboard.
2. A presenter, already in a live meeting, can browse this library from your application's interface.
3. When they click "Add to Whiteboard" on a specific asset (e.g., Q3-Sales-Deck.pptx), your backend retrieves the file from its centralized storage.
4. Your backend calls the uploadWhiteboardFile API to inject it into the presenter's current session.

The Result: Perfect brand consistency and effortless access to up-to-date, official materials, all managed from a single source of truth.

Use Case 3: Dynamic Report Generation and On-the-Fly Analysis​

The Scenario: A team is in a live meeting discussing performance metrics. They realize they need to see a specific, up-to-the-minute report that doesn't exist yet.

The Old Way: Someone would have to leave the meeting, generate the report, save it, and then manually upload it. The meeting's momentum is lost.

The New Way with the API:

1. Your application has a "Generate Live Report" button integrated into its dashboard.
2. A user in the meeting clicks the button and selects the required parameters.
3. Your backend generates the report (e.g., a PDF of a graph) on the fly.
4. As soon as the file is created, your backend calls the uploadWhiteboardFile API.

The Result: A report is generated and delivered into the live meeting in seconds, enabling true real-time, data-driven decision-making.

Use Case 4: Moodle Integration - Bridging Content and Classroom​

The Scenario: Our official Plug-N-Meet Moodle Plugin already leverages this API to create a seamless experience for educators. Teachers can manage a central repository of course materials within Moodle.

The New Way with the API:

1. A teacher is conducting a live class using the Plug-N-Meet activity in Moodle.
2. They decide they need to show a specific PDF or presentation from their Moodle course files.
3. From an interface within Moodle (outside the live session window), the teacher selects the file.
4. The Moodle backend calls the uploadWhiteboardFile API, instantly pushing the selected document into the live virtual classroom.

The Result: The teacher never has to leave their Moodle environment. They can inject course materials into the live session on the fly, creating a fluid and uninterrupted teaching experience. This showcases how the API can bridge an external content management system directly with a live session.

Technical Quick-Look & Important Considerations​

This endpoint uses a multipart/form-data request, which requires a different authentication method than our standard JSON APIs.

Authentication​

The HASH-SIGNATURE must be generated using your API-SECRET with the value of the Room-Id header as the message body. This is different from other APIs where the signature is generated from the request body.

File Constraints​

• Supported File Types: This API is optimized for office documents and presentations (PDF, PPT, DOC, etc.). Image files like JPG or PNG are not supported and will be rejected.
• File Size: The file must not exceed the max_size_whiteboard_file limit defined in your server's configuration.

Server Behavior​

• Concurrent Uploads: The server processes only one upload at a time per room. If you send a new upload request while another is in progress for the same room, you will receive a 409 Conflict error.
• Timeouts & Background Processing: File conversion can be resource-intensive. If your initial API call times out, don't worry. The server continues to process the file in the background. Once complete, the file will appear in the room, and the upload lock will be released.

For a complete curl example and detailed parameter descriptions, please refer to the official uploadWhiteboardFile API Documentation.

Conclusion: Your Application is Now the Co-Presenter​

The uploadWhiteboardFile API transforms the whiteboard from a simple user-driven tool into a programmable, dynamic canvas. It allows your application to become an active participant in the meeting, delivering relevant content exactly when it's needed.

This feature deepens the potential for integration, enabling you to build smarter, more automated, and highly professional workflows that set your application apart.

Ready to start building?

• Explore the uploadWhiteboardFile API Documentation
• Check out our full API Reference
• Try our Live Demo to see the whiteboard in action.

At Plug-N-Meet, we believe webinars should be dynamic, engaging, and truly interactive. It's not about replacing your presentation, but enhancing it with tools that foster real-time collaboration and feedback. This guide will show you how to leverage Plug-N-Meet's powerful features to design webinars that captivate your audience and deliver measurable results.

The Problem with Passive Webinars​

Traditional webinars often fall short because they treat the audience as passive consumers. This leads to:

• Low Engagement: Attendees tune out, multitask, or simply leave.
• Missed Opportunities: Valuable insights and questions from the audience are lost.
• Ineffective Learning: Information retention is poor without active participation.
• Generic Experience: Your event feels indistinguishable from countless others.

Plug-N-Meet empowers you to break free from this mold and create memorable, impactful webinars.

Plug-N-Meet's Interactive Toolkit​

Our platform is packed with features designed to turn your audience into active participants. Here’s how you can use them:

1. Live Polls: Instant Feedback & Decision Making​

Forget trying to tally responses in a chaotic chat. Live Polls allow you to ask structured questions and get immediate, quantifiable feedback from your entire audience.

• How to use it: Launch quick quizzes to check comprehension, gauge opinions on a new product feature, or even make group decisions. You can see results in real-time and publish them for discussion. For more ideas, read our post on Engaging Audience with Live Polls.
• Impact: Boosts engagement, provides valuable data, and keeps the audience invested in the content.

2. Breakout Rooms: Small Group Collaboration at Scale​

For workshops, training sessions, or brainstorming, small group discussions are invaluable. Breakout Rooms allow you to split your large audience into smaller, private sub-meetings.

• How to use it: Assign participants randomly or manually to groups. Each room gets its own private whiteboard, shared notepad, and full audio/video capabilities. As a moderator, you can broadcast messages to all rooms or join specific groups. Learn more in our guide to Mastering Breakout Rooms.
• Impact: Fosters deeper collaboration, encourages quieter participants to speak up, and allows for focused problem-solving.

3. Interactive Whiteboard & Shared Notepad: Visual & Textual Collaboration​

Move beyond static slides. Our integrated whiteboard and shared notepad provide dynamic canvases for collective ideation and note-taking.

• How to use it: Upload presentations or documents to the whiteboard and annotate them in real-time. Enable multi-user drawing for collaborative brainstorming. Use the shared notepad for collective note-taking, drafting ideas, or creating action item lists. Dive deeper into our Integrated Whiteboard Experience.
• Impact: Enhances visual learning, makes abstract concepts clearer, and creates shared artifacts of the session.

4. Q&A / Raise Hand: Structured Audience Interaction​

Manage questions effectively without interrupting the flow of your presentation.

• How to use it: Encourage attendees to use the "Raise Hand" feature to signal they have a question. As a moderator, you can then unmute them individually. Use the public chat for general comments, but direct specific questions to a dedicated Q&A segment. Our Moderator Guide to Room Lock Settings provides more details on managing interactions.
• Impact: Maintains order, ensures all questions are addressed, and gives every participant a chance to be heard.

5. Embed Web Content: Dynamic Presentations​

Bring the web directly into your meeting without clunky screen sharing.

• How to use it: Share any website, online application (like a Google Doc, Miro board, or project management tool), or interactive content directly within the meeting window. Find out more in Bring the Web into Your Meeting.
• Impact: Creates a seamless, integrated presentation experience, reduces distractions, and enables real-time collaborative work on external resources.

Designing Your Interactive Webinar: A Workflow Example​

Here’s how you might structure a 60-minute interactive webinar using Plug-N-Meet:

• Pre-Webinar Setup:

  • Enable Features: When creating your room (via API or dashboard), ensure polls_features, breakout_room_features, whiteboard_features, shared_note_pad_features, and display_external_link_features are all enabled. You can find detailed API parameters in our Create Room API Documentation.
  • Default Lock Settings: For a webinar, you might start with microphones and webcams locked for attendees by default to maintain control. Refer to our Moderator Guide for more on lock settings.
  • Webhooks: Set up a webhook to automate post-webinar tasks like sending recordings or summaries. Learn how in How to Build Your First Automated Workflow with Webhooks.

• 0-5 Minutes: Welcome & Icebreaker (Interactive Whiteboard)

  • Start with a simple, engaging activity. Upload a world map to the whiteboard and ask participants to mark their location using the multi-user drawing tool. This gets everyone comfortable with the tools and creates a visual representation of your global audience.

• 5-20 Minutes: Core Presentation & Quick Check (Live Polls)

  • Deliver your initial content. After a key segment, launch a quick poll to check for understanding or gather opinions. "On a scale of 1-5, how relevant is this topic to your work?" Publish the results and briefly discuss.

• 20-40 Minutes: Collaborative Activity (Breakout Rooms with Whiteboard/Notepad)

  • Introduce a problem or discussion topic. Divide your audience into small groups using Breakout Rooms. Instruct them to use their private whiteboards for brainstorming or shared notepads for outlining solutions. Broadcast a "5 minutes left!" message before bringing them back.

• 40-50 Minutes: Debrief & Q&A (Live Polls & Raise Hand)

  • Once back in the main room, launch another poll: "Which solution did your group find most promising?" Publish results. Then, open the floor for questions using the "Raise Hand" feature, unmuting participants one by one.

• 50-60 Minutes: Dynamic Content & Call to Action (Embed Web Content)

  • Instead of just telling people where to go, use "Share External Link" to display your website, a sign-up form, or a relevant resource directly in the meeting. Conclude with a final poll for overall feedback.

Conclusion: Your Audience Deserves More​

Moving beyond the passive presentation transforms your webinars from forgettable broadcasts into memorable, high-impact events. With Plug-N-Meet, you have a comprehensive, open-source toolkit to design truly interactive experiences that engage your audience, foster collaboration, and deliver real value.

Stop talking at your audience. Start working with them.

Ready to design your next interactive webinar?

• Try these features in our Live Demo
• Explore our Open-Source Project on GitHub
• Read our Moderator Guide for more tips on managing interactive sessions.

The answer isn't to work harder; it's to teach smarter. Imagine having a silent partner in every session, one that makes your virtual classroom more inclusive, accessible, and effective. This is the power of an AI Teaching Assistant. Here are 5 ways it can revolutionize your online teaching.

1. Make Every Student Feel Included with Live Translation​

The Challenge: A student’s primary language isn't the one being spoken in class. They struggle to keep up, hesitate to participate, and quickly become disengaged.

The AI Solution: With a single click, that student can enable live, real-time translation. As you speak, they see captions in their native language, allowing them to understand the material and formulate questions. This simple tool breaks down language barriers and fosters a truly global, inclusive classroom where every student has a voice.

2. Boost Comprehension for Every Learning Style​

The Challenge: Students have diverse learning needs. Some are visual learners, some may be in a noisy environment, and others may have hearing impairments.

The AI Solution: Live transcription provides real-time captions of everything you say. This reinforces your lesson visually, helps students catch anything they might have missed, and provides a critical accessibility tool. It ensures that all students can follow along, improving focus and knowledge retention for everyone.

3. Get Instant Answers with a Built-in Research Assistant​

The Challenge: You mention a concept or historical figure that a student isn't familiar with. To understand it, the student has to open a new browser tab, search, and read, causing them to miss the next part of the lesson.

The AI Solution: The AI Assistant acts as a built-in research tool. A student can privately ask the AI general knowledge questions like, "Who was Marie Curie?" or "What is the Pythagorean theorem?" and get a quick, concise answer without ever leaving the meeting window. This helps them fill knowledge gaps instantly and stay focused on the live lesson.

4. Create Perfect, Searchable Study Guides—Automatically​

The Challenge: After a long lecture, you need to share your notes, and students need a reliable way to review the material.

The AI Solution: Forget manual note-taking. Once the session is over, the AI Assistant automatically generates a concise summary of the entire lesson, complete with key concepts and action items. This becomes a perfect, searchable study guide that saves both you and your students hours of work.

5. Focus on Teaching, Not Juggling Tasks​

The Challenge: As an educator, you're juggling multiple roles at once: presenting content, managing participants, monitoring the chat, and trying to take notes.

The AI Solution: By offloading the tasks of transcription and post-meeting summarization to the AI, you are free to do what you do best: teach. You can focus entirely on student-interaction, gauge understanding, and deliver a more dynamic and engaging lesson.

Your New Superpower​

AI isn't about replacing great teachers; it's about giving them superpowers. It automates the tedious tasks, breaks down barriers to participation, and allows you to create a more powerful and equitable learning experience for every student.

At plugNmeet, we believe this technology should be simple and accessible for everyone.

For educators, our platform integrates seamlessly into the tools you already use. Get started in minutes with our guides for Moodle, WordPress, or Joomla.

For developers, our flexible, open-source foundation is so powerful you can build a complete video conferencing app in under an hour.

Ready to see how an AI assistant can transform your classroom?

• Try our Live Demo to experience these features firsthand.
• Want to learn how it works? Read our technical guide on how to add an AI meeting assistant.

Today, we're thrilled to announce the launch of the completely rebuilt plugNmeet plugin for Moodle. This isn't just an update; it's a ground-up redesign focused on one thing: deep, seamless integration that makes your virtual classroom feel like a core Moodle activity.

A Major Leap Forward​

While our previous plugin offered basic branding and recording features, this new version is in a different league. We've rebuilt it from scratch with a laser focus on Moodle 4.5+ standards, creating a robust, secure, and deeply integrated solution. The user interface is now cleaner and more intuitive, with features logically placed within the Moodle activity context, just as you'd expect.

So, what makes this new version so special? Let's dive into the features that will change the way you teach online.

More Than a Plugin—It's Part of Moodle​

We moved beyond simple embedding to deeply integrate plugNmeet into Moodle’s core systems.

• Advanced Completion Tracking: Go beyond simple "viewed" metrics. Our plugin introduces cumulative completion criteria. Track user engagement across all sessions within a single Moodle activity. Mark the activity complete based on:
  • Total minutes attended
  • Total webcam or microphone duration
  • Number of chat messages sent
  • Raised hand, voted in a poll, and more...
• Automatic Calendar Integration: When you schedule a session using the "Available from" date, the plugin automatically creates an event in the Moodle Calendar. Your students will see upcoming classes on their dashboard and course calendars, boosting visibility and attendance.
• Gradebook Integration: Assign a grade for your plugNmeet activity. The plugin can automatically calculate a grade based on the completion progress of the criteria you set.

Transparency and Data-Driven Insights​

Knowledge is power—not just for teachers, but for students too. This plugin gives you the data you need to understand engagement like never before. For a deeper dive into how to use this data, see our guide on Classroom Analytics for Educators.

• New Student Self-Reporting Dashboard: Students no longer have to wonder about their progress. They now have access to a beautiful, personalized dashboard that shows their cumulative participation data in a modern, card-based layout.
• Visual Progress Tracking: If completion criteria are set, students see color-coded status cards (Green for met, Yellow for pending) with clear badges indicating exactly what they need to do to complete the activity.
• Cumulative Attendance Reporting: Teachers get a consolidated attendance list for the entire activity. See at a glance who is attending and for how long across a series of classes, with the ability to export the data to Excel.
• Live Session Dashboard: Need to know what's happening in a live class right now? Teachers can view a real-time dashboard showing the number of participants, active webcams, microphones, and more.
• Session Artifacts in Moodle: After a session, all generated files—including AI-powered meeting summaries, full transcriptions (VTT files), and detailed analytics reports—are available directly on the Moodle activity page. To learn more about the AI capabilities, read our guide on how to add AI features to your video conferences.

Built for Administrators and Developers​

We built this plugin to be as powerful for administrators as it is for teachers.

• 100% White-Label Experience: Using the Remote (Embedded) client mode, the plugNmeet classroom loads directly within your Moodle site's layout. There are no redirects and no third-party branding. To your users, it’s simply your virtual classroom, powered by Moodle.
• Granular, Role-Based Access: We've implemented a comprehensive set of Moodle capabilities to give you fine-grained control over who can manage rooms, view recordings, download artifacts, and see attendance reports.
• Extensible Events API: The plugin receives real-time data from your plugNmeet server via webhooks and immediately re-broadcasts them as standard Moodle events. This allows developers to easily hook into events like participant_joined or recording_proceeded to build custom integrations and extend functionality.

A Seamless Experience for Everyone​

• Secure Guest Access: A new, secure workflow allows you to generate time-limited, single-use guest links for guest speakers or external participants, without compromising your site's security. For maximum security in sensitive meetings, you can also enable end-to-end encryption.
• Redesigned Recordings Page: Managing cloud recordings is now a breeze. View and control the visibility of your recordings from a clean and intuitive interface within the activity page.

To get started, check out our Ultimate Guide to Moodle Video Conferencing or our tutorial on How to Add No-Code Video Conferencing to Your Moodle Courses.

Ready to enhance your Moodle courses?

• Download the official Moodle Plugin
• Try the Live Demo to explore the teaching tools.
• Follow our Installation Guide to get your server running.

What if you could host professional webinars and meetings with unparalleled control, complete data privacy, and the flexibility to tailor every aspect to your brand and workflow? This is the promise of open source webinar software and self-hosted meeting platforms. At plugNmeet, we believe in empowering you to reclaim ownership of your digital interactions.

The Power of Open Source Webinar Software: More Than Just a Tool​

When you search for "open source webinar software," you're looking for freedom. You want to own your brand, manage your audience, and create a unique, professional presentation without being locked into a vendor's ecosystem.

Proprietary webinar tools often treat a webinar like a glorified meeting, lacking the specific features needed for a structured, engaging event. An open-source platform, however, allows for:

1. Clear Roles & Moderation: Distinguish between presenters and attendees, with granular control over permissions. A dedicated admin can manage the audience, while the presenter focuses on content delivery, as detailed in our post on open source webinar software platforms.
2. Structured Engagement: Move beyond chaotic chat. Implement live polls for Q&A, quizzes, and use features like "Raise Hand" for organized interaction.
3. Complete Branding: Your webinar is your show. Open-source solutions, especially those built with an API-first approach like plugNmeet, allow for deep customization – from logos and colors to entirely rebuilding the layout to match your brand identity perfectly.
4. Content Ownership: Recordings are valuable assets. With open-source, you own your content, saving it to your servers and automating post-webinar workflows (e.g., uploading to YouTube, sending to attendees).

Open source isn't just about cost; it's about community, transparency, and the ability to adapt the software to your exact needs, rather than adapting your needs to the software.

Why Self-Hosted Meeting Solutions are Non-Negotiable for Control & Privacy​

The "self-hosted meeting" aspect takes control to the next level. When you host your own video conferencing infrastructure, you gain benefits that proprietary cloud services simply cannot offer:

• Unmatched Data Ownership & Privacy: Your conversations, recordings, and user data reside entirely within your infrastructure. This is critical for compliance with regulations like GDPR, HIPAA, and other industry-specific privacy standards. You are in command of your data, not a third-party vendor.
• Cost-Effectiveness at Scale: Proprietary solutions often charge per-user or per-minute, leading to escalating costs. Self-hosting offers predictable infrastructure costs, making it a significantly more cost-effective solution for long-term, large-scale deployments. For strategies on hosting large-scale events, we recommend a broadcast studio model to maximize scalability and minimize costs.
• Tailored Performance & Reliability: By hosting on your own servers, you can optimize network and resources specifically for your users. This ensures a smoother, more reliable experience, especially when combined with smart streaming techniques like Simulcast and Dynacast, which adapt video quality to individual network conditions and pause off-screen video streams to save bandwidth, as explained in our article on smart video streaming.
• Deep Customization & Integration: Beyond just branding, self-hosting allows for profound customization. You can integrate video conferencing directly into your existing applications and workflows, using powerful APIs to define feature sets for each room, embed web content, and even connect with traditional telephony via SIP Dial-In for participants without internet access.

plugNmeet: Your Foundation for Open Source, Self-Hosted Excellence​

plugNmeet is built from the ground up to deliver on these promises. As an open-source, WebRTC-based platform, it provides the flexible, powerful, and secure foundation you need to build a professional, branded, and automated webinar and meeting experience that is truly your own.

Key features that highlight our commitment to open source and self-hosting include:

• Adaptive Streaming (Simulcast & Dynacast): Ensures smooth, uninterrupted calls even on challenging networks by intelligently managing video streams.
• RTMP & WHIP Ingress: Stream like a pro by bringing professional tools like OBS Studio directly into your meeting room, appearing as a participant, as detailed in our guide on OBS RTMP WHIP Ingress.
• SIP Dial-In: Bridge the gap for participants without internet access, allowing them to join audio via any standard telephone.
• AI Meeting Agent: Enhance productivity with live spoken translations, automated summaries, and full transcriptions.
• End-to-End Encryption (E2EE): For the highest level of privacy, ensuring your conversations remain completely confidential.
• Comprehensive APIs & SDKs: For developers to build custom solutions and integrate deeply with existing systems.
• CMS Plugins: Ready-to-use plugins for WordPress, Joomla, and Moodle for easy integration without coding. For example, you can start your Webinar meeting with WordPress in minutes.

Take Control of Your Communication Future​

In a world where digital interactions are paramount, settling for generic, proprietary solutions means sacrificing control, privacy, and the ability to truly brand and tailor your user experience.

Choose an open source webinar software and self-hosted meeting platform like plugNmeet to empower your organization with a secure, scalable, and fully customized video conferencing solution. Reclaim ownership of your communication and deliver an unparalleled experience to your users.

Ready to build your perfect webinar and meeting platform?

• Explore our Live Demo to see the features in action.
• Visit our GitHub Repository to get started with self-hosting.
• Dive into our API Documentation to begin building your custom solution.

Enter plugNmeet: an open-source, self-hosted WebRTC platform designed to give you ultimate control, unparalleled customization, and robust security, fundamentally outperforming generic, off-the-shelf alternatives.

The Power of Self-Hosting: Unmatched Control & Privacy​

When you choose a proprietary video conferencing service, your data resides on their servers, subject to their policies, security practices, and potential data mining. Self-hosting with plugNmeet flips this script, putting you firmly in command.

• Data Ownership & Privacy: Your conversations, recordings, and user data remain entirely within your infrastructure. This is crucial for compliance with regulations like HIPAA, GDPR, and other industry-specific privacy standards. With plugNmeet, you own your data, ensuring maximum privacy and peace of mind. For a deeper dive into our security architecture, refer to our Security Overview.
• Cost-Effectiveness at Scale: Proprietary solutions often charge per-user or per-minute, leading to escalating costs as your needs grow. Self-hosting offers predictable infrastructure costs, making it a significantly more cost-effective solution for long-term, large-scale deployments.
• Reliability & Performance: By hosting on your own servers, you can optimize your network and resources specifically for your users, ensuring a smoother, more reliable experience tailored to your audience's geographical location and bandwidth.

Beyond Branding: True Customization for Your Unique Needs​

Many "white-label" solutions merely allow you to swap a logo. plugNmeet offers a level of customization that transforms the platform into an integral part of your ecosystem, not just an embedded tool.

• Pixel-Perfect Branding: From custom URLs and logos to colors and layouts, plugNmeet allows you to tailor every visual aspect to match your brand identity seamlessly. For more on this, see our post on True White-Label Video Conferencing. Our getClientFiles API even allows you to inject the client directly into your application for a truly native feel, as detailed in our Design Customization Guide and getClientFiles API Documentation.
• Feature Control via API: Our powerful server-side API lets you define the exact feature set for each room. Need a minimalist one-to-one chat? Disable the whiteboard and polls. Building a virtual classroom? Enable breakout rooms, shared notepads, and advanced moderation tools. This granular control ensures your users only see what's relevant, creating a streamlined and focused experience.
• Tailored Workflows: Whether you're building a telehealth platform, an online learning environment, or a secure corporate communication hub, plugNmeet's flexibility allows you to integrate video conferencing directly into your existing workflows and applications.

Feature Spotlight: What Makes plugNmeet Stand Out​

While control and customization are paramount, plugNmeet also boasts a rich set of features that rival, and often surpass, proprietary offerings.

• AI Meeting Agent: Transform your meetings into actionable insights with live spoken translations, automated summaries, and full transcriptions. This intelligent agent enhances productivity and accessibility. Learn more about How to Add AI Features.
• End-to-End Encryption (E2EE): Beyond standard WebRTC security, plugNmeet adds an additional layer of true E2EE, ensuring that even the server cannot access the content of your private conversations. This is privacy by design. Explore our E2EE Key Models Guide and How to Enable End-to-End Encryption.
• Advanced Collaboration Tools: Boost productivity with interactive whiteboards, collaborative notepads, screen sharing, and breakout rooms for focused group discussions.
• Scalability & Performance: Built with modern technologies like Go, LiveKit, and NATS, plugNmeet is engineered for horizontal scaling, supporting hundreds of participants with optimal performance, even on challenging networks thanks to adaptive streaming. Discover how our Scaling Architecture Saves Money and dive into our Backend Architecture Deep Dive.
• Recording & Broadcasting: Capture sessions in HD as portable MP4 files to your own server, or stream live to platforms like YouTube and Facebook using built-in RTMP/WHIP support. You own your content, always. Read our Guide to Managing Meeting Recordings and learn about Smart Scaling HA Recorder.

Seamless Integration & Migration​

Worried about switching from an existing platform? plugNmeet makes it easy.

• Easy Migration: For users looking to move away from platforms like BigBlueButton, plugNmeet offers a modern, performant, and highly customizable alternative. Our architecture simplifies the transition, allowing you to leverage your existing knowledge while gaining superior control and features. See our guide on Migration from BigBlueButton.
• CMS Plugins: Integrate plugNmeet effortlessly into popular content management systems like WordPress, Joomla, and Moodle with our official plugins, requiring no coding. Find out more in our guides for WordPress Video Conferencing, Joomla Video Conferencing, and Moodle Video Conferencing.
• Developer-Friendly SDKs: For custom applications, our comprehensive API Documentation and SDKs (PHP, JavaScript, Python) provide the tools developers need for deep integration.

Conclusion: Choose Control, Choose Customization, Choose plugNmeet​

In a world increasingly reliant on digital communication, settling for generic, proprietary video conferencing solutions means sacrificing control, privacy, and the ability to truly brand and tailor your user experience.

plugNmeet offers a powerful, open-source alternative that empowers you to build a secure, scalable, and fully customized video conferencing platform that is truly your own. Reclaim ownership of your communication and deliver an unparalleled experience to your users.

Ready to take control of your video conferencing?

• Explore our Live Demo to see the features in action.
• Visit our GitHub Repository to get started with self-hosting.
• Dive into our API Documentation to begin building your custom solution.

What if you could cut that bill by up to 80% while gaining more control and better branding?

It's not a fantasy. By switching from a proprietary SaaS "rental" model to a self-hosted "ownership" model with an open-source platform like Plug-N-Meet, you can dramatically reduce your Total Cost of Ownership (TCO). This article will break down the numbers and show you how.

The SaaS "Rental" Model: A Penalty on Growth​

The pricing model for most SaaS video platforms is simple and seductive: a flat fee per host, per month. It's easy to budget for when you have 10 employees. But what happens when you have 100?

Let's look at a common scenario.

Scenario: A Company with 50 Hosts

• SaaS Provider Cost (e.g., Zoom Pro):
  • Price per host: ~$15.99 / month
  • Total monthly cost: 50 hosts * $15.99 = $799.50 / month
  • Total annual cost: $9,594 / year

This is a significant, recurring operational expense (OpEx). And it gets worse. This model penalizes you for success. If your company grows to 100 hosts, your bill doubles to nearly $20,000 per year. You are paying more for the exact same service, simply because your team is bigger.

The Self-Hosted "Ownership" Model: Predictable and Scalable​

Now, let's compare this to a self-hosted model using the open-source Plug-N-Meet platform. With this model, you don't pay any license fees. Your only significant cost is the server hardware you run the software on.

Scenario: The Same Company with 50 Hosts (or 100, or 200)

• Self-Hosted Infrastructure Cost (e.g., Hetzner Cloud Server):
  • Recommended server: A powerful cloud instance like the Hetzner CCX33 (8 vCPUs, 32 GB RAM).
  • Total monthly cost: ~€55 / month (approx. $60 / month)
  • Total annual cost: ~$720 / year

Let's compare the annual costs:

• SaaS Model: $9,594
• Self-Hosted Model: $720

That's a cost reduction of over 92%.

Even if you choose a more expensive cloud provider or a larger server for higher capacity, the savings are dramatic. A comparable server on DigitalOcean or AWS might cost $150-$250 per month, which still represents a cost saving of over 80% compared to the SaaS alternative.

The best part? This cost is fixed. If your company grows from 50 to 100 hosts, your server cost doesn't change. You can accommodate more users for the same price, rewarding your growth instead of penalizing it.

But What About "Hidden" Costs?​

Skeptics of self-hosting often point to hidden costs like maintenance and setup. Let's address those directly.

• Setup Complexity: This used to be a valid concern. Today, with automated tools, it's largely a solved problem. Plug-N-Meet provides a one-line installation script that sets up a production-ready server in about 15 minutes. You don't need to be a systems administration expert.
• Maintenance: The server requires minimal maintenance. Running a software update is as simple as executing another one-line script. For most organizations, this amounts to less than an hour of work per month.
• Reliability: Modern cloud providers offer extremely high uptime (often 99.99%). Your self-hosted solution, running on reliable infrastructure, is just as dependable as a SaaS service, with the added benefit that you aren't affected by their widespread outages.

When you weigh a few hours of optional maintenance per year against a potential saving of thousands of dollars, the financial case becomes overwhelmingly clear.

Conclusion: Stop Renting, Start Owning​

The per-user, per-month SaaS model is a brilliant business strategy—for the provider. For the customer, it's a treadmill of escalating costs that actively works against your growth.

By switching to a self-hosted, open-source platform like Plug-N-Meet, you move from being a tenant to an owner. You gain a predictable, low-cost infrastructure that scales with your success. You also get the invaluable strategic benefits of full brand control, deeper integration, and absolute data privacy.

If your organization is feeling the pain of rising SaaS subscription costs, it's time to run the numbers. The move to self-hosting isn't just a technical decision; it's one of the smartest financial decisions you can make.

Ready to slash your video conferencing costs?

• See our detailed Server Recommendations.
• Follow our simple Installation Guide to get started.
• Read more about the Business Case for Self-Hosting.

But how do you replicate this in a virtual classroom? An unsecured online meeting can quickly devolve into chaos, with uninvited guests, background noise, and constant interruptions.

This guide will walk you through the simple but powerful tools available in Plug-N-Meet that allow you to take control of your digital classroom. Think of these features as your new classroom management toolkit, designed to ensure your online sessions are as safe, private, and productive as your in-person ones.

1. Lock the Door: The Waiting Room​

You wouldn't let just anyone walk into your classroom off the street. The same principle should apply online. The Waiting Room is your digital lobby, giving you complete control over who enters your session.

• How it Works: When you enable the Waiting Room for your class, any student who clicks the join link is placed on a "waiting" screen. You, the teacher, will see a notification and a list of everyone waiting to get in. You can then admit them one by one or all at once.
• Why it's Essential:
  • Prevents "Zoombombing": This is the single most effective way to stop uninvited guests from disrupting your class. If you don't recognize a name, you don't have to let them in.
  • Control the Start Time: It allows you to prepare your lesson materials and admit all students at the same time, ensuring everyone starts on the same page.

How to Enable it: You can enable the Waiting Room in your room settings when you create the class in your LMS (like Moodle) or via the API.

2. Set the Rules: Granular Lock Settings​

Once your students are in the room, you need to set the ground rules for participation. Plug-N-Meet's Room Lock Settings panel is your command center for this.

• Lock Microphones (Your Most-Used Tool): This is the equivalent of asking the class to be quiet while you're speaking. It mutes all participants and prevents them from unmuting themselves. This is essential for lectures, presentations, or when a specific student is speaking.
• Lock Webcams: In large classes, having dozens of webcams active can be distracting and consume a lot of bandwidth. Locking webcams helps focus attention on the speaker or the shared content.
• Lock Public Chat: While chat is a great tool, it can sometimes become a source of distraction. You can temporarily lock the chat to bring focus back to the lesson, and then unlock it for a dedicated Q&A session.
• Lock Screen Sharing: Keep this locked by default to prevent students from accidentally taking over the presentation. You can unlock it when you want a student to share their work.

Pro Tip: Use these settings dynamically. Start your class with everything unlocked for a few minutes of social time, then lock microphones and chat when the formal lesson begins.

3. The Gold Standard of Privacy: End-to-End Encryption (E2EE)​

For sensitive conversations, such as a one-on-one meeting with a student or a parent, you may need the highest possible level of privacy. End-to-End Encryption (E2EE) provides a mathematical guarantee that no one—not even the server administrator—can access the audio or video of your conversation.

• How it Works: When E2EE is enabled, the video and audio are encrypted on your device and only decrypted on the recipient's device.
• When to Use It: This is ideal for any situation requiring absolute confidentiality, such as discussions about grades, student well-being, or any other private matter.

How to Enable it: E2EE can be enabled on a per-room basis. Our guide on How to Enable E2EE explains the simple steps. It's important to note that when you enable the highest level of E2EE, features that require the server to "see" the media, like cloud recording, are automatically disabled for your protection.

Conclusion: You Are in Control​

A secure and productive online classroom doesn't happen by accident. It happens by design. By using these simple but powerful features, you can move from being a passive host to an active and effective classroom manager.

Start with the Waiting Room to control who enters, use the Lock Settings to manage the flow of conversation, and deploy E2EE for sensitive discussions. With these tools at your fingertips, you can create a virtual learning environment that is just as safe, private, and conducive to learning as your physical classroom.

Ready to take control of your virtual classroom?

• Try these moderator features in our Live Demo.
• Read our full Moderator Guide for more tips.
• Learn more about our commitment to Privacy by Design.

So why, at the most critical moment of interaction—a sales demo, a customer support call, or a training session—do you send your customers to a third-party platform with someone else's logo on it?

Using a generic, off-the-shelf video conferencing tool is like a Michelin-starred restaurant serving its food in a McDonald's box. It breaks the experience, erodes brand value, and misses a huge opportunity. This is why forward-thinking businesses are moving away from generic SaaS tools and embracing white-labeled video conferencing solutions like Plug-N-Meet.

A white-label platform isn't just about changing the logo. It's about owning the entire customer journey and transforming a simple utility into a powerful strategic asset.

1. It Builds Brand Trust and Professionalism​

Imagine a new client is paying you for a premium consultation. You send them a meeting link. Which of these inspires more confidence?

• your-company.zoom.us
• meet.your-company.com

The answer is obvious. When the entire experience—from the URL to the logo in the corner to the brand colors of the interface—is yours, it sends a powerful message: you are professional, you are established, and you have invested in your own platform. It removes the jarring feeling of being handed off to another company and keeps the focus entirely on your brand.

2. It Creates a Seamless, Frictionless Customer Experience​

A white-labeled solution, especially one that can be deeply integrated, eliminates the "context switching" that plagues generic tools. Instead of your user having to open a separate app or a new tab that looks completely different from your website, the video experience feels like a natural extension of your own digital property.

With a platform like Plug-N-Meet, you can use the getClientFiles API to embed the video client directly into your own application or customer portal. This means you can:

• Place the video call next to relevant customer data for your support agents.
• Allow users to join a webinar directly from your community page without ever leaving your site.
• Create a "single pane of glass" experience where the video is just one integrated component of a larger workflow.

This seamlessness reduces friction, improves usability, and keeps your user engaged within your ecosystem.

3. You Control the Feature Set and User Journey​

Not all conversations are the same. A one-on-one sales call has very different needs than a 100-person training webinar.

Generic platforms offer a one-size-fits-all approach. A white-label, API-first platform gives you granular control to tailor the experience to the specific use case.

• For a simple support call: You can disable all features except video, audio, and chat to create a clean, minimalist interface.
• For an interactive workshop: You can enable the whiteboard, breakout rooms, and polling to foster collaboration.
• For a formal presentation: You can lock down all participant controls to ensure the focus remains on the speaker.

This ability to programmatically define the user journey means you can deliver the perfect, purpose-built tool for every interaction, which is a level of service generic platforms can't match.

4. It Turns a Cost Center into a Potential Revenue Stream​

When you pay a per-user subscription for a generic SaaS tool, video conferencing is a cost center that grows as your team grows.

When you own your platform, you flip the model. Because a self-hosted solution like Plug-N-Meet has no per-user fees, you can offer video conferencing services to your own customers. With our official plugins for WordPress and Joomla, you can even use membership and e-commerce extensions to sell access to premium, branded meeting rooms—no coding required.

You transform a monthly expense into a revenue-generating product.

Conclusion: Stop Advertising for Other Brands​

Every time a customer joins a meeting on a generic platform, you are paying to advertise for that platform.

A white-labeled video conferencing solution is an investment in your own brand. It enhances trust, creates a superior customer experience, and gives you the control to build a communication tool that perfectly fits your business. In a competitive market, owning this critical touchpoint is not a luxury; it's a strategic necessity.

Ready to put your brand front and center?

• Learn more about our Deep Integration and White-Labeling Capabilities.
• Try our Live Demo and imagine it with your own branding.
• Follow our Installation Guide to start building your own platform.

What if you could integrate a secure, fully-branded, and powerful video conferencing solution directly into your Joomla site, making it a native part of your user's journey?

With the official Plug-N-Meet component for Joomla, you can. This guide will show you how to transform your Joomla website into a dynamic communication platform, perfect for community meetings, webinars, online training, and even monetized services.

Why a Native Joomla Integration Beats External Tools​

Before we get into the setup, let's be clear about the strategic advantages of using a self-hosted, integrated solution like Plug-N-Meet instead of an external SaaS tool.

1. A Seamless, Professional Brand Experience: Your users join meetings on your own domain, with your logo and brand colors. This reinforces professionalism and trust, keeping the user experience consistent with the rest of your site.
2. Full Control Over User Data: All user data and meeting recordings are stored on your own server, not in a third-party cloud. This is critical for maintaining data sovereignty and complying with privacy regulations like GDPR.
3. Cost-Effective Scaling: You escape the expensive per-user, per-month subscription fees that penalize growth. With a self-hosted model, your primary cost is a predictable server fee, allowing you to serve more users without your bill spiraling out of control.

The 3-Step Guide to Your First Joomla Meeting​

You can have a live video meeting room on your Joomla site in under 15 minutes.

Step 1: Get Your Video Conferencing Engine​

First, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.

Step 2: Install the Free Plug-N-Meet Component​

From your Joomla administrator panel:

1. Go to System > Install > Extensions.
2. Install the Plug-N-Meet component, which you can download from the official Joomla Extensions Directory.
3. After installation, navigate to System > Global Configuration and select plugNmeet from the components list.
4. Enter your API Key and API Secret and save the configuration.

Your Joomla site is now fully connected to your video conferencing engine.

Step 3: Create and Display Your Room​

1. Go to Components > Plug N Meet > Manage Rooms and click + New.
2. Configure your room's features, such as its name, participant limits, and a welcome message.
3. To display the room, go to Menus > Main Menu and click + Add New Menu Item.
4. For the Menu Item Type, select Plug N Meet > Single room.
5. In the Select a room dropdown, choose the room you just created and save the menu item.

That's it. A new link will appear on your site's main menu, leading directly to your fully functional, branded video conferencing room.

Level Up: 3 Powerful Ways to Use Video on Your Joomla Site​

With the basics in place, you can now leverage Plug-N-Meet to build sophisticated video-based services.

Use Case 1: The Private Client Portal​

If you're a consultant, coach, or provide any one-on-one service, you can create private, secure meeting rooms for your clients.

• How to do it: Use Joomla's built-in Access Control Levels (ACL) to create a user group for each client. Create a dedicated menu item for their private meeting room and set its Access level to their specific user group. Now, only that logged-in client can see and access their private session link.

Use Case 2: The Community Webinar Platform​

Host live webinars and events directly on your site to engage your community.

• How to do it: Create a new room and configure it for a webinar. In the room settings, you can disable webcams for attendees, enable Cloud Recording, and activate features like Polling and Raise Hand. Set the menu item's access to "Public" or "Registered" and you have an instant webinar platform.

Use Case 3: The Monetized Membership Service​

This is where you can turn your Joomla site into a revenue-generating business. By combining Plug-N-Meet with a Joomla membership or e-commerce extension, you can sell access to premium video content. For a detailed walkthrough, see our guide on How to Launch Your Own No-Code Video Conferencing Service with Joomla.

• How to do it:
  1. Use your membership extension to create a "Premium Members" user group that paying subscribers are automatically added to.
  2. Create a new menu item that links to your premium Plug-N-Meet room.
  3. Set the Access level for this menu item to "Premium Members."

Now, only paying subscribers will be able to see the link and join your exclusive video sessions, creating an automated paywall.

Conclusion: The Professional Video Solution for Joomla​

Don't let external tools dictate your user experience. With the Plug-N-Meet component, you can seamlessly integrate a secure, scalable, and fully-branded video conferencing platform into the Joomla ecosystem.

It's a solution that's simple enough to get started in minutes but powerful enough to build a business on.

Ready to power up your Joomla site?

• Download the official Joomla Component
• Try the Live Demo to see all the features in action.
• Follow our Installation Guide to get your server running.

What if your virtual classroom was just another native Moodle activity, as easy to add as a quiz or a forum? What if it was a powerful, interactive space designed specifically for teaching, not just a generic meeting room?

With the official Plug-N-Meet plugin for Moodle, this is not just possible; it's simple. This guide will show you how to transform your Moodle site into a world-class, interactive e-learning platform.

Why a Native Moodle Integration is a Game-Changer​

Before we get to the "how," let's focus on the "why." Choosing a deeply integrated, self-hosted solution like Plug-N-Meet over a generic SaaS tool provides three critical advantages for any educational institution.

1. A Seamless Student Experience: Students never leave your Moodle site. They join the live class directly from their course page, with the same branding and interface they already know. This reduces confusion and keeps them focused on the learning, not the technology.
2. Absolute Control Over Student Data: In education, privacy is paramount. With a self-hosted platform, all student data and class recordings are stored on your own servers, not on a third-party cloud. This gives you full control to ensure compliance with privacy regulations like GDPR and FERPA.
3. Predictable, Scalable Costs: Instead of paying a costly per-host, per-month subscription that penalizes you for adding more teachers, you have a fixed, predictable cost for your server infrastructure. This is a far more sustainable and cost-effective model for schools and universities.

The 3-Step Guide to Your First Moodle Virtual Classroom​

Getting started is incredibly fast. You can have your first meeting room live in under 15 minutes. For a more detailed walkthrough, you can also read our popular guide on How to Add No-Code Video Conferencing to Your Moodle Courses.

Step 1: Get Your Video Conferencing Engine​

First, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.

Step 2: Install the Free Plug-N-Meet Plugin​

From your Moodle Site Administration panel:

1. Go to Site administration > Plugins > Install plugins.
2. Install the Plug-N-Meet plugin, which you can download from the official Moodle plugins directory.
3. After installation, navigate to the plugin settings page (Site administration > Plugins > Activity modules > PlugNmeet).
4. Enter your API Key and API Secret and save the changes.

Your Moodle site is now fully integrated with your video conferencing engine.

Step 3: Add the "PlugNmeet" Activity to Your Course​

1. Navigate to the Moodle course where you want to add the live class.
2. Turn Edit mode on.
3. Click Add an activity or resource and select PlugNmeet from the list.
4. Configure your virtual classroom, giving it a name, a welcome message, and setting the schedule.

That's it. Your students can now join a powerful, interactive virtual classroom directly from their Moodle course page.

Level Up: 3 Powerful Ways to Use Video in Moodle​

Plug-N-Meet is more than just a lecture tool. It's a suite of features designed for modern pedagogy.

Use Case 1: The Interactive Virtual Classroom​

Transform a passive lecture into an engaging, two-way experience.

• How to do it: Use the Interactive Whiteboard to upload your presentation slides and annotate them in real-time. Use the Live Polling feature to quickly check for student understanding or run a quick quiz. All class sessions can be recorded to the cloud and automatically made available back in the Moodle course for students who missed the live session.

Use Case 2: The Collaborative Workshop with Breakout Rooms​

For project-based learning and group work, the Breakout Rooms feature is essential.

• How to do it: From within the live session, the teacher can split the students into smaller groups. Each breakout room gets its own private, fully-functional whiteboard and shared notepad, allowing for true small-group collaboration. The teacher can broadcast messages to all rooms or drop in to a specific group to check on their progress.

Use Case 3: The Secure One-on-One or Parent-Teacher Conference​

For private conversations, you need a higher level of security.

• How to do it: Create a PlugNmeet activity and, in the room settings, enable End-to-End Encryption (E2EE). This provides a mathematical guarantee that the conversation is completely private and that not even the server administrator can access the audio or video. This is ideal for one-on-one student support, counseling sessions, or parent-teacher conferences where confidentiality is critical.

Conclusion: The Virtual Classroom Moodle Deserves​

Stop compromising with external tools that break the learning experience. By integrating Plug-N-Meet, you can offer your teachers and students a powerful, secure, and seamlessly integrated virtual classroom that lives right where it belongs: inside Moodle.

It's a solution that's simple enough for any teacher to use but powerful enough to support the most innovative online teaching methods.

Ready to enhance your Moodle courses?

• Download the official Moodle Plugin
• Try the Live Demo to explore the teaching tools.
• Follow our Installation Guide to get your server running.

What if you could integrate a powerful, secure, and fully-branded video conferencing solution directly into your WordPress site as easily as you add a new page?

This is not just possible; it's simple. This guide will show you how to use the Plug-N-Meet plugin to transform your WordPress site into a true communication hub, whether you need a simple meeting room, a platform for webinars, or a full-fledged, monetized video service.

Why Self-Hosted is the Smart Choice for WordPress​

Before we dive into the "how," let's cover the "why." While embedding a Zoom meeting is an option, a self-hosted solution like Plug-N-Meet offers three transformative advantages for any serious WordPress site owner:

1. You Own Your Brand: Every meeting happens on your own domain, with your logo and your colors. You're not providing free advertising for a SaaS giant; you're reinforcing your own brand's professionalism and trust.
2. You Control Your Data: All data—from user information to recordings—stays on your own server. This gives you absolute control over privacy and is critical for compliance in sensitive industries.
3. You Escape Per-User Pricing: Instead of paying a fee for every host on your team, you have a predictable, fixed cost for your server. This model rewards your growth instead of penalizing it.

The 3-Step Guide to Your First WordPress Meeting​

Getting started is incredibly fast. You can have your first meeting room live in under 15 minutes.

Step 1: Install the Engine (Your Plug-N-Meet Server)​

First, you need the server that will power your video calls. You can either self-host the open-source version with our simple installation script or get an instant, managed server from plugnmeet Cloud. Both will provide you with an API Key and API Secret.

Step 2: Install the Free Plug-N-Meet Plugin​

From your WordPress dashboard:

1. Go to Plugins > Add New.
2. Search for "plugnmeet".
3. Click Install Now, then Activate.
4. Navigate to the new Plug-N-Meet > Settings menu.
5. Enter your API Key and API Secret and save.

Your WordPress site is now fully integrated with your video conferencing engine.

Step 3: Create and Embed Your Room​

1. Go to Plug-N-Meet > Rooms and click Add New.
2. Configure your room's features (e.g., name, max participants, welcome message) and get the Room ID.
3. After saving, the plugin will generate a unique Shortcode for that room (e.g., [plugnmeet_room_view id="your_room_id"]).
4. Create a new WordPress Page, paste the shortcode into the content, and click Publish.

That's it. You now have a fully functional, branded video conferencing room running directly on your own website.

Level Up: 3 Powerful Ways to Use Video on Your WordPress Site​

Once you've mastered the basics, you can leverage Plug-N-Meet to power a wide range of professional services.

Use Case 1: The Private Coaching or Consultation Room​

Are you a coach, consultant, or therapist? You can easily create secure, private rooms for your client sessions.

• How to do it: Create a separate, password-protected page for each client. Embed the shortcode for a unique meeting room on that page. Only the person with the password can access the session, ensuring complete privacy.

Use Case 2: The Community Webinar or Live Event​

Want to host a webinar for your audience? Plug-N-Meet is a powerful open-source webinar platform.

• How to do it: Create a room and configure its features specifically for a webinar. In the room settings, you can disable webcams and microphones for attendees by default, enable Cloud Recording, and use features like Polling and Raise Hand to manage audience interaction. Embed the room's shortcode on your "Events" page and you're ready to go live.

Use Case 3: The Monetized Membership Site​

This is where you can turn your video feature into a revenue stream. By combining Plug-N-Meet with a popular membership plugin (like Paid Memberships Pro, MemberPress, or Restrict Content Pro), you can create premium video content exclusively for paying subscribers. For a detailed walkthrough of this business model, see our guide on How to Launch Your Own No-Code Video Conferencing Service with WordPress.

• How to do it:
  1. Use your membership plugin to create a "Premium" subscription tier.
  2. Create a new WordPress page for your premium content (e.g., "Weekly Mastermind Call").
  3. Paste the Plug-N-Meet room shortcode onto this page.
  4. Use your membership plugin's settings to restrict access to this page so that only users with an active "Premium" subscription can view it.

Now, you have a secure, automated paywall for your exclusive video content.

Unlocking Advanced Features: AI and Zero-Trust Security​

The Plug-N-Meet WordPress plugin isn't just for basic meetings. It gives you simple, one-click access to enterprise-grade features directly from your room settings.

• AI-Powered Meeting Assistants: Imagine having every meeting automatically transcribed and summarized. With the AI features enabled, you can turn your conversations into actionable intelligence. Learn how to add AI features with a simple toggle.
• Zero-Trust Security: For telehealth, legal consultations, or any conversation requiring absolute confidentiality, you can enable End-to-End Encryption (E2EE). This ensures that not even your server can access the meeting's content. Discover more about our privacy-by-design philosophy.

Conclusion: The Professional Video Solution WordPress Deserves​

Stop treating live video as an afterthought. With Plug-N-Meet, you can seamlessly integrate a secure, scalable, and fully-branded video conferencing platform into the WordPress ecosystem you already know and love.

It's a solution that's simple enough to start in minutes but powerful enough to grow with your biggest ambitions.

Ready to power up your WordPress site?

• Download the official WordPress Plugin
• Try the Live Demo to see all the features in action.
• Follow our Installation Guide to get your server running.

This is where Plug-N-Meet's "headless" integration mode comes in.

This guide is for developers who want to move beyond basic embedding. We'll show you how to use the powerful getClientFiles API to render the Plug-N-Meet client directly into your own page's DOM, giving you ultimate control over layout, branding, and the user experience.

The Problem with Iframes​

An <iframe> is a simple way to embed content, but it's essentially a "window" into another website. This creates several limitations for developers aiming for a professional, deeply integrated product:

• The Black Box: The <iframe> creates a hard boundary between your parent application and the video client, making communication between them complex and limited.
• Layout Restrictions: You are stuck with the layout provided by the src URL. You can't easily place your own application's components (like a custom header or a sidebar with user data) "inside" the video experience.
• Styling and Branding: While you can pass some branding parameters, your ability to deeply customize the look and feel is limited.

The Solution: Headless Integration with getClientFiles​

The getClientFiles API is the key to unlocking a truly "headless" video integration. Instead of providing you with a URL to embed, it gives you a list of the exact CSS and JavaScript assets you need to render the client yourself.

This approach transforms Plug-N-Meet from a separate application into a UI component library that you control.

The Three-Step Workflow​

The logic is simple and can be implemented in any backend language (PHP, Node.js, Python, etc.).

1. Your Backend Fetches the Asset List: Your server makes a secure, server-to-server API call to the /auth/getClientFiles endpoint.
2. Plug-N-Meet Responds with a JSON Object: This object contains two arrays: css and js, listing the filenames of all the necessary assets.
3. Your Template Renders the <link> and <script> Tags: Your server-side templating engine loops through these arrays and dynamically injects the required tags into the HTML page that will be sent to the user's browser.

A Practical Example (Node.js with EJS)​

Let's walk through a simplified example using Node.js and the EJS templating engine.

Step 1: The Backend Route (e.g., in server.js)​

This route will handle the API calls and render the final page.

import express from 'express';
import { PlugNmeet } from 'plugnmeet-sdk-js';

const app = express();
app.set('view engine', 'ejs');

// Your Plug-N-Meet credentials (use environment variables in production)
const API_KEY = 'plugnmeet';
const API_SECRET = 'zumyyYWqv7KR2kUqvYdq4z4sXg7XTBD2ljT6';
const PLUGNMEET_URL = 'https://demo.plugnmeet.com';

const pnm = new PlugNmeet(PLUGNMEET_URL, API_KEY, API_SECRET);

app.get('/meeting', async (req, res) => {
  try {
    // 1. Get the asset files
    const clientFiles = await pnm.getClientFiles();

    // 2. Create a room and generate a join token for the user
    const room = {
      room_id: 'my-custom-room',
      metadata: {
        room_title: 'My Custom UI Room',
        room_features: {
          allow_webcams: true,
          // ... other features
        },
      },
    };
    await pnm.createRoom(room);

    const joinToken = await pnm.getJoinToken({
      room_id: 'my-custom-room',
      user_info: {
        name: 'John Doe',
        user_id: 'user-123',
      },
    });

    // 3. Define dynamic branding options
    const designOptions = {
      primary_color: '#004D90',
      secondary_color: '#24AEF7',
      custom_logo: 'https://my-app.com/logo.png',
    };

    // 4. Render the view, passing all the necessary data
    res.render('meeting', {
      plugnmeetUrl: PLUGNMEET_URL,
      clientFiles: clientFiles.res,
      accessToken: joinToken.res.token,
      designOptions: JSON.stringify(designOptions),
    });

  } catch (error) {
    console.error(error);
    res.status(500).send('Error setting up meeting');
  }
});

app.listen(3000, () => console.log('Server started on port 3000'));

Step 2: The Frontend Template (e.g., in views/meeting.ejs)​

This EJS file will take the data from the backend and construct the HTML page.

<!DOCTYPE html>
<html lang="en">
<head>
  <title>My Custom Video App</title>

  <!-- Dynamically inject CSS files -->
  <% clientFiles.css.forEach(file => { %>
    <link href="<%= plugnmeetUrl %>/assets/css/<%= file %>" rel="stylesheet" />
  <% }); %>

  <!-- Inject essential window variables BEFORE loading scripts -->
  <script type="text/javascript">
    window.plugNmeetConfig = {
      // Required: The URL of your plugNmeet server.
      serverUrl: "<%= plugnmeetUrl %>",

      // Required: The public path to the assets directory.
      staticAssetsPath: "<%= plugnmeetUrl %>/assets",
      
      // Required: Pass the design customization options.
      designCustomization: <%- designOptions %>,

      // Optional: Add any other custom configurations.
      // See: https://github.com/mynaparrot/plugNmeet-client/blob/main/src/assets/config_sample.js
      enableSimulcast: true,
      enableDynacast: true
    };
  </script>
</head>
<body>
  <!-- Your Custom Application UI -->
  <header style="background: #0A1929; color: white; padding: 1rem;">
    <h1>My Application Header</h1>
  </header>

  <div style="display: flex;">
    <!-- The Plug-N-Meet client will mount itself in this div -->
    <div id="plugNmeet-app" style="flex-grow: 1; height: 90vh;"></div>

    <!-- Your Custom Application Sidebar -->
    <aside style="width: 250px; background: #f4f4f4; padding: 1rem;">
      <h2>Meeting Notes</h2>
      <p>This sidebar is part of my parent application!</p>
    </aside>
  </div>

  <!-- Dynamically inject JavaScript files -->
  <% clientFiles.js.forEach(file => { %>
    <% if (file.startsWith('main-module.')) { %>
      <script src="<%= plugnmeetUrl %>/assets/js/<%= file %>" type="module"></script>
    <% } else { %>
      <script src="<%= plugnmeetUrl %>/assets/js/<%= file %>" defer></script>
    <% } %>
  <% }); %>

  <script>
    // Add the access token to the URL without reloading the page
    const url = new URL(window.location);
    url.searchParams.set('access_token', '<%= accessToken %>');
    window.history.pushState({}, '', url);
  </script>
</body>
</html>

The Result: A Truly Integrated Experience​

When a user visits /meeting, they will see your application's custom header and sidebar, with the Plug-N-Meet video client rendered seamlessly in the middle. The client will be styled with the dynamic brand colors you passed from the backend.

You have successfully broken out of the <iframe> box.

From here, the possibilities are endless. You can use your own application's state to interact with the meeting, build custom layouts that respond to meeting events, and create a user experience that is completely unique to your product.

This is the true power of a headless, API-first platform. It gives you the building blocks not just to add a feature, but to build a deeply integrated and professional product.

Ready to build your custom UI?

• Review the full getClientFiles API Documentation.
• Explore our Design Customization Guide for more branding options.
• Check out our official JavaScript SDK to simplify your backend code.

What went wrong? You've fallen into the monolith trap.

This post explains how Plug-N-Meet's modern, decoupled architecture is designed to prevent this exact problem, enabling you to scale your service efficiently and control your costs. For a business, this isn't just a technical detail—it's a core financial advantage.

The Monolith Trap: Paying for Empty Seats​

Many traditional video conferencing platforms are built as monoliths. This means the core application, the media processing, and the recording services are all bundled into a single, massive application.

This creates a huge problem when it's time to scale:

• If you need to support more concurrent users, you have to upgrade the entire server, even if your recording service is barely being used.
• If a few large recording jobs are using all the CPU, your live meetings will lag and stutter, forcing you to buy a bigger server just to handle a temporary workload.

A monolithic server is like renting a giant bus for a single passenger. You pay for all the empty seats, and if one part of the bus breaks down, the whole trip is canceled.

The Plug-N-Meet Way: A Decoupled, Intelligent Architecture​

Plug-N-Meet was designed from the ground up to avoid this trap. It is not one giant application; it is a set of specialized, independent services that work together.

The three core components are:

1. plugnmeet-server (The Brain): A lightweight Go application that handles all the API calls, authentication, and business logic.
2. LiveKit (The Media Highway): A high-performance, open-source media server that manages all the real-time audio and video traffic.
3. plugnmeet-recorder (The Factory): A dedicated Go application that handles CPU-intensive tasks like MP4 recording and RTMP broadcasting.

These components are designed to be scaled independently. This is the key to cost-effective growth.

Benefit 1: Scale Only What You Need (Elastic Scaling)​

With a decoupled architecture, you can scale each component based on your actual needs.

• Expecting a huge webinar? You don't need to touch your main application server. Simply spin up a few extra LiveKit media servers for the duration of the event, then spin them down afterward.
• Seeing more users in a specific region? Deploy media servers in that geographic area to reduce latency, without having to replicate your entire backend.

This is like adding more cashiers to a store only during the holiday rush. You get the performance you need when you need it, and you don't pay for idle resources during quiet periods.

Benefit 2: Isolate Your Workloads (Improved Quality of Service)​

In a monolith, a resource-hungry task can degrade the entire user experience. If someone starts a large recording, everyone's live video call could suffer.

Plug-N-Meet's architecture prevents this. Because the plugnmeet-recorder is a separate service, you can run it on entirely different machines from your live media servers.

• The Result: A CPU-intensive MP4 transcoding job will have zero impact on the quality and stability of your live meetings.
• The Benefit: Your users always get a smooth, high-quality experience, which is critical for customer satisfaction and retention.

Conclusion: A Lower Total Cost of Ownership (TCO)​

"Scalable" isn't just a technical buzzword; it's a business feature. The ability to scale components independently and isolate workloads means you are not constantly over-provisioning your hardware. You pay only for the resources you actually use.

As your platform grows, this intelligent design leads to a dramatically lower Total Cost of Ownership (TCO) compared to a monolithic solution. You can grow your user base sustainably without your infrastructure costs spiraling out of control.

Plug-N-Meet's architecture isn't just a technical implementation detail; it's a strategic advantage designed to help your business succeed at scale.

Ready to learn more about scaling?

• Read our detailed Scalable Deployment Guide
• Dive deep into our Backend Architecture
• Get started with the Installation Guide