Building a client portal for corporate training buyers

Featured image with a butter yellow pastel background and a zigzag pattern, showing the post title "Building a Client Portal for Corporate Training Buyers"

Building a client portal for corporate training buyers

A client portal for corporate training buyers is a login where a client’s training manager books seats, sees rosters and attendance, and downloads invoices and certificates without emailing your team. Build it around six buyer jobs, a small role model, one client key stamped on every record, and server-side checks on every request.

Companies that buy training for their staff keep asking the same questions: who is booked, did they attend, where is the invoice, where are the certificates. A portal answers those without an account manager in the middle. It also puts every client’s data behind one login system, which makes security the hard part of the build.

Key takeaways

  • Design from six buyer jobs: find and book seats, see the roster, confirm attendance, pay against a purchase order, collect certificates and request new training.
  • Use four client roles (admin, coordinator, finance, viewer) plus a client attribute, and keep learners on a separate login.
  • Stamp the paying client on each enrollment and order when it is created. Do not scope by the learner’s current employer.
  • Enforce deny-by-default checks on the server for every request, file download and export, and test them with two clients, never one.

What do corporate training buyers need from a client portal?

Corporate buyers need six things: to find and book seats, see who is attending, confirm attendance after delivery, pay and reconcile invoices, collect certificates, and ask for new training. Published portals from training software vendors are built around these jobs. Start from the jobs, then work out which data each one touches.

Arlo’s Organization Portal announcement (May 2026) says client contacts can browse private courses, see who is registered, add or remove attendees, resend joining instructions, view attendance, results and certificate status, and request new private courses. The aXcelerate client portal guide (May 2026) adds a purchase order number entered at booking that carries through to the invoice, and certificates that clients can download in bulk.

Buyer job What the portal does Data it reads or writes
Book seats Shows public sessions and this client’s private sessions; reserves seats, names can follow later Session visibility, capacity, client-specific price
See the roster Lists attendees per session; swaps or cancels a delegate; resends joining instructions Enrollments, delegate contact details
Confirm attendance Shows who attended, was absent or completed Attendance and completion records
Pay and reconcile Captures a PO number; lists invoices and their status Orders, PO numbers, invoices
Collect certificates Downloads one or many certificates Issued certificates, expiry dates
Ask for training Submits a request for a private course or extra dates Request records, account owner

The table is our own synthesis of those two vendor pages and common B2B booking needs, not a standard. Group bookings, where one order holds a seat line per delegate and names arrive later, are covered in our guide to the registration and payment workflow.

Should buyers book directly or send a request?

Let buyers book directly only when price and capacity are fixed. If you negotiate private-course pricing or hold limited seats, use a request that your team approves. aXcelerate’s portal works this way: clients submit enrollment requests, and the provider’s admin team reviews and confirms them.

Who should be able to do what in a client portal?

Give each client four roles: an admin, a coordinator who books and names attendees, a finance contact and a read-only viewer. Tie every role to one client, and optionally to a department or cost center. Keep learners on a separate login. Permissions then answer two questions: what the person can do, and for whom.

Role Typical person Can Cannot
Client admin Training or L&D manager Invite and remove portal users, book, cancel, see every roster and invoice for the client See other clients, change prices
Coordinator Team lead, HR assistant Book seats, name or swap attendees, see rosters in their department See invoices, manage users
Finance contact Accounts payable See invoices, PO numbers and statements See rosters beyond what an invoice line needs
Viewer Compliance or audit lead Read attendance and certificates Change any record
Provider staff Account manager, support agent Use a “view as client” mode for support Act silently: every session is logged

This is a starting design. Add roles only when a real client needs one, because a role list that grows per client becomes hard to audit.

Why keep learners out of the buyer portal?

Learners need their own record that follows them across employers, while buyers need an organization’s view. Arlo makes the same split: learners use a separate Customer Portal, not the Organization Portal. One login for both invites mistakes, such as showing an employer a learner’s history with other companies.

Pro tip: Let clients own their user list. Make each client admin approve and remove their own portal users, and prompt them to review that list every quarter. Your support team cannot know who left the client last month, and stale accounts are how access outlives employment.

How do you scope each client’s data in a client portal?

Stamp the paying client on every record when it is created, and filter every query by that stamp. Use the client that booked or paid, not the learner’s current employer. aXcelerate describes the same rule: visibility follows the organization recorded on the enrollment, so a learner who changes jobs does not carry history across.

Our TMS data model walkthrough describes the enrollment, session and order records this builds on. The scoping key differs by object:

Object Scope by Common mistake
Enrollment and roster Billing client stored on the enrollment Joining to the learner’s current employer
Session Public flag, or an allow-list of clients for private sessions Listing a private session because the URL is hard to guess
Order, PO and invoice Billing client on the order Showing finance users learner details that the invoice does not need
Attendance and certificate Inherited from the enrollment Scoping by learner ID alone
Department or cost center Extra attribute on the enrollment, checked for coordinators Adding it later without backfilling old rows

Put the filter in one shared function or data layer that every screen, API and export calls. Database row-level security can act as a backstop, but it does not replace the application check. We cover tenancy models in a separate guide.

What about files, exports and emails?

Files and exports leak more often than screens, because they are built later and skip the shared filter. The OWASP Authorization Cheat Sheet says static resources must be included in access control policies. That covers certificate PDFs, invoice downloads, CSV rosters and links in joining-instruction emails.

Make every download URL re-check the caller against the record, even when the link is signed or short-lived. Run exports through the same scoping function as the roster screen.

Which architecture should you build the client portal on?

There are three build routes: use the portal module of your TMS or LMS, assemble one with a low-code portal tool over your APIs, or build a custom portal application. Choose by how far your roles and scoping rules differ from the product’s defaults, and by how complete your APIs are.

Route Fits when Watch for
Portal module of your TMS or LMS Its roles, branding and booking flow already match your six jobs Role limits you cannot change; per-client scoping you cannot inspect or test
Low-code or portal builder over your APIs You need a first release quickly and your data is reachable through APIs Whether row-level and per-record permissions are enforced on the server, not only hidden in screens; how external users are licensed
Custom portal application Your roles, scoping or workflows are unusual, or the portal is part of your product You own security, upgrades and API gaps; the first release is slower

Costs are not given as numbers because they depend on scope. A common trade-off is that a vendor module costs least up front, while a custom build costs most up front and gives you the most control over later changes. If you are also deciding whether to own the TMS itself, our build vs buy TMS framework scores that decision.

Should every client get its own portal?

This is a separate choice from the build route: one shared portal with client scoping, or a branded workspace per client. A shared portal is one codebase to run. A per-client workspace gives stronger separation and client branding, but more to configure and operate. Tenancy models and per-client single sign-on are covered in their own guides.

If you want a platform that already offers the per-client model, SimpliTrain’s page for professional training companies says it supports separate corporate client portals with negotiated pricing, bulk enrollment and an admin hierarchy, each client in an isolated workspace inside one multi-tenant platform. SimpliTrain is a Mundrisoft product, so treat that as a vendor claim to test in a demo.

Pro tip: Test with two clients, never one. Seed your test data with two clients that share a session, have similar learner names and use overlapping invoice numbers. A demo with one client cannot show a leak, and most cross-client bugs only appear when two clients touch the same record.

How do you secure a client portal?

Enforce authorization on the server for every request, deny by default, and check each record against the caller’s client, not only the caller’s role. Treat hidden buttons and obscure IDs as cosmetics. Then write tests that prove one client cannot reach another’s data, and keep them in your build pipeline.

The OWASP cheat sheet says applications should deny access by default and that permission must be validated on every request, whether it comes from an AJAX call, the server or another source. These controls matter most for a portal:

  • Check the object, not just the role. OWASP ASVS 5.0 requires that data-specific access is limited to consumers with explicit permission (V8.2.2, Level 1). That is the control behind IDOR and BOLA defenses.
  • Enforce rules in a trusted service layer. ASVS V8.3.1 says authorization must not depend on controls that an untrusted client, such as browser JavaScript, can alter.
  • Use the client as an attribute, not only a role. The cheat sheet says RBAC is poorly suited when distinct organizations or customers need access to the same protected resources, and recommends ABAC or ReBAC. In practice, combine a short role list with a client attribute.
  • Add cross-client controls. ASVS V8.4.1 (Level 2) asks multi-tenant applications to use cross-tenant controls so one tenant’s operations never affect another.
  • Log and test. The cheat sheet warns that violations can go undetected without access-control logging, and calls for unit and integration tests of access logic.

What does a tested scope check look like?

It is a permission check followed by a query that always includes the client. This Python and SQLite sketch is minimal on purpose. The invoice lookup returns nothing for a missing record and for another client’s record, so a caller cannot tell the two apart.

PERMISSIONS = {  # role -> allowed actions (anything not listed is denied)
    "client_admin":   {"roster:read", "invoice:read", "booking:create"},
    "training_coord": {"roster:read", "booking:create"},
    "billing":        {"invoice:read"},
}

def allowed(actor, action):
    return action in PERMISSIONS.get(actor["role"], set())  # deny by default

def roster(actor, session_id):
    if not allowed(actor, "roster:read"):
        return None
    rows = db.execute(
        "SELECT l.name FROM enrolments e JOIN learners l ON l.id = e.learner_id "
        "WHERE e.session_id = ? AND e.billing_org_id = ?",
        (session_id, actor["org_id"])).fetchall()
    return [r[0] for r in rows]

def invoice(actor, invoice_id):
    if not allowed(actor, "invoice:read"):
        return None
    return db.execute(
        "SELECT id FROM invoices WHERE id = ? AND billing_org_id = ?",
        (invoice_id, actor["org_id"])).fetchone()  # None for missing and for foreign

The matching tests below seed two clients on the same session. We ran four such tests with pytest 9.1.1 on Python 3.13 and an in-memory SQLite database, and all passed. This is a pattern sketch, not production code.

def test_guessing_another_clients_invoice_id_returns_nothing():
    assert invoice(admin_a, 7) is not None
    assert invoice(admin_a, 8) is None   # same result as a missing id
    assert invoice(admin_a, 999) is None

The other three tests check that a shared session shows each client only its own learners, that roles without permission are denied, and that a learner who changes employer does not move an old enrollment to the new client.

What should you do next?

List the six buyer jobs and ask your account managers which three requests fill their inboxes. Those three are your first release. Then write down the scoping key for each object in the second table, because a gap there is a data leak waiting to be found.

Next, compare the three build routes against your role list and API coverage, and write the two-client test cases before any screen design. If you would rather start from a platform with per-client portals, SimpliTrain, described above, is one to test against your own checklist.

Frequently asked questions

What is a client portal for a training company?

It is a secure login for corporate customers, as distinct from learners. Through it, a client’s staff book seats, manage attendee lists, see attendance, pay invoices against purchase orders and download certificates. The provider controls what each client sees, so clients can serve themselves without exposing any other client’s bookings or data.

How is a client portal different from a learner portal?

A learner portal serves individual learners: their courses, schedule, progress and certificates. A client portal serves the organization that pays: rosters across many learners, group bookings, invoices and reporting. Keep them as separate logins so an employer never sees a learner’s history with other organizations.

Can clients book seats themselves, or should they submit a request?

Both models exist. Direct booking suits public sessions with fixed prices and open capacity. A request that staff approve suits private courses with negotiated pricing or scarce seats. aXcelerate’s portal, for example, sends client enrollment requests to the provider’s admin team to review and confirm. Choose per session type.

How do you stop one client seeing another client’s data?

Store the paying client on every enrollment and order, then filter every query, download and export by the caller’s client on the server. Deny access by default and treat missing and forbidden records the same. Test with two clients sharing a session, because single-client test data hides leaks.

Do corporate clients need single sign-on for the portal?

It depends on each client’s security policy, so ask during sales. Design accounts so a portal user belongs to one client, and keep a local login with strong credentials for clients that do not use single sign-on. Per-client identity provider setup is a topic of its own.

How long does it take to build a client portal?

It depends mostly on API coverage and the role model, not the number of screens. A first release limited to rosters, invoices and certificates is much smaller than a full booking flow with approvals. Ask any estimate to state its assumptions about authentication, client scoping and test coverage.

Alert: mundrisoftcareers.com is not affiliated with Mundrisoft Solutions. Beware of fake job offers and trust only our official recruitment channels.