Case study: mining education
Training telemetry that supervisors can query immediately.
Browser-based 3D drilling-rig simulations produce deeply nested assessment paths: steps, mistakes, timings, warnings, retries, instructor notes, and telemetry bursts. RushDB lets the frontend send that JSON as records, then query it with filters, select clauses, groupBy, and graph context for dashboards.
Training insight gets buried inside telemetry blobs.
Mining training platforms collect rich simulation data, but managers usually need a backend analytics project before they can answer practical questions: which cohort struggles with torque response, which rig operation takes too long, where students repeat unsafe steps, and which supervisors need follow-up evidence.
Before
- 3D simulation events stored as large denormalized JSON blobs
- Assessment paths require manual flattening before analysis
- Cohort dashboards need custom joins across students, attempts, steps, and telemetry
- Supervisors wait for backend analytics work before seeing training patterns
With RushDB
- Assessment attempts, step results, and simulation events become queryable records
- Nested JSON preserves the operational path without a schema-planning delay
- MongoDB-like filters, select, groupBy, and time buckets power thin dashboards
- Managers inspect cohorts, rig models, operations, errors, and student progress from one datasource
Graph intelligence on ingest
Incoming data becomes queryable graph context.
RushDB turns structured data into graph-ready context without a separate modeling pipeline. Structure already encoded in a nested payload is linked immediately. For flat records imported from scattered sources, relationship analysis can propose stable cross-source patterns.
01
Normalize as data arrives
Import JSON or CSV. RushDB infers property types and adds new fields to the live, queryable ontology without a schema migration.
02
Auto-link nested structure
Nested objects become connected records automatically, preserving the parent-child graph structure already encoded in your payload.
03
Enrich scattered sources
After flat imports or schema changes, analyze the project ontology. RushDB can suggest join patterns and semantic relationship types for your review.
Suggested relationship analysis requires an LLM configured for the project. Suggestions stay in draft form until you approve them, so inferred domain meaning never mutates the graph silently. You can also add explicit relationships through the SDK or API.
Review suggested relationship patternsData model
One flexible graph for the workflow.
Start with the payload shape your product already produces. RushDB stores it as Records, infers typed properties, and keeps nested or approved domain relationships queryable.
Deeply nested assessment paths can stay denormalized at write time while becoming queryable records for dashboards.
{
"attemptId": "attempt-884",
"studentId": "student-42",
"cohortId": "cohort-night-shift",
"rigModel": "DR-9000",
"operation": "pipe-tripping",
"score": 86,
"STEP_RESULT": [
{ "stepName": "preStartInspection", "status": "passed", "timeSec": 91 },
{ "stepName": "torqueResponse", "status": "needsReview", "timeSec": 133 }
],
"SIMULATION_EVENT": [
{ "eventType": "torqueThresholdWarning", "timestampMs": 184220, "severity": "medium" }
]
}Working example
Ingest one rig assessment. Group cohort performance.
A browser simulator sends one deeply nested assessment attempt. A thin dashboard queries average score and event counts by rig model, operation, event type, and cohort.
ASSESSMENT_ATTEMPT attempt-884
studentId: student-42
cohortId: cohort-night-shift
rigModel: DR-9000
operation: pipe-tripping
STEP_RESULT preStartInspection passed 91s
STEP_RESULT torqueResponse needsReview 133s
SIMULATION_EVENT torqueThresholdWarning severity: medium{
"labels": ["ASSESSMENT_ATTEMPT"],
"where": {
"cohortId": "cohort-night-shift",
"operation": "pipe-tripping"
},
"select": {
"avgScore": { "$avg": "$record.score" },
"attempts": { "$count": "$record" }
},
"groupBy": ["$record.rigModel", "$record.operation"]
}[
{ "rigModel": "DR-9000", "operation": "pipe-tripping", "avgScore": 82.4, "attempts": 38 },
{ "rigModel": "DR-7000", "operation": "pipe-tripping", "avgScore": 76.1, "attempts": 21 }
]TypeScript SDK
Ingest denormalized telemetry. Query it like operational data.
The simulator can send nested assessment JSON as it is produced. RushDB turns it into records that thin dashboards can filter, aggregate, group, and drill into.
Implementation blueprint
Build the mining training analytics path.
Use this sequence to turn 3D simulation telemetry into supervisor, stakeholder, and training-manager dashboards without building a separate analytics pipeline first.
- 01Send ASSESSMENT_ATTEMPT JSON from the browser after each operation test
- 02Preserve nested STEP_RESULT, SIMULATION_EVENT, ERROR_EVENT, and INSTRUCTOR_NOTE records
- 03Query attempts with MongoDB-like filters by cohort, student, rig model, operation, and date
- 04Use select, groupBy, and time buckets for cohort dashboards
- 05Let the thin UI render approved dashboard queries and drill-downs from RushDB
Build path
- Keep simulator telemetry append-only where auditability matters.
- Model students, cohorts, attempts, steps, events, notes, and supervisors as connected records.
- Use aggregate queries for score, duration, event frequency, and retry patterns.
- Expose frontend dashboards through approved query shapes for student-data governance.
Relevant docs
Read the exact primitives behind this pattern.
These links point to the RushDB docs pages that map directly to this case study: ingestion, labels, properties, values, SearchQuery, relationships, semantic search, MCP, or deployment.
Import JSON data
Import deeply nested simulator attempts and let RushDB create linked attempt, step, and event records.
Open docsSelect expressions
Build score, duration, error-frequency, and time-bucket metrics from training assessment records.
Open docsgroupBy
Group attempts by cohort, rig model, operation, step, event type, or severity for dashboard views.
Open docsHow it works
Build the smallest useful workflow first.
01
Ingest the simulator payload
Send the operation attempt, step path, telemetry events, timing, score, and notes as one nested JSON write.
02
Analyze without flattening first
Use filters, select, groupBy, and time buckets over the resulting records to build cohort and supervisor dashboards.
03
Drill into training evidence
Move from a cohort metric into the underlying student attempts, step results, simulation events, and instructor notes.
Know where it fits.
Frontend-friendly does not mean ungoverned
A thin UI can render dashboards quickly, but approved query shapes, access controls, and student-data governance still belong in the product boundary.
Denormalized input, queryable output
The simulator can emit messy nested JSON. RushDB preserves the path as graph context while still supporting analytical queries over scores, events, cohorts, and operations.
Questions developers ask.
Next step