Mission
Build the dashboards and internal tools that customers actually understand. Operators on a factory floor don't read JSON – they need clear, instant visualisations of inspection results, deviation trends, and QC status. You translate the entire D2R data pipeline into interfaces that drive daily decisions.
System Ownership
- Primary: Customer-facing web dashboard (inspection history, deviation visualisation, QC reports, analytics)
- Primary: Admin console (tenant management, user roles, subscription status, device fleet overview)
- Primary: Internal engineering tools (data annotation UI, model evaluation dashboard, system health overview)
- Primary: 3D visualisation layer in browser (point cloud viewer, deviation heatmap overlay, CAD model viewer)
- Secondary interface: Backend team (you consume their APIs, they own the data)
- Secondary interface: Applied AI team (you render their explainability outputs – heatmaps, confidence scores)
- Does NOT own: API layer (Backend team), ML models (AI team), MR rendering (MR team), infrastructure (DevOps team)
What You Will Build
- Inspection dashboard – The primary customer-facing interface. List of inspections with status (pass / marginal / fail), drill-down into individual scans, 3D deviation heatmap viewer, per-feature GD&T compliance table, side-by-side CAD vs. scan comparison.
- Analytics & trends view – Time-series charts showing deviation trends per machine/station/product. SPC (Statistical Process Control) charts with control limits. Anomaly flags linked back to specific inspections. Filterable by date range, product, station, operator.
- 3D point cloud viewer – WebGL-based viewer rendering millions of points in-browser. Overlay deviation heatmaps (colour-coded by severity). Overlay CAD wireframe for reference. Pan/zoom/rotate with 60fps performance. Click-to-inspect: click a region to see deviation magnitude and tolerance spec.
- QC report generator – Generate PDF and Excel compliance reports from inspection data. Include 3D screenshots, deviation tables, GD&T compliance matrices, pass/fail summaries. Customisable per customer branding. Automated scheduled reports.
- Data annotation tool – Internal tool for labelling inspection data (pass/fail/anomaly regions). Used by the AI team to build training datasets. Efficient 3D annotation workflow: select region → label → add note → next.
- Device fleet dashboard – Overview of all deployed edge devices. Status (online/offline/updating), last sync time, firmware version, health metrics (CPU, GPU, storage, temperature). OTA update rollout status.
Core Technical Responsibilities
- Design and build the React/Next.js web application with TypeScript – strict type safety, component library (Shadcn UI, Radix, or equivalent), responsive design
- Implement the 3D visualisation layer using Three.js or React Three Fiber: point cloud rendering (instanced meshes or point buffers), deviation heatmap shader, CAD wireframe overlay, LOD (Level of Detail) for large scans
- Build real-time data updates via WebSocket integration – live inspection status, device health, multi-user dashboard collaboration
- Implement data visualisation components: time-series charts (D3.js, Recharts, or Visx), SPC charts with UCL/LCL lines, geographic maps for multi-site deployments
- Build the PDF/Excel report generation: server-side rendering (Puppeteer or equivalent) for PDF with 3D screenshots, OpenPyXL or equivalent for Excel
- Implement role-based access control in the frontend: operator view (simplified), QC manager view (analytics + reporting), admin view (full tenant management)
- Build the internal data annotation tool with optimised UX for high-throughput labelling
- Performance optimisation: code splitting, lazy loading, virtual scrolling for long lists, WebGL memory management for large point clouds
Required Technical Mastery
- Frontend framework: React 18+ with Next.js (App Router), TypeScript (strict mode). Server-side rendering (SSR) and static generation (SSG) where appropriate
- 3D graphics: Three.js or React Three Fiber. WebGL performance optimisation: instanced rendering, buffer geometry, custom shaders (GLSL), GPU-based picking. Understanding of 3D coordinate systems and camera controls
- State management: Zustand, Jotai, or TanStack Query (React Query) for server state. No unnecessary global state – co-locate state with components
- UI/UX: Component libraries (Shadcn UI, Radix Primitives), Tailwind CSS, responsive design, accessibility (WCAG 2.1 AA). Strong design sensibility – not just "makes it work" but "makes it clear"
- Data visualisation: D3.js (lower-level control), Recharts or Visx (React-native charts). Understanding of statistical charts: histograms, box plots, SPC charts, scatter matrices
- API integration: REST (fetch/axios with type-safe wrappers), WebSocket (Socket.IO or native), data fetching patterns (optimistic updates, stale-while-revalidate, pagination, infinite scroll)
- Testing: Vitest or Jest for unit tests, Playwright or Cypress for E2E, React Testing Library for component tests. Storybook for component documentation
- Performance: Lighthouse audits, bundle analysis (webpack-bundle-analyzer), Core Web Vitals optimisation, memory profiling for WebGL applications
Production Challenges You'll Solve
- Rendering 10M points in-browser – A customer's LiDAR scan has 10 million points with per-point deviation values. Render this at 60fps with colour-coded deviation heatmap. Implement progressive loading, LOD, frustum culling, and GPU-based point splatting.
- Dashboard for non-technical operators – The end user is a QC inspector on a factory floor, not a software engineer. Your dashboard must be understandable in 10 seconds: big green/yellow/red indicators, clear trend arrows, minimal text. If they need a manual, you've failed.
- Offline-capable reporting – A customer in a remote construction site has intermittent connectivity. Your dashboard must cache recent inspection data and allow offline viewing and PDF generation. Service worker + IndexedDB.
- Multi-tenant branding – Enterprise customer wants their logo, colour scheme, and custom report template. Build a white-label system that doesn't require code changes per tenant – configuration-driven theming and report customisation.
- Annotation tool throughput – The AI team needs 10,000 labelled regions this month. Your annotation tool must support: 3D region selection (lasso/brush), keyboard shortcuts, undo/redo, batch operations, and quality metrics (inter-annotator agreement display). If the tool is slow, labelling bottlenecks AI model improvement.
- Real-time multi-user dashboard – Two QC managers are viewing the same inspection simultaneously. One adds a note. The other sees it in real-time. Implement presence indicators, real-time sync, and conflict resolution.
Success KPIs
| KPI | Target | Measurement |
|---|
| Dashboard load time | < 2s (First Contentful Paint) | Lighthouse / RUM metrics |
| 3D viewer performance | 60fps for ≤ 5M points, 30fps for ≤ 15M points | Performance profiling |
| Point cloud load time | < 5s for 10M points | Measured from API response to rendered view |
| Report generation time | < 10s for PDF, < 5s for Excel | Server-side generation metrics |
| Annotation throughput | ≥ 100 regions/hour per annotator | Annotation tool analytics |
| Core Web Vitals | LCP < 2.5s, FID < 100ms, CLS < 0.1 | Lighthouse CI in deployment pipeline |
| Component test coverage | ≥ 80% for critical paths | Jest/Vitest coverage reports |
| Design system adoption | 100% of new UI uses component library | Code review enforcement |
Failure If Underperforming
- Dashboard is confusing → operators don't check it → inspection insights go unused → customers see no ongoing value from D2R → churn. The MR experience happens once; the dashboard is the daily touchpoint that retains subscriptions.
- 3D viewer crashes or lags → customers assume the platform can't handle their data → they reject the pilot → lost deployment. Industrial data is large; the viewer must handle it gracefully.
- Reports are ugly or incomplete → QC managers can't present to auditors → compliance workflow breaks → customer finds an alternative that generates proper reports.
- Internal annotation tool is slow → AI team can't get labelled data → models can't improve → AI QC accuracy stagnates → the "AI-powered" promise rings hollow.
Collaboration Interfaces
| With | Interface |
|---|
| Backend Engineer | They provide REST + WebSocket APIs (OpenAPI spec). You consume them. Data format, pagination, and error handling agreed jointly. |
| Applied AI Engineer | You render their model outputs: 3D deviation heatmaps, confidence scores, anomaly flags, root cause suggestions. Agree on API response shapes. |
| CAD Geometry Engineer | You render CAD wireframes and feature annotations in the 3D viewer. Mesh format and LOD levels defined jointly. |
| DevOps Engineer | They manage hosting, CDN, SSL, and CI/CD for the frontend. You define build configs and deployment requirements. |
| MR Systems Engineer | Shared 3D rendering knowledge. Coordinate on consistent colour schemes and visualisation conventions between MR and web. |
Why This Role Is Mission-Critical
The dashboard is the product for 90% of the customer's team. The MR headset is worn by 2-3 operators per shift. The dashboard is checked by QC managers, production supervisors, plant managers, and compliance officers – every day. If the dashboard is poor, the perception of the entire D2R platform is poor. Customers don't renew subscriptions for invisible backend improvements. They renew because the dashboard told them something useful this morning.
About Us
Building the D2R (Design-to-Reality) platform – sub-millimetre CAD alignment + edge AI + mixed-reality overlay for industrial field workers. Venture-backed, seed-stage, < 20 engineers.
- Location: Bangalore / Hyderabad
- Stage: Seed / Pre-Series A (venture-backed)
- Industries: Construction, Manufacturing, Infrastructure, Energy