BigBlueButton single server vs Scalelite cluster

A single BigBlueButton server suits smaller virtual classroom loads with one front end, while Scalelite adds a pool, shared storage and databases that only pay off when capacity, uptime or spread across servers matter.

On this page

When one BigBlueButton server is enough and when a Scalelite pool fits

Run one BigBlueButton server when your virtual classrooms fit within one machine's capacity and a short outage is tolerable. Move to a Scalelite pool when concurrent load outgrows a single server or when uptime requirements mean one node cannot be a single point of failure. The Scalelite README recommends a minimum of 3 BigBlueButton servers in the pool, and it gives around 200 concurrent users as the stated capacity of a single server at the minimum configuration. If your peak concurrency sits well under that figure, one server is the simpler default: fewer components to patch, back up and troubleshoot.

Four factors should drive the decision. First, peak concurrent users, measured in your own timetable rather than average daily use, since classes overlap at the top of the hour. Second, the number of front ends: a single Moodle or Greenlight instance sending API calls to one server is straightforward, while several front ends sharing capacity raise the load you need to plan for. Third, recording volume, because recordings consume disk on every server that hosts them and must be consolidated when you pool. Fourth, in-house skills. Scalelite's README states that setup requires advanced knowledge of BigBlueButton, Linux, Docker, networking and TURN server administration, so confirm that your team already covers those areas before you commit to a pool.

The fairness point in Scalelite's favor is that it presents the pool to front ends such as Moodle or Greenlight as a single, very scalable BigBlueButton server, so the LMS configuration does not change when you add servers. Ask your integration partner or the project to confirm how your specific front end and version behave against a pool before you rely on that, and plan for the extra services a pool adds, including the load balancer, NFS, PostgreSQL and Redis, as ongoing operational work.

Single server and Scalelite cluster compared on the factors that decide the choice

This table sets one BigBlueButton server against a Scalelite pool on capacity, footprint, dependencies, front-end behavior, recording storage, upgrades, licensing and skills. Read each row against your expected concurrent classes and your team's Linux and networking experience, since the advantage in each row only applies under the condition named there.

FactorSingle BigBlueButton serverScalelite pool behind a load balancer
Capacity per serverOne server meeting the minimum configuration supports around 200 concurrent users, according to the Scalelite README. Choose this when peak concurrency stays inside that range with headroom.Capacity grows by adding servers to the pool. Scalelite places new meetings on the least loaded server. Choose this when peak concurrency is expected to exceed one server.
Minimum footprintOne BigBlueButton 4.0 server: 16 GB memory with swap, 8 CPU cores with high single-thread performance, 500 GB disk for recordings (50 GB without recording), per the install docs.The Scalelite README recommends at least 3 BigBlueButton servers in the pool, plus a Scalelite server sized at 4 CPU cores and 8 GB memory, and a database at 2 cores, 2 GB and 20 GB disk. Confirm current sizing in the repository before you order hardware.
Components to runBigBlueButton itself, with its own web server, TCP 80 and 443, UDP 16384 to 32768, Docker for document conversion, and a TURN server for users behind restrictive firewalls.Multiple BigBlueButton servers, the Scalelite server, an NFS shared volume, a PostgreSQL database and a Redis cache with persistence enabled, according to the Scalelite README.
How front ends see the systemMoodle, Greenlight or other front ends connect directly to one BigBlueButton API endpoint and secret.Front ends such as Moodle or Greenlight keep sending standard BigBlueButton API requests, and the pool appears as a single, very scalable BigBlueButton server. Confirm each front end's supported version before cutover.
Recording storageRecordings are stored on the same server, so the 500 GB recording disk sizing in the install docs applies to each server that records.Scalelite consolidates recordings and indexes them in a database, and the shared NFS volume carries them. Storage planning moves to the NFS layer, so confirm its capacity, backup and retention design with your storage team.
Upgrade pathBigBlueButton 4.0 does not support direct upgrades from 2.6, 2.7 or 3.0, so a clean server installation is recommended. Plan a rebuild and data migration for existing installs.Each pool member and the Scalelite server are upgraded and tested together. The clean-install rule still applies to BigBlueButton 4.0 nodes, so plan the pool rebuild as one change window.
LicenseBigBlueButton is LGPL-3.0 licensed and maintained by BigBlueButton Inc., per its GitHub repository.BigBlueButton remains LGPL-3.0. Scalelite is an open source project from blindsidenetworks, but its license must be confirmed in its repository before you rely on it.
Skills requiredLinux administration, BigBlueButton operations, networking and TLS. Suitable for teams that run one service and can accept a single point of failure.Advanced knowledge of BigBlueButton, Linux, Docker, networking and TURN administration, as stated in the Scalelite README. Plan for NFS, PostgreSQL and Redis administration as well.

How much load one BigBlueButton 4.0 server can carry

Plan on one BigBlueButton 4.0 server only after you have measured your own class profile, because the documented minimum is a floor, not a capacity guarantee. The install documentation for 4.0 calls for Ubuntu 24.04 64-bit, at least 16 GB of RAM with swap, 8 CPU cores with high single-thread performance, 500 GB of disk for recordings (50 GB if you turn recording off) and 250 Mbit/s of symmetrical bandwidth. The Scalelite README says a single server meeting that minimum configuration supports around 200 concurrent users. Treat that figure as the Scalelite project's planning reference for the minimum build, and confirm it against your own load tests before you rely on it.

Three factors move real capacity more than the hardware list does. Bandwidth is the first, because every participant's webcam and screen share consumes upload and download on the same 250 Mbit/s link, so a class with many video feeds can saturate the network long before the CPUs are busy. Recording is the second, since it adds processing and disk writes for each session and fills the 500 GB recording allocation over a term. Browser-side load is the third: students on older laptops or phones, many open tabs, and heavy use of shared notes or whiteboards push work onto client machines and change how many people a session can hold. Ask your vendor or the BigBlueButton community which of these your target class sizes stress first, and record the answer.

Before you commit to a server count, run a pilot that mirrors your heaviest real timetable: the largest class size, the share of students who turn on webcams, the share of sessions you will record, and the breakout room pattern your teachers use. Watch CPU, memory, swap use, network throughput and the health of the media path while the test runs, and include TURN traffic if students sit behind restrictive firewalls. If the pilot shows the single server approaching its limits at peak, that is the signal to compare the cost of a larger single build against a pool managed by Scalelite, using the test data as the basis for both estimates.

What Scalelite adds to the stack: servers, NFS, PostgreSQL and Redis

A Scalelite cluster is more than a few extra BigBlueButton servers. The load balancer, a shared NFS volume, a PostgreSQL database and a Redis cache each carry a different part of the work, and each one becomes a new point of failure, backup target and monitoring target. Plan for all of them before you size the pool.

The pool of BigBlueButton servers

Each server in the pool runs its own BigBlueButton media, signalling and recording services and takes new meetings the load balancer assigns to it. The Scalelite README recommends a minimum of 3 servers in the pool, so a single failed server still leaves capacity for classes. Check that every server runs the same BigBlueButton version and that each one has its own monitoring, certificates and firewall rules, because Scalelite will not fix a server that is misconfigured.

The Scalelite load balancer

Scalelite is the single endpoint that front ends such as Moodle or Greenlight call. It checks each server's reachability and load, places new meetings on the least loaded server and consolidates recordings. The README sizes the Scalelite server at 4 CPU cores and 8 GB of memory. If this host fails, every front end loses access to the whole pool, so it needs its own backups, health checks and a documented rebuild path.

The NFS shared volume

Recordings must be visible to the Scalelite side across the pool, and the README lists an NFS shared volume as a required component. A slow or unavailable NFS export can stall recording consolidation and playback, even when every BigBlueButton server is healthy. Ask who owns the storage, how capacity grows with recordings, and how the export is backed up, since recordings can reach hundreds of gigabytes per server.

PostgreSQL and Redis with persistence

PostgreSQL indexes the consolidated recordings, and Redis caches state that Scalelite uses while it routes requests. The README sizes the database at 2 cores, 2 GB of memory and 20 GB of disk, and asks for Redis with persistence enabled. Losing the database breaks recording lookups, so schedule regular dumps and test restores. Add both services to your monitoring alongside the load balancer, not after an outage shows the gap.

Which deployment fits which teaching setup

One institution with a single LMS and modest concurrency usually fits a single BigBlueButton server. The server stays simple to back up, upgrade and troubleshoot, and the front end talks to one endpoint with no load balancer to maintain. The Scalelite README describes a single server meeting the minimum configuration as supporting around 200 concurrent users, which is the figure to test against your own peak class schedule.

  • Single server: One BigBlueButton 4.0 host on Ubuntu 24.04 with 16 GB of memory, 8 CPU cores and 500 GB of disk for recordings, as the install documentation specifies.
  • Clean install: Plan for a fresh server rather than an in-place upgrade from 2.6, 2.7 or 3.0, since direct upgrades are not supported.
  • Shared hosting: Greenlight or LTI can run on the same server through the installer, which keeps the footprint to one box.
  • Change trigger: Peak concurrency that approaches the single-server figure, or a second campus joining the same LMS, is the signal to plan a pool.

Before committing, confirm your peak concurrent users at the busiest hour and how many classes run at once.

How Moodle and Greenlight see a Scalelite pool

Front ends such as Moodle or Greenlight do not need to know that a pool exists. Scalelite presents the pool as a single, very scalable BigBlueButton server, and the front end keeps sending the same standard BigBlueButton API requests it would send to one server. The front end's configuration points at the Scalelite hostname, not at an individual BigBlueButton server. Scalelite then decides which server in the pool hosts each meeting, based on reachability and load. For your planning, this means changes to the pool, such as adding or removing a server, should not require reconfiguring each front end, but you should still confirm this behavior in a test environment before relying on it.

Every API call still has to carry a checksum computed from the secret shared with the server. The BigBlueButton API docs say SHA-256 is the default algorithm, with SHA-1 kept for legacy use and SHA-384 or SHA-512 available since version 2.5. Confirm which algorithm your chosen front-end version sends, and confirm that the Scalelite secret configured for the front end matches the one in the pool. The shared secret must never be embedded in a web page, so check any custom theme, plugin or template for that secret before go-live, and keep it out of client-side JavaScript and public repositories.

For sign-in, Greenlight v3 supports external authentication through OpenID Connect, configured with environment variables. The Greenlight v3 docs suggest Keycloak as a broker if you need Google, Microsoft, SAML or other login methods, since Keycloak can federate those sources and present one OpenID Connect endpoint to Greenlight. Moodle has its own authentication plugins, so the identity design for a Moodle front end is handled in Moodle. Before you commit, confirm the exact front-end and Scalelite version pairing with both projects, because the supported combinations are not part of the supplied material and can change between releases.

What running each model asks of your team

Can I upgrade an existing BigBlueButton server in place to version 4.0?

No, not directly. Direct upgrades from 2.6, 2.7 or 3.0 are not supported for BigBlueButton 4.0, so the install documentation recommends a clean server installation on Ubuntu 24.04. A single server means one clean rebuild, followed by moving your configuration, recordings and any LMS or Greenlight settings across by hand. In a Scalelite pool, you repeat that process for every BigBlueButton server, one at a time, so that the remaining servers keep carrying meetings during each rebuild. Plan a staged cutover, keep the previous build available for rollback, and confirm the migration path with the BigBlueButton project before you commit to a date. Ask your provider how they will sequence the pool rebuild and test it on a non-production pool first.

How do I back up BigBlueButton recordings and the database?

Back up recordings and configuration on every BigBlueButton server, and back up the database on the Scalelite side. On a single server, the recordings sit on the same disk as the server, and the install documentation sizes that disk at 500 GB when recording is enabled, so storage growth is the main recurring cost to plan for. In a pool, recordings are consolidated and indexed by Scalelite in its PostgreSQL database, so you need consistent backups of that database together with the recording files they point to. The Scalelite NFS shared volume also needs its own backup policy. Restore tests matter more than backup jobs: ask your team to restore a recording and a database snapshot into a staging environment before go-live, and document the recovery order.

How do I monitor the health of a Scalelite pool?

Monitor each BigBlueButton server, the Scalelite server, PostgreSQL, Redis and the NFS volume as separate components. Scalelite checks each server's reachability and load and places new meetings on the least loaded server, so a failing server is partly handled by the balancer, but it will not alert your team on its own. On a single server, monitoring centers on CPU, memory, disk growth for recordings, bandwidth and the UDP media ports. In a pool, add checks for the number of servers that pass Scalelite's reachability test, Redis persistence status, database connections and NFS latency, because a shared storage slowdown can affect recordings across the whole pool. Confirm with the Scalelite project which metrics and endpoints it exposes in your version, and build alerting around those rather than assumptions.

Do I need to run my own TURN server for BigBlueButton?

A TURN server is recommended, and it becomes more important as your users sit behind restrictive firewalls. The BigBlueButton install documentation recommends one for users who cannot reach the media ports directly, so it is an extra service you must install, certify, monitor and renew certificates for. On a single server it is one additional host or container to maintain. In a Scalelite pool, the TURN configuration has to be consistent across every BigBlueButton server, and the Scalelite README lists TURN server administration among the skills the setup requires. Ask your team who owns TURN after go-live, how credentials are rotated, and how bandwidth for relayed media is sized. Plan for it in the design rather than adding it after users report failed audio.

What skills does a Scalelite cluster need that a single server does not?

The Scalelite README says setup requires advanced technical knowledge of BigBlueButton, Linux, Docker, networking and TURN server administration. A single BigBlueButton server needs the same BigBlueButton and Linux knowledge, with fewer moving parts, because it has no load balancer, shared volume or database tier to keep consistent. A pool adds Docker to run the Scalelite services, PostgreSQL and Redis administration with persistence enabled, NFS permissions and performance, and networking across several hosts and the balancer. Ask whether your staff can cover those skills for on-call response, or whether you need a partner for the initial build and runbooks. The checklist below is a practical way to test readiness before you commit.

  • Can your team rebuild a BigBlueButton server from a clean install on a set schedule?
  • Can they restore PostgreSQL, Redis and NFS data together?
  • Can they diagnose TURN and firewall failures for end users?
Who pays for ongoing operation of a single server versus a pool?

The cost of ownership recurs in staff time, infrastructure and any support contract, and the mix shifts as you add servers. A single server has the lowest recurring infrastructure footprint, but a single failure takes all classes offline, so you pay in risk rather than hardware. A pool spreads capacity across several BigBlueButton servers and adds the Scalelite server, database, cache and shared storage, each with its own patching and backup work. Your costs come from your own staff, cloud or data center resources, bandwidth, and any external help you buy. Ask any provider for a written quote that separates the one-time build, the first clean rebuild cycle, and the recurring tasks for monitoring, backups, upgrades and TURN, so you can compare the two models on the same basis.

Does DeployOpen run and upgrade BigBlueButton clusters for clients?

DeployOpen plans, implements, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For BigBlueButton, that can cover the initial single server or pool design, the Scalelite build, backup and monitoring setup, runbooks and upgrade work. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts, and ongoing support, upgrades and continuous testing are available as retainers. DeployOpen does not publish a price list, so a quote follows from the written scope. Confirm in that scope how pool rebuilds, TURN administration and on-call response are split between your team and DeployOpen.

How to move from one server to a pool without losing recordings

This sequence takes a single BigBlueButton server to a Scalelite pool with its recordings intact and front ends pointed at the new entry point. Each step ends with a check you can run before moving on.

  1. Size the current load and recordings

    Your team measures peak concurrent users, meeting count and the size of the recordings directory on the existing server, and compares them with the per-server figures in the Scalelite README and the BigBlueButton 4.0 install requirements. Recording storage is the number that most often surprises teams, so measure it before you plan the new disks. The step is done when you have a written peak, a recording inventory and a target pool size that your staff agrees with. This work is internal or led by your DeployOpen engagement lead, and it recurs whenever you resize.

  2. Build clean servers for the pool

    Install every new BigBlueButton server on a fresh Ubuntu 24.04 system rather than upgrading the existing one, since the install documentation says direct upgrades from 2.6, 2.7 or 3.0 are not supported. Confirm each server meets the 16 GB memory, 8 CPU core, 500 GB recording disk and UDP 16384 to 32768 requirements. The step is done when each server answers BigBlueButton API calls with a valid checksum. This is a one-time build per server, and it is performed by your platform engineers following the official install guide.

  3. Provision NFS, PostgreSQL and Redis

    Create the NFS shared volume that the pool uses for recordings, a PostgreSQL database sized to the Scalelite README guidance, and a Redis cache with persistence enabled. Mount the NFS volume on every BigBlueButton server and on the Scalelite host, and confirm that a file written from one host is visible on the others. The step is done when all three services accept connections from the Scalelite host and the NFS mounts are readable and writable on each server. These are one-time builds, but backups and patching recur.

  4. Deploy the Scalelite load balancer

    Install Scalelite on its own host with the Scalelite README's Docker-based procedure, pointing it at the PostgreSQL database, the Redis cache and the NFS volume. Set the Scalelite host to the Scalelite README sizing or larger. The step is done when Scalelite starts cleanly and its health endpoint or admin commands report the database and Redis as reachable. Confirm the exact configuration keys and commands in the official Scalelite documentation, since they change between releases.

  5. Register each server with Scalelite

    Add each BigBlueButton server to the Scalelite pool with its hostname and shared secret, then confirm Scalelite reports each one as reachable and reports its load. Scalelite uses those load checks to place new meetings on the least loaded server. The step is done when a test meeting created through Scalelite lands on a pool member and joins from a browser. Secrets stay on the servers and in your secrets store, never in a web page.

  6. Repoint front ends and test the API path

    Change each front end, such as Moodle or Greenlight, to send its standard BigBlueButton API requests to the Scalelite endpoint and to use the shared secret that Scalelite presents. Create a test meeting from each front end, join it with two users, and confirm the front end shows the meeting and its join links. The step is done when each front end completes create, join and end cycles without errors. Plan a rollback path that restores the old server address in each front end.

  7. Migrate or index existing recordings

    Move recordings from the old server's recording directory onto the NFS volume in the layout Scalelite expects, then have Scalelite consolidate and index them in its database so playback links resolve. Check a sample of recordings from each course or tenant before you decommission the old server. The step is done when a recording from before the migration plays back through the front end and appears in the Scalelite index. Ask the Scalelite maintainers or your DeployOpen engagement lead to confirm the exact import procedure for your version, because the steps depend on the release.

  8. Confirm the procedure and schedule recurring work

    Compare every step with the official Scalelite README and the BigBlueButton install documentation for your versions, and record the deviations in a runbook. Then set up recurring tasks: NFS and database backups, Redis persistence checks, server patching, certificate renewal and capacity reviews as concurrent use grows. The step is done when the runbook is signed off and the recurring tasks have named owners. Build-time steps are one-time, while monitoring, backups and upgrades recur for the life of the pool.

Questions buyers ask before choosing a BigBlueButton deployment

Is one BigBlueButton server enough for our concurrent users?

One server can be enough when your peak concurrency stays below what a single well-sized server handles, and the Scalelite README says a single server meeting the minimum configuration supports around 200 concurrent users. That figure assumes the minimum hardware, so count your peak simultaneous learners and staff, add headroom for growth, and confirm the per-server limit with the BigBlueButton project for your workload mix. Video-heavy classes use far more bandwidth and CPU than audio-only sessions, so test with a realistic class profile before you commit. Also plan for a second server in case the first one fails, since a single server is a single point of failure.

Why does Scalelite recommend at least three BigBlueButton servers?

The Scalelite README recommends a minimum of 3 BigBlueButton servers in the pool. The reason is resilience and headroom: with three or more servers, Scalelite can place new meetings on the least loaded healthy server, and the pool keeps working when one member is down or being upgraded. Treat three as the project's stated floor, not a sizing result for your classes. Confirm with the Scalelite maintainers how a pool behaves during a server failure, and ask whether your peak load still fits when one server is removed from service.

What drives the cost and effort of a single server versus a pool?

The cost has five parts: hardware or cloud instances, bandwidth, staff time to install and operate, outside help, and recurring upkeep. A single server needs at least 16 GB of memory, 8 CPU cores, 500 GB of disk for recordings (or 50 GB without recording) and 250 Mbit/s symmetrical bandwidth, according to the BigBlueButton install documentation. A Scalelite pool multiplies those servers and adds a Scalelite server sized at 4 CPU cores and 8 GB of memory, a PostgreSQL database, a Redis cache and an NFS shared volume. Each extra component adds patching, monitoring and backup work. Your hardware or cloud bill is recurring, while setup labor is largely one-time. Whoever pays for staff time, whether your team or a contractor, will carry most of the ongoing burden.

How long does it take to stand up a Scalelite pool?

The duration depends on your team's skills, the number of servers, your network and how much integration you need, and no researched figure is available for a typical timeline. Setup covers provisioning each BigBlueButton server, configuring TURN for users behind restrictive firewalls, building the NFS volume, PostgreSQL and Redis, wiring Scalelite to your front ends and testing failover. Ask any provider for a written, fixed-scope plan that lists each deliverable and the test evidence it produces. Confirm the schedule against your change-control windows and the upgrade path, because BigBlueButton 4.0 cannot be upgraded directly from 2.6, 2.7 or 3.0 and requires a clean installation.

Can our own staff run a Scalelite cluster without outside help?

Your staff can run it if they already know BigBlueButton, Linux, Docker, networking and TURN server administration. The Scalelite README states that setup requires advanced technical knowledge across those areas. If that skill set is thin, plan for training or outside help, and budget for on-call coverage, since a pool has more moving parts than a single server. Ask whether at least two people can operate each component, and whether the runbooks cover database recovery, Redis persistence and NFS failures.

What should we request in a quote for a BigBlueButton deployment?

Ask for a written, fixed-scope quote that names every server, the Scalelite host, the database, cache and shared storage, and the front-end integrations such as Moodle or Greenlight. Request the sizing basis, the peak concurrency it covers, and the failover test plan. List which items are one-time (installation, integration, documentation, knowledge transfer) and which recur (support, upgrades, monitoring, backups, continuous testing). Confirm who supplies hardware, bandwidth and TURN capacity, and what happens to the pool if you later need more servers. DeployOpen does not publish a price list, so the quote follows from the written scope.

Does BigBlueButton integrate with our identity provider and LMS?

Integration depends on your front end and identity setup. Greenlight v3 supports external authentication through OpenID Connect, configured with environment variables, and its docs suggest Keycloak to add Google, Microsoft, SAML and other login methods. Confirm with your LMS vendor which BigBlueButton versions and API options it supports, and test checksum handling, since every API call needs a checksum computed with the shared secret. Never embed that secret in a web page.

What a pool costs to run and what switching later involves

A pool costs more than the sum of its servers. Each BigBlueButton server in the pool needs the 8 CPU cores, 16 GB of memory and disk for recordings that the install documentation lists for a 4.0 server, plus the bandwidth it carries, and the Scalelite README recommends at least 3 servers. On top of that sit the Scalelite server, the PostgreSQL database, the Redis cache with persistence enabled and the NFS shared volume. Each of these is a separate line on your bill or your hardware plan. Ask your provider or internal platform team to price the pool as a list of these components, not as one per-server figure, and confirm whether recordings are stored on the NFS volume or elsewhere, because that choice drives storage growth.

Most of the cost is recurring. Hosting, bandwidth, storage growth and monitoring repeat every month, and recordings accumulate with use. Upgrades also recur. BigBlueButton 4.0 does not support direct upgrades from 2.6, 2.7 or 3.0, so each major move means a clean server installation, and a pool multiplies that work across every node and the Scalelite layer. One-time costs are the initial build, TURN server setup, hostname and SSL configuration, and testing with your front ends. The largest recurring cost is often people time: someone who understands BigBlueButton, Linux, Docker, networking and TURN administration has to own patching, capacity checks and incident response. Quotes should separate one-time build effort from a recurring support or retainer line, and state who performs each upgrade.

Moving from one server to a pool is a re-architecture, not a configuration change. A single server serves clients directly, while a pool requires the shared NFS volume, the database, the cache and the Scalelite layer to exist before meetings are routed through it. The cost of switching later depends on two things. The first is recordings: existing recordings sit on the original server and must be migrated or kept accessible before the old host is retired. The second is front-end configuration: Moodle, Greenlight or other clients must be pointed at the Scalelite endpoint and their shared secrets reviewed, and any integration that depends on a specific server address needs testing. Plan the pool layout before the first class runs, and document how recordings and front-end settings will move if you start with a single server.

How DeployOpen works on this

DeployOpen plans, implements, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure, so the choice between one BigBlueButton server and a Scalelite pool is settled against your own user counts, network and staffing before any build starts. Engagements are fixed-scope, with the scope agreed in writing first.

How we scope

  • Written scope records expected concurrent users, class sizes and whether recordings are kept.
  • Scope names the front ends, such as Moodle or Greenlight, that will send API requests.
  • Scope states where servers, NFS, PostgreSQL and Redis will run, including your cloud or data center.
  • Quote follows from the written scope, so ask which items it includes and which it excludes.

How we build

  • Install a clean BigBlueButton server on the Ubuntu release that the version's install documentation specifies.
  • Configure ports 80, 443 and UDP 16384 to 32768, a valid hostname for SSL, and a TURN server where needed.
  • For a pool, build the Scalelite load balancer with its PostgreSQL, Redis and NFS dependencies as one tested unit.
  • Test meeting placement, failover of a pool member and recording consolidation before handover.

How we hand over

  • Documentation covers server layout, sizing assumptions, configuration keys and the upgrade path.
  • Runbooks describe backups for recordings, databases and the shared volume.
  • Knowledge transfer targets the staff who will operate the platform after the engagement ends.
  • Confirm with us in writing which artifacts are delivered and in what format.

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers after handover.
  • Upgrades to a new major release are planned as clean installs, since direct upgrades are not supported by the vendor.
  • Retainer scope, response expectations and SLAs are set in writing, so ask for them in the quote.
  • Security testing of the deployed platform can be scoped as a separate engagement.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.