Sazinga Sarva · Workforce
Publishing the training is easy, finishing it is the hard part
Organisations running internal training in safety, compliance, onboarding and product knowledge
In production — Deployed white-label, so the installations cannot be named.
Every screen below is rebuilt from Engage's own interface and filled with a demonstration tenant's data. They are not captures of a live customer system.
Tap any picture to open it full size.
You get something made from your own material, within one working day, and no call unless you ask for one.
A policy, a procedure, a safety briefing. Within one working day we return five comprehension questions generated from it, so you can judge the questions before anyone judges the product.
Your enquiry is with the team. We read every one ourselves and normally reply within one working day.
If it is quicker to talk, reach us directly:
While you wait — the platform overview covers what each application does, and Insights is our writing on building this kind of software.
Would rather read than write? See the screens above, or the whole platform — seven applications, each one standing on its own.
Most organisations have already solved the publishing half of internal training. The safety induction exists, the compliance refresher exists, the onboarding pack exists. What is missing is the other half. People open a module, get part way in, and never return, and the reporting records an assignment where there should be a demonstrated understanding.
Sazinga Engage takes the material an organisation already has and generates comprehension checks from it, so the questions test the document that was actually issued. Around that sits a reward loop of points, streaks and visible progress, built for one purpose, which is getting people to the end. Reporting then shows not just who enrolled but where in a module people stopped.
Engage is in production, deployed white-label. That is the part to be precise about: there is no public URL to send you to and no client we can name, because the deployments carry somebody else’s branding rather than ours. There is also no sign-up page, no published price list and no self-serve trial — a walkthrough on a demonstration tenant is how you see it.
The engine underneath is not new. The generation pipeline, the quiz model and the reward loop run in a consumer learning application built on the same stack — a FastAPI and PostgreSQL server with a React Native client — which is where the mechanisms described below come from. The workplace product is that engine given an organisation, roles, assignment by team, and reporting a manager can act on.
One consequence worth stating, because it is visible on this page: the screens below are captures of that consumer application with the labels changed, not of a live Engage tenant, and each says so underneath it. White-label deployment is exactly why we cannot publish the real ones.
A generic question bank tests the topic. A question generated from the document you issued tests the document you issued. That distinction is the reason to do the harder thing, and it changes what a pass means: answering correctly demonstrates having read your safety brief, not general familiarity with safety.
Photographs of printed material work as an input, which matters more than it sounds — most organisations’ real training content is a laminated procedure on a wall or a page in a binder, not a tidy PDF. Images are downscaled and re-encoded on the device before they are sent anywhere, which is not a bandwidth optimisation but a privacy step: re-encoding drops the EXIF block, and that block contains the coordinates of the room the photograph was taken in. A file already small enough is re-encoded anyway, because skipping that pass to save work would switch location stripping off for precisely the pictures taken closest to home.
Language models fail intermittently, and a training platform that shrugs at a failed generation puts the work back on the person who was trying to publish. Three mechanisms, all measured rather than assumed.
The request carries a real response schema rather than an instruction to return JSON. Asking a model for JSON guarantees only that the reply parses — an empty object is valid JSON and a useless answer, and it fails a layer later as a confusing parse error rather than as a bad generation.
Failures are classified before they are retried. An unusable reply gets up to three further attempts against the same credential, with the sampling temperature nudged so the model genuinely re-rolls rather than returning the same thing. A rate limit, a rejected credential or a network error moves straight on to the next provider, because repeating those changes nothing.
Every attempt is recorded — provider, model, number of attempts, duration and outcome — so the question “is generation working” is answered from a table rather than from an impression. That record is also what a usage allowance is counted from.
The position of the correct answer. A set of questions written by hand, or generated one at a time, drifts towards putting the right answer in the same place, and learners find that pattern long before they find the material. Engage places correct answers by a generated rotation across the option positions rather than leaving it to whoever wrote the question — an approach that came directly from a batch of 150 questions where every answer was option one.
A quiz is created as a draft and stays invisible to learners until it is explicitly published. A learner’s device only ever offers published material and refuses an attempt against anything else.
This is deliberate friction. The alternative — content that goes live the moment it is saved — means half-written questions reach people, and the correction arrives after they have answered them. The cost of the separation is that a module can be published with no quiz attached, so publishing warns when it would leave a learner with material and nothing to answer.
Points earned per correct answer, a streak counted in consecutive active days, badges, and per-item progress that lets someone continue where they stopped. The learner-facing loop — read, answer, see the reward — runs entirely on the device and touches the network zero times; synchronisation happens in the background afterwards.
Two kinds of record sit behind it, on purpose. Progress is stored per item, and the aggregate counters are stored separately. A lost counter update costs a number that can be recomputed from the per-item records; it never costs the history of what somebody actually completed.
It does not author your training. It generates comprehension checks from material you supply, and somebody in your organisation still has to review them before they go out — the review step is part of the design, not an oversight.
It is not a compliance register. It records that a module was completed and when; it does not track the certificate that results, its expiry, or the obligation that required it. That is Sazinga Comply, and the two are being built to meet at the point where a completion becomes evidence.
It also does not do video hosting, live sessions, SCORM import or accredited course delivery, and it is not a substitute for training that legally requires an assessor in the room.
The sectors this is aimed at first are the ones where training is issued, evidenced and audited rather than merely offered: food safety, construction and healthcare. If your immediate problem is proving that certification is current rather than that people understood the material, start with Sazinga Comply instead — and note that it is also still in build.
Swipe for the other screens.
Upload the handbook, the safety brief, the standard operating procedure or the product sheet you already have. Comprehension checks are generated from that material rather than from a generic question bank, so the questions test what you actually issued.
Points for correct answers, streaks for returning, and a progress bar that shows how much of a module remains. The loop is aimed at completion rather than at enrolment, because enrolment was never the number that was short.
For each person, what was assigned, how far they got, what they answered and when. A module that people abandon at the same point is visible in the data, which is usually a problem with the material rather than the people.
Delivered as a mobile app so training happens in short sessions between other work, rather than requiring a desk, a laptop and an hour that nobody has.
Each of these is a real problem from a live installation, what it cost, and what changed.
Sazinga Engage is an employee training and engagement platform. You supply the training material, it generates comprehension checks from that material, and a reward loop of points, streaks and visible progress is used to drive people through to completion rather than only to enrolment.
Yes. It is in production and deployed white-label, which is why we cannot point you at a live URL or name the organisations running it. A walkthrough on a demonstration tenant is the way to see it.
From the material you upload. The handbook, procedure, safety brief or product sheet is processed and comprehension checks are generated from its content, so answering correctly demonstrates having read the document you issued rather than general knowledge of the topic.
Because publishing training is already solved and finishing it is not. An assigned module that is opened and abandoned produces a record of assignment and no comprehension, which is the gap the reward loop of points, streaks and progress is built to close.
Internal training an organisation is responsible for issuing and evidencing, such as safety inductions, compliance refreshers, new-starter onboarding and product knowledge for sales and service staff.
Per person, the modules assigned, how far through each one they are, the answers given and the dates. Aggregated across a team, it shows completion rates by module and the point within a module where people most often stop.
