BigBlueButton and Moodle integration

A Moodle site with a BigBlueButton activity needs a server URL and a shared secret pointing at infrastructure you control. This page covers the method, the configuration sequence, data mapping, security and testing.

On this page

How the BigBlueButton and Moodle integration keeps sessions in your infrastructure

The supported way to connect Moodle to your own BigBlueButton is through Moodle's BigBlueButton activity, which calls a BigBlueButton server or a Scalelite pool through the BigBlueButton API and authenticates each call with a shared secret. Moodle creates and joins meetings by sending requests from the Moodle server to your endpoint, so classroom audio, video, chat, slides and recordings are handled on servers in your cloud account or data center. For a university or training provider that wants live classes on its own servers, three decisions shape the design: which endpoint Moodle calls, where the secret is stored, and which team owns both ends of the connection.

The integration covers the path between Moodle and your BigBlueButton endpoint. That includes the server URL and shared secret entered in Moodle, meeting creation and join requests, and how recordings become available inside a course. It does not cover the surrounding platform work. Building and sizing the BigBlueButton servers, configuring TLS, opening the required ports, scaling a Scalelite pool, managing identity for students and staff, and designing courses all need their own plan. Confirm that your Moodle release and your BigBlueButton release are compatible, including any plugin version the activity depends on. BigBlueButton 4.0 installs on Ubuntu 24.04 and does not support direct upgrades from 2.6, 2.7 or 3.0, so check whether your current server can be upgraded in place or needs a clean installation.

The shared secret is the control you will manage most often. BigBlueButton requires every API call to carry a checksum computed with that secret, using SHA-256 by default, and the documentation warns never to embed the secret in a web page. In practice, the secret should exist only in the Moodle and BigBlueButton or Scalelite configuration, be generated with enough randomness to resist guessing, be readable only by administrators, and be rotated during a planned change window. Ask the implementation team which checksum algorithm the activity uses with your BigBlueButton release, since SHA-384 and SHA-512 are supported from version 2.5 and SHA-1 remains for legacy use. Record who holds the secret and where backups of Moodle configuration are stored.

Before the first live class, run a short verification in a non-production Moodle course. Create a meeting, join it from two browsers using a teacher account and a student account, confirm audio, slides and chat, end the session, and check that the recording appears where expected and only for permitted users. If you use Scalelite, confirm that a second session lands on another server in the pool and that recordings from every node are reachable. Also confirm that the Moodle server can reach your endpoint on TCP 443 and the UDP media range, because a successful login test does not prove that media will flow. Write these checks into the handover so operations staff can repeat them after every upgrade.

What you need before connecting Moodle to BigBlueButton

Connecting Moodle's built-in BigBlueButton activity to your own server depends on decisions made before anything is installed. The cards cover the BigBlueButton 4.0 server, the storage and bandwidth it needs, the network path learners use to reach it, and the version pairing that determines which Moodle release you can connect. Check each item against your environment before you order hardware or open a change request.

Server size and operating system

A BigBlueButton 4.0 server installs on Ubuntu 24.04 64-bit and needs at least 16 GB of RAM with swap configured, plus 8 CPU cores with high single-thread performance. Confirm these figures against the install documentation for the exact release you plan to run. Check that your cloud instance type or data center host provides the single-thread performance, because the core count alone does not confirm it. Size for your expected number of concurrent classes, not only the minimum.

Storage and bandwidth

Plan 500 GB of disk if recordings stay on the server and 50 GB if you disable recording. Budget 250 Mbit/s of symmetrical bandwidth, since learners send audio, video and screen content upstream as well as receiving it. Recording storage grows with usage, so decide who owns retention, archiving and deletion before go-live. Confirm how course recordings will be retrieved from the server when Moodle links to them.

Network ports and firewall rules

Keep TCP ports 80 and 443 reachable for web access, and open UDP ports 16384 to 32768 for media traffic. Firewalls and proxies at campus or corporate edges are a common cause of failed audio and video, so test from the networks your learners actually use. A TURN server is recommended for users behind restrictive firewalls, and it needs its own sizing and certificate planning.

Valid hostname for SSL

BigBlueButton requires a valid hostname so that it can obtain and renew SSL certificates, which means a DNS name that resolves to the server. Choose the name before installation, because changing it later means reconfiguring the server and the server URL and shared secret that Moodle stores. Confirm with your security team which certificate authority and renewal process your organization requires.

Docker for document conversion

BigBlueButton converts uploaded presentations with LibreOffice running in a sandboxed Docker container, so Docker must be available on the server. Check that your hosting policy allows Docker on the host, since some hardened images and managed platforms restrict container runtimes. Test with the file types your teachers upload, such as large slide decks and spreadsheets, because conversion problems usually appear at upload time rather than during a session.

Clean install and release pairing

Direct upgrades from BigBlueButton 2.6, 2.7 or 3.0 to 4.0 are not supported, so plan a clean server installation and move content and recordings separately. Then confirm which Moodle release supports the BigBlueButton release you choose, using the vendor's compatibility information, before you connect the activity. Record both version numbers in your change plan so that every later Moodle upgrade is checked against the BigBlueButton release in use.

Choosing a single BigBlueButton server or a Scalelite pool

Start with the number of sessions that will run at the same time, not the number of students or courses. A single BigBlueButton server is the simpler choice when your peak concurrent load fits on one machine with headroom left for the spikes that come with a class start time. A Scalelite pool is worth its added components when one server cannot carry peak load, when you want a second server to take over if the first is down, or when you need to add capacity without changing the Moodle configuration. Scalelite is an open-source load balancer that presents the pool to Moodle as one server and sends each new meeting to the least loaded server behind it.

The added components are real. Scalelite uses a PostgreSQL database, a Redis cache and an NFS shared volume where recordings are written so that every node can serve them. Each of these needs its own installation, backups, patching and monitoring. The shared volume also becomes a single point of failure for recordings unless you design its storage and recovery deliberately. Ask your implementation partner to show how a failed BigBlueButton node is removed from the pool and how in-progress meetings are handled, and confirm both behaviors in your own test environment before you rely on them.

Four drivers should decide the topology. The first is peak concurrent sessions, measured in attendees and in simultaneous meetings. The second is recording volume: if teachers record most sessions, the disk and NFS sizing matters more than the CPU. The third is availability expectations. If a class can wait a few minutes for a restart, one server may be acceptable, but if exams or office hours run on fixed schedules, a pool with spare capacity is easier to defend. The fourth is operations skills in-house. A pool adds a database, a cache, shared storage and load balancer configuration to the team's workload, so a team without experience in those areas should price that effort into the decision.

Size from your own class schedule rather than from a generic figure. Pull the last term's timetable from your LMS or student information system, count the sessions that start within the same window, and multiply by the expected attendees per session. Add the breakout rooms and the recording volume you expect from those sessions. Repeat the exercise for your heaviest week, such as the first week of term or exam preparation. Vendor minimums and community examples are useful for checking hardware, but they do not describe when your classes overlap. Ask your partner to base the sizing on this schedule and to state the assumptions in writing so they can be revisited each term.

Plan the decision as a checkpoint, not a one-time purchase. Document the peak load you measured, the failure you are designing for, and the team member who will operate the pool. Revisit the decision when enrollment grows, when a new course format adds long recorded sessions, or when the team changes. Confirm the current BigBlueButton release and its hardware requirements with the project documentation before you order servers, because requirements change between major versions.

How to configure the BigBlueButton activity in Moodle step by step

This sequence connects Moodle's built-in BigBlueButton activity to a BigBlueButton server or Scalelite pool that you operate. It ends with a verified join from two browsers and a recording that plays back inside a course, so the team knows the path works before instructors depend on it.

  1. Prepare the server with a valid HTTPS hostname

    The platform team installs BigBlueButton 4.0 on a clean Ubuntu 24.04 64-bit server, or prepares the Scalelite load balancer that fronts your BigBlueButton servers. Direct upgrades from 2.6, 2.7 or 3.0 are not supported, so a clean installation is the recommended starting point. Give the server a public hostname with a valid certificate, because SSL requires a valid hostname. Check: opening the hostname in a browser loads the BigBlueButton front end over HTTPS with a trusted certificate.

  2. Confirm firewall ports and server sizing

    Open TCP ports 80 and 443 and UDP ports 16384 to 32768 so clients can reach the server. Confirm the host meets the 4.0 minimums in the install documentation: 16 GB of RAM with swap, 8 CPU cores with high single-thread performance, 500 GB of disk for recordings (50 GB without recording) and 250 Mbit/s symmetrical bandwidth. Install Docker for sandboxed document conversion, and plan a TURN server for users behind restrictive firewalls. Check: the hostname answers on port 443 from an outside network, and a test client can exchange media over the UDP range.

  3. Retrieve the server URL and shared secret

    Record the public base URL of the BigBlueButton server or the Scalelite load balancer. For a Scalelite pool, use the load balancer URL, which makes the pool appear as one server. Retrieve the shared secret with the method described in the install or API documentation for your version, and confirm the command before you run it. Store the secret in your secrets manager and share it only through a channel you control, because every API call is signed with it and it must never appear in a web page. Check: an API call with a checksum computed from the secret returns a success response.

  4. Enter the URL and secret in Moodle

    A Moodle administrator opens the BigBlueButton settings in the site administration area and enters the server URL and shared secret. The exact menu path and field names depend on the Moodle version in use, so confirm them against the documentation for that version before changing production settings. Save the settings and record the change in your change log. Check: the settings page saves without error, and any connection check your Moodle version offers reports the server as reachable.

  5. Create a test activity in a sandbox course

    A course administrator creates a sandbox course, adds a BigBlueButton activity and sets the options that matter for your rollout, such as recording behavior and participant roles. Use test accounts, not a live class roster. Open the activity to start a session, then check the server's meeting listing through the API or admin tools to confirm the meeting exists on your infrastructure. Check: the activity opens its room without an error, and the meeting appears in the server's listing while it runs.

  6. Run a join from two browsers

    Open the test activity in two separate browser sessions, one signed in as a teacher and one as a student test account. Join from both, then confirm audio, video and chat work in each direction. Check that moderator controls appear only for the moderator role. If students will join from home or mobile networks, repeat the test from a network outside your office. Check: both participants see each other in the participant list, exchange audio and chat without errors, and the server lists two participants.

  7. Verify recording creation and playback

    Start recording during the test session, end the meeting and wait for processing to finish. Reopen the activity and confirm the recording appears in its recordings list with the expected name and length. Play it back in a browser account that did not host the session. Check: the recording plays with audio and slides, and the visibility and deletion options follow the permissions you set for each role. Record the Moodle and BigBlueButton versions tested so the rollout has a baseline.

Mapping Moodle roles, sessions and recordings to BigBlueButton

This table shows how Moodle's roles, course and activity identifiers, and session events line up with BigBlueButton's moderator and viewer permissions, meeting identifiers, and recording artifacts. Read each row as a decision to confirm in your own Moodle and BigBlueButton configuration before go-live, and treat the default role rules as something to verify in your version rather than assume. The main takeaway is that the server URL and shared secret belong in site-level configuration, never in course content.

Integration itemWhat maps or is configuredWhat to confirm before go-live
Teacher roleMapped to BigBlueButton moderator permissions in the meetingConfirm which Moodle capabilities your version checks before granting moderator status
Student roleMapped to BigBlueButton viewer permissions by defaultConfirm whether students can publish webcam, share screen or upload slides in your setup
Course admin roleMapped to moderator-level access for course meetingsConfirm whether site admins and course admins receive identical meeting permissions
Course and activity identifiersMoodle course and activity IDs are used to derive the BigBlueButton meeting identifierConfirm that identifiers stay stable across course copies, restores and activity duplication
Server URL and shared secretStored in Moodle site-level plugin settings and used to sign API calls, never placed in course contentConfirm that course editors cannot view these values and that the secret is rotated under your process
Session start eventCreates the BigBlueButton meeting on your server or Scalelite poolConfirm which server or pool receives each course's meetings when multiple servers exist
Session end eventCloses the meeting and triggers recording processing on the BigBlueButton sideConfirm how recordings that are still processing appear in the course activity
Recording artifactsStored on the BigBlueButton server or shared volume and linked back to the activityConfirm retention, deletion and access rules for recordings against your records policy

Keeping recordings and student data inside your own infrastructure

Recordings, chat messages, poll results, shared notes and participant details from a BigBlueButton session started through Moodle are education records under FERPA when an institution maintains them for a student, and personal data under the GDPR when the individual is in the EU. Children under 13 add a third regime, COPPA. Which of these apply depends on jurisdiction, the age of participants and who holds the data. Decide this before go-live, then map where each artifact is stored: the BigBlueButton server disk, the NFS volume used by Scalelite for recordings if you run a pool, the PostgreSQL and Redis services, and the course storage in Moodle where published recordings are linked.

For US institutions, the key FERPA question is whether anyone outside the institution can see the data. Under 34 CFR 99.31(a)(1), a contractor may act as a school official only if it performs a service staff would otherwise do, stays under the institution's direct control for the use and maintenance of the records, and honors redisclosure limits. Hosting BigBlueButton, Scalelite and Moodle in infrastructure you control keeps that direct control clear. You must also limit administrator and support accounts to people with a legitimate educational interest (34 CFR 99.31(a)(1)(ii)). Under 34 CFR 99.32, each disclosure of personally identifiable information must be recorded, with the parties and their interests, for as long as the records are kept. Confirm whether the Moodle and BigBlueButton logs capture this, or whether you need a separate audit trail.

For EU data subjects, the GDPR (Regulation (EU) 2016/679) governs how recordings and chat data are collected, used and kept, and it applies wherever the data is physically processed. Your legal or compliance team should confirm the lawful basis for recording, how participants are told a session is recorded, and how access and erasure requests will be handled for recordings that are spread across a server, a pool and an LMS. If children under 13 are in the classes, COPPA's rule on written retention, 16 CFR 312.10, requires a written data retention policy with a deletion timeframe, and the operator may keep children's personal information only as long as reasonably necessary for the purpose collected. Written security program and risk assessment duties in 16 CFR 312.2 and 312.8 also apply.

Legal or compliance review should confirm which regimes apply to each course, cohort and jurisdiction before the server design is final. You decide the retention periods, the deletion timeframes and who approves a deletion. The engineering team can then build the controls that enforce those decisions: recording retention jobs, deletion procedures for the server and NFS storage, restricted administrator roles, protected storage of the shared secret used for API calls, and logs that show who accessed what. For Title IV institutions, the Safeguards Rule (16 CFR Part 314) also requires multi-factor authentication for anyone who accesses an information system, so confirm how that applies to the BigBlueButton and Moodle administrator accounts. Ask for these items in writing as part of the scope.

Securing the shared secret, endpoints and recording access

Connecting Moodle to a BigBlueButton server creates a trust relationship built on a shared secret that signs every API call, an endpoint that students reach from the internet, and recordings that outlive each session. The cards below cover the secret, the server that holds it, the transport that carries it and the access model for recordings. None of these settings should be assumed to be enforced by default, so confirm each one in your own environment.

Checksum algorithm choice

Every BigBlueButton API call carries a checksum computed from the shared secret. SHA-256 is the default, SHA-384 and SHA-512 are supported since version 2.5, and SHA-1 is kept only for legacy use. Confirm which algorithm your server and the Moodle activity both expect, since a mismatch causes create and join calls to fail. Where your versions allow it, plan to move off SHA-1 and test a join from a student account after each change.

Keeping the secret server-side

The shared secret must never appear in a web page, theme file, Moodle block, JavaScript file or public repository, because anyone who can read page source could create meetings and sign API calls. Check rendered HTML and browser network traffic for the secret, and review who can edit themes and plugins. Document where the secret is stored on each server and in Moodle, who can change it, and the change window for rotation. Rotation touches every holder at once, so test a join after the change and record the date of the last rotation.

Restricting administrative server access

Administrative access to the BigBlueButton server gives control over every meeting, every recording and the shared secret. Limit SSH to named administrators through a bastion host or VPN, use key-based login and keep the host firewall aligned with the required ports: TCP 80 and 443, plus UDP 16384 to 32768 for media. Review sudo rights on each server and each Moodle host, and keep a log of administrative sessions that someone reviews on a set schedule.

TLS on the public hostname

BigBlueButton needs a valid hostname for SSL, and students and Moodle reach it over HTTPS on port 443. Use a certificate issued for the public hostname, confirm the full chain is served so browsers accept it, and assign a named owner for renewal so expiry does not depend on one person. Verify that the Moodle server URL uses https, that expiry is monitored, and that any load balancer or proxy in front of the servers terminates TLS consistently. Recheck the endpoint after every renewal.

Limiting who sees recordings

Recordings can contain student voices, images, chat and shared files, so their visibility is a privacy decision as well as a configuration one. Decide who may record, where recordings are published in Moodle and how long they remain available. Test access with a student account enrolled in a different course, and confirm how recording links are shared and whether they can be opened outside Moodle. Where recordings identify students, ask counsel whether FERPA's access and recordkeeping duties apply to them.

MFA for administrators

Where the institution participates in the Title IV programs, its Program Participation Agreement commits it to the GLBA Safeguards Rule (16 CFR Part 314), which requires multi-factor authentication for anyone accessing an information system. That reaches administrators of the BigBlueButton servers, any Scalelite nodes and the Moodle site hosting the activity. Confirm which accounts hold these roles, enforce a second factor for SSH or VPN access and for Moodle administrator logins, and keep a short list of exceptions, each with an owner and an end date.

Why the BigBlueButton activity fails to join or record

This table lists the failures most often seen when Moodle's BigBlueButton activity cannot join a session or save a recording. Each row pairs a symptom with its likely cause, the check that confirms that cause, and the fix. Work through the checks in order, since several symptoms share the same first cause.

FailureLikely causeCheck that confirms itFix
Join fails with a checksum errorThe shared secret changed on the server but not in MoodleCompare the secret in the Moodle activity settings with the secret reported by the BigBlueButton serverUpdate the secret in Moodle, then test with a new meeting
Users join but hear no audio or see no videoUDP ports 16384 to 32768 are blocked by a firewall or cloud security groupTest UDP reachability to the port range from a client network and review firewall rulesOpen UDP 16384 to 32768 to clients; deploy a TURN server for restrictive networks
Browser shows certificate or connection errorsThe server has no valid hostname for SSL, or the certificate does not match the hostnameConfirm DNS resolves the hostname, the certificate covers it, and TCP 443 is reachableUse a valid public hostname with a matching certificate, and use the same name in Moodle
Meetings stop working after a server moveMoodle still points to the old server URLCompare the server URL in Moodle with the current hostname of the BigBlueButton server or ScaleliteUpdate the server URL in Moodle and retest the join and create actions
Some meetings fail to start during busy periodsA Scalelite node is missing, disabled or registered with the wrong secretReview the node list in the Scalelite pool and confirm each node responds and is enabledRe-register the node with the correct secret, enable it, and confirm meetings reach it
Recordings are missing or incompleteThe disk was sized for the server without recording storageCheck free space on the recording path and confirm disk sizing matches the recording requirementProvision recording storage, then confirm the path has room and recordings publish
Recordings missing in a Scalelite poolThe NFS shared volume for recordings is not mounted on every nodeConfirm the recording volume is mounted on each pool node and written to by test sessionsMount the shared volume on all nodes and rerun a test recording from each
Checksum accepted or rejected unexpectedlyThe legacy SHA-1 setting is still in use on one side of the integrationConfirm the checksum algorithm configured in Moodle and on the server, and the server versionAlign both sides on SHA-256 or stronger, and retire SHA-1 after testing

Testing BigBlueButton sessions in Moodle before students join

A pre-launch test plan should prove three things: the Moodle activity reaches your own BigBlueButton server or Scalelite pool, each role sees the right controls and recordings, and the shared secret never reaches a student's browser or a log file. Run the plan in a staging course that mirrors your production settings before any student is enrolled. Write each test as a scripted case with a named owner, the expected result, and the evidence you keep, such as a screenshot, a log extract or a recording link. Vague sign-off on a call is not enough for an audit trail.

Start with joins. Test a join from a desktop browser and from a mobile device, since audio, camera and screen-sharing behavior often differs between the two. Then test a student on a restrictive network, such as a campus or corporate firewall that blocks UDP. BigBlueButton needs TCP 80 and 443 and UDP 16384 to 32768, and the install documentation recommends a TURN server for users behind strict firewalls. Confirm with your network team which path a blocked student takes, whether media falls back through TURN, and what happens if it cannot connect. Record the result for each network you expect students to use.

Next, test a teacher-moderator session end to end. Confirm that the moderator can start the session from the course, create breakout rooms, launch a poll, and end the meeting, while a student joined as a viewer cannot do those things. Check that breakout room participants return to the main room correctly and that poll results display for the moderator as intended. Also confirm the role mapping that Moodle passes to BigBlueButton, because a mismatch there is the most common cause of students gaining moderator controls.

Create a recording during a test session, then play it back from inside the course. Check how long the recording takes to appear, and confirm where it is stored. On a single server, recordings use local disk, and the install documentation's 500 GB recording figure is the planning guide for that. In a Scalelite pool, the shared NFS volume holds them, so confirm that every node can write to and read from it. Then test visibility: an enrolled student should see the recording, while a user from another course, a guest and a logged-out visitor should not. Ask your vendor to confirm how recording links behave if they are shared outside the course.

Size concurrency to the expected peak, using your timetable to estimate how many sessions run at once, then load test at that level. Watch CPU, memory, swap and bandwidth against the install minimums (16 GB of RAM with swap, 8 cores and 250 Mbit/s symmetrical bandwidth for a 4.0 server). If you use a pool, stop one server during a test session and restart it, then confirm how active meetings end and whether new meetings land on the remaining servers. Finally, search the Moodle logs, web server logs, proxy logs and BigBlueButton logs for the shared secret string, and inspect page source for the activity launch. Any hit is a failed test, and the fix is part of the go-live gate.

Questions buyers ask before hiring help with the Moodle integration

What drives the cost and effort of a BigBlueButton Moodle integration?

The main drivers are the number of BigBlueButton servers, whether you run a Scalelite pool, how long recordings are kept, your identity and LTI decisions, and how much testing the rollout needs. Each one changes the work. A single server needs one installation, one hostname with a valid SSL certificate and one shared secret for Moodle. A pool adds Scalelite, PostgreSQL, Redis and an NFS shared volume for recordings, plus more network and capacity planning. Recording retention sets storage: according to the BigBlueButton install docs, a 4.0 server needs 500 GB of disk for recordings, or 50 GB without recording. Identity choices and testing scope add further effort. Ask for each driver to be priced separately in the quote.

Can our own team set up the Moodle integration without outside help?

Yes, if your team has Linux administration, networking and Moodle administration skills. The Moodle connection itself is configuration: the activity needs your server URL and shared secret, and the server needs a valid hostname and SSL. The gaps usually sit in the surrounding work. Firewall rules must allow TCP ports 80 and 443 and UDP ports 16384 to 32768, a TURN server is recommended for users behind restrictive firewalls, and LibreOffice document conversion relies on Docker. Teams with no one who has run a Linux server in production often find the Moodle side easy and the infrastructure side slow. A useful test is whether someone on your team can install BigBlueButton 4.0 on Ubuntu 24.04 and explain how each check is done.

How long does a BigBlueButton and Moodle integration take?

Duration depends on scope, and this page does not give a figure. The main variables are the number of servers, whether a Scalelite pool is needed, how many Moodle sites or courses must be connected, your identity and LTI decisions, how much testing is required before go-live, and how quickly your infrastructure team can provide hosts, DNS records and certificates. A single server with one tested Moodle connection is a much smaller job than a pool with recordings, identity integration and load testing. The most reliable way to get a number is a written scope. Ask for the timeline in the scope document, with the assumptions behind it listed, so you can see what would change it.

What does the work need from our team and infrastructure?

Most of the input is needed before the build starts. You provide access to the environment where the servers will run, including the cloud account, data center or air-gapped network, and the accounts needed to build and operate it. You also provide hostnames for the BigBlueButton server or Scalelite endpoint, DNS records, and SSL certificates or a process to issue them. Your Moodle administrators confirm the Moodle version, plugins and the courses that will use the activity. Your teaching team shares the class schedule so maintenance windows avoid live sessions. Decide early how long recordings are kept, who can delete them and where they are stored. If FERPA applies to you, the regulation requires institutions to keep a record of disclosures of personally identifiable information from education records, so have your compliance lead confirm retention and access rules before go-live.

Is a fixed-scope engagement typical for this kind of work?

Yes, most DeployOpen engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. For an integration like this, a fixed scope usually names the server count, whether a Scalelite pool is included, the Moodle sites and courses in scope, the identity method, the test cases and the handover items. Anything outside that list is handled as a change agreed in writing. This suits organizations that want a defined deliverable before committing budget. The trade-off is that unclear requirements take longer to settle later, so the discovery conversation matters. DeployOpen does not publish a price list. A quote follows from the written scope, so bring your environment details and expected courses to the first call.

What does ongoing support cover after the Moodle integration goes live?

Ongoing support is available as a retainer, and its exact coverage is defined in the agreement. Typically the scope covers monitoring the BigBlueButton servers and any Scalelite pool, applying BigBlueButton maintenance releases on your change schedule, checking that the Moodle activity still connects after Moodle or plugin updates, and reviewing recording storage and backups. It can also include incident handling and changes to server capacity. BigBlueButton 4.0 does not support direct upgrades from 2.6, 2.7 or 3.0, so moving an older deployment forward is a planned migration onto a clean server and should be scoped as one. Confirm response expectations in writing, since this page does not state service levels.

How should the shared secret be handled between Moodle and BigBlueButton?

Store the shared secret only on the Moodle server and on the BigBlueButton side that needs it, and never place it in a web page or client-side script. The BigBlueButton API requires a checksum computed with that secret on every call. According to the API docs, SHA-256 is the default, SHA-1 remains for legacy use, and SHA-384 or SHA-512 are available since version 2.5. Confirm that the Moodle activity uses a checksum algorithm your server accepts, and test it after each upgrade. Rotate the secret in a planned change window, updating the server and Moodle together, because a mismatch stops meetings from starting. Keep the secret in your secrets manager or protected configuration, and limit which Moodle administrators can view it.

How DeployOpen scopes, delivers and supports the Moodle integration

DeployOpen plans and implements the connection between Moodle's built-in BigBlueButton activity and a BigBlueButton server or Scalelite pool that you run in infrastructure you control. Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. Ongoing support, upgrades and testing are available as retainers.

How we scope

  • The written scope names the Moodle and BigBlueButton versions and the hosting model for the server or pool.
  • Network needs are reviewed up front: ports 80, 443 and UDP 16384 to 32768, plus a valid hostname.
  • Scope records which courses, roles and recording rules apply, and who in your organization approves each setting.

How we build

  • Install BigBlueButton 4.0 on a clean Ubuntu 24.04 64-bit server sized to the published hardware requirements.
  • Configure Moodle's BigBlueButton activity with the server URL and shared secret, and keep the secret out of web pages.
  • Connect a Scalelite pool when concurrent classes need load balancing, and test recording storage on the shared volume.

How we hand over

  • Handover covers documented settings, checksum and secret rotation steps, and recording access rules for course instructors.
  • Test cases cover joining, moderator controls, breakout rooms, recording playback and a lesson run by a teacher account.
  • Operators receive runbooks for upgrades, backups of recordings and any database in use, and log locations for troubleshooting.

How we support

  • Upgrades from 2.6, 2.7 or 3.0 to 4.0 are not direct, so a clean server installation is recommended.
  • Ongoing support is available as a retainer for monitoring, patching and maintenance releases on the 3.0 or 4.0 branch.
  • Changes to Moodle or the server are tracked against the written scope and agreed deliverables.

Sources and further reading

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.