One spine. A module for every tool you rent.

1. Session 1: What you pay for today. Map the paper forms, checklists and inspections you use now and the form tools you pay for; classify three real forms by category (inspection, checklist, round, audit, permit, log, survey, record) and note what people work around.
2. Session 2: Extend the spine. Add the frm_ tables to the Foundation schema: frm_template, frm_template_version, frm_field, frm_assignment, frm_submission, frm_response, frm_triggered_action and frm_ingestion_job, keyed to core_person, core_site and core_attachment.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for who designs, fills, reviews and approves forms, and their screens: a designer, an offline phone capture screen with its local queue and retry-safe sync, and a supervisor review queue.
4. Session 4: The workflow. Draft and published versions that cannot be edited; scheduled assignments with due windows; scoring and signature with meaning; submission, supervisor review and reject-with-comment; failed items that create linked actions; completion and overdue dashboards.
5. Session 5: Move the data. Upload a scanned paper form for AI-proposed fields with field-by-field human review, then import historical records from the old tool's CSV or API export as read-only archived submissions.
6. Session 6: Cut over and retire. Run old and new side by side, compare completion and overdue counts with a hand count, cut over, and cancel the paper forms and form-builder subscription with the saving recorded.

HOMEWORK Build the Paper to Glass module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the eQMS you use now: its quality events, CAPAs, audits and users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the qms_ tables to the Foundation schema: the quality event supertype with NCR, complaint and deviation detail, holds, CAPA, audits, change control, FMEA and supplier quality, keyed to the spine's people, sites, items and lots.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for reporters, quality engineers, CAPA owners, auditors and approvers who sign material review decisions, holds and closures, and their screens on the three surfaces.
4. Session 4: The workflow. Raise an event, triage, hold the lot, decide the material review disposition, run the CAPA with a 5-Why or fishbone, check effectiveness, and close with a signature; score FMEA action priority from severity, occurrence and detection.
5. Session 5: Move the data. Import open and closed events, CAPAs and audits with attachments; closed records arrive as read-only history with original signatures kept as attached evidence.
6. Session 6: Cut over and retire. Run old and new side by side, compare open events and CAPA due dates, cut over, and cancel the eQMS subscription with the saving recorded.

HOMEWORK Build the Quality management module on your spine: quality events with NCR and material review, holds that stop product, CAPA with an effectiveness check, audits, change control, FMEA and supplier scorecards. Move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the computerised maintenance management system (CMMS) you use now and what you pay for it a year: its asset tree, work orders, PM plans, parts and users, how it differs from your production equipment hierarchy, and what people work around (free-text closeouts, drifting asset lists, late PMs).
2. Session 2: Extend the spine. Add the cmms_ tables to the Foundation schema: cmms_asset_profile on core_equipment, cmms_craft, cmms_job_plan, cmms_job_plan_task, cmms_meter, cmms_meter_reading, cmms_pm_schedule, cmms_work_request, cmms_work_order, cmms_wo_task, cmms_wo_labor, cmms_wo_part, cmms_failure_code, cmms_spare_part_link and cmms_calibration_record.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for requesters, technicians, planners, supervisors and reliability engineers, and their screens: a QR and mobile request screen, an offline technician work screen, a planner's weekly schedule and a reliability dashboard.
4. Session 4: The workflow. Work request triage, then work orders through approval, planning, scheduling, in progress, on hold with a reason, completed and closed; PM generation from calendar, meter and condition rules with a 90-day forecast; parts issued through the inventory ledger; ISO 14224 failure coding reviewed at closeout; calibration with as-found and as-left; reliability views for MTBF, MTTR, PM compliance, backlog, bad actors and the failure Pareto.
5. Session 5: Move the data. Import the asset register mapped to spine equipment codes first, then PM plans with their next due dates, open work orders, parts, and closed work orders as read-only history from the old CMMS CSV or API export.
6. Session 6: Cut over and retire. Run old and new side by side, compare PM compliance, open work orders and MTBF and MTTR with a hand calculation, cut over, and cancel the computerised maintenance management system (CMMS) subscription with the saving recorded.

HOMEWORK Build the Maintenance (CMMS) module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the shift log, handover tool or chat you use now: its data, its users, what it costs a year, and what people work around; note where equipment, open issues, holds and permits get lost between crews.
2. Session 2: Extend the spine. Add the shf_ tables to the Foundation schema: shf_shift_log, shf_log_entry, shf_handover, shf_standing_order, shf_standing_order_ack, shf_task_template, shf_shift_task, shf_event_rule and shf_event_occurrence, keyed to core_shift_instance, core_equipment, core_person and core_e_signature.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for the outgoing lead, incoming lead, operator and standing-order issuer, and their screens: shift log, handover report with sign-out and sign-in, standing orders to acknowledge, and an offline phone view for field operators.
4. Session 4: The workflow. Log entries with category, priority and carry-forward; a handover with an auto-snapshot stored at sign-out (never recomputed when viewed); dual e-signature sign-off with escalation of an unsigned handover; standing orders with acknowledgement; an event rule that creates exactly one entry per condition episode.
5. Session 5: Move the data. Export historical logs as CSV and import them as closed entries tagged origin=import; mark which open items carry forward; keep the old tool's data read-only.
6. Session 6: Cut over and retire. Run old and new side by side, compare handover counts and open carry-forward items with the old tool, cut over, and cancel the shift handover tool subscription with the saving recorded.

HOMEWORK Build the Shift handover module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the CRM you use now (Salesforce, HubSpot, Pipedrive or similar): its accounts, contacts, deals and activities, its users, what it costs a year, and what people work around. Classify three real records against the account, contact, lead and opportunity shapes.
2. Session 2: Extend the spine. Add the crm_ tables to the Foundation schema: crm_account linked one to one to core_party, crm_contact, crm_lead, crm_pipeline, crm_pipeline_stage, crm_opportunity, crm_stage_history, crm_contact_role, crm_activity, crm_price_book, crm_price_book_entry, crm_quote and crm_quote_line, keyed to core_person, core_item and core_attachment.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for sales reps, sales managers who approve discounts, and service staff who read accounts, with a do_not_contact flag respected, and their screens on the three surfaces: lead inbox, pipeline board and quote builder.
4. Session 4: The workflow. Lead capture and conversion to account, contact and opportunity with the original lead and its UTM data kept; stages with probability and required fields; a crm_stage_history row on every change; next step and owner always set; won and lost with a reason; quote versions, discount approval and acceptance.
5. Session 5: Move the data. Export accounts, contacts, deals, activities and stage history from the old CRM by CSV or API; load stage history in full before anyone uses the new CRM so analytics stay continuous; de-duplicate on email and company by a written rule; keep the source of each record.
6. Session 6: Cut over and retire. Run old and new side by side, compare open pipeline, win rate and forecast against the old tool, cut over, and cancel the CRM subscription with the saving recorded.

HOMEWORK Build the Customers and CRM module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the scheduling tool, board or spreadsheet you use now (an APS such as PlanetTogether or Asprova, or a Smartsheet, monday.com or Excel board): its resources, orders, users, yearly cost and what planners work around; spot infinite-capacity Gantt charts and schedules built on nameplate rates.
2. Session 2: Extend the spine. Add the aps_ tables to the Foundation schema: aps_resource, aps_capability, aps_resource_capability, aps_calendar_exception, aps_setup_matrix, aps_scenario, aps_job, aps_scheduled_operation, aps_constraint, aps_scenario_kpi and aps_adherence, keyed to core_equipment, core_calendar, core_item, core_person and core_reason_code.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for planners, supervisors and the floor, and their screens: resource and calendar set-up, an interactive Gantt with live validation, scenario compare, and a dispatch list for operators on a phone.
4. Session 4: The workflow. A rule-based finite scheduler (forward and backward, EDD and SPT) that never overloads a resource, changeover-aware sequencing from the setup matrix, locked operations that survive a re-run, scenario copy and compare, and publish to dispatch with the aps.scenario.published event.
5. Session 5: Move the data. Import resources, routings and open orders from the ERP or MRP export (history beyond adherence data rarely needs to move); check no resource is loaded beyond capacity and that efficiency factors come from measured OEE, not nameplate.
6. Session 6: Cut over and retire. Run old and new schedules side by side, compare on-time delivery, changeover hours and schedule adherence, cut over, close the adherence loop from M04 actuals, and cancel the scheduling subscription with the saving recorded.

HOMEWORK Build the Scheduling and dispatch module on your spine, move your real resources and open orders in, run it alongside the old tool or board for at least one week, and cut over.

1. Session 1: What you pay for today. Map the invoicing and billing tool you use now (QuickBooks, Xero or similar): its customers, terms, open invoices, unapplied payments, users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the bill_ tables (bill_billing_account, bill_invoice, bill_invoice_line, bill_tax_rate, bill_credit_note, bill_payment, bill_payment_application, bill_dunning_step, bill_dunning_event, bill_posting) to the Foundation schema, keyed to core_party and the spine's records, with money in whole cents.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for sales, billing, approvers and the posting service, defining what each role can see and do in the later sessions, and their screens on the three surfaces.
4. Session 4: The workflow. Build the order-to-cash workflow: invoices from sales orders and service work orders, tax lines from a dated rate table, approval above a threshold, credit notes as the only correction, payment application, and one idempotent posting per document to accounting.
5. Session 5: Move the data. Import open invoices, customers and unapplied payments from QuickBooks or Xero, load opening balances as one posting each, and reconcile open balance per account to the accounting system's receivables to the penny.
6. Session 6: Cut over and retire. Run old and new side by side, check the KPIs (DSO, invoice accuracy, time to invoice, posting success), cut over from a set date while the old system keeps history, and cancel the subscription with the saving recorded.

HOMEWORK Build the Quotes, orders and invoicing module on your spine: billing accounts and terms, invoices from orders and work, dated tax, credit notes, payment application and a posting contract to your accounting system. Move your real open invoices in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the inventory, MRP and purchasing tool you use now (for example MRPeasy, Katana, Fishbowl or a spreadsheet): its items, lots, locations and orders, its users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the fifteen inv_ tables to the Foundation schema: inv_inventory_transaction (append-only) with the derived inv_inventory_balance, inv_item_site_plan, inv_bom_simple, inv_supplier_item, inv_purchase_requisition, inv_purchase_order, inv_purchase_order_line, inv_goods_receipt, inv_invoice_match, inv_mrp_run, inv_planned_order, inv_mrp_exception, inv_sales_order and inv_sales_order_line, keyed to core_item, core_site, core_storage_location, core_lot and core_party.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for planner, buyer, approver, receiver and stock user, with the right for each to post, read or approve, keeping PO approval and goods receipt with different people, and their screens on the three surfaces.
4. Session 4: The workflow. Requisition, purchase order with approval threshold, receipt (full or partial) with lot capture, status change and hold, issue and cycle count, all posted as ledger transactions; available-to-promise; then building the MRP engine and a worked run with gross-to-net, lead-time offset, lot sizing, pegging, planned orders and exception messages.
5. Session 5: Move the data. Load item-site planning parameters, open purchase orders and sales orders, and opening balances as one dated opening transaction per item, lot and location; reconcile to the old tool's stock valuation report.
6. Session 6: Cut over and retire. Run old and new side by side, compare on-hand and open orders with a physical count and the old valuation report, cut over, and cancel the inventory and purchasing tool subscription with the saving recorded.

HOMEWORK Build the Purchasing and inventory module on your spine, move your real item parameters, open orders and a counted opening balance in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the SPC and inspection tool you use now (InfinityQS, WinSPC, SQCpack or similar): its characteristics, charts, gauges and users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the spc_ tables (spc_characteristic, spc_control_plan, spc_control_plan_line, spc_chart, spc_subgroup, spc_measurement, spc_violation, spc_capability_study, spc_msa_study and the inspection tables) to the Foundation schema, linked to core_item, core_equipment, core_person and core_lot.
3. Session 3: Roles and screens. Add rows to the Role and Exposure Matrix for inspectors, operators, quality engineers and supervisors, including who may set or approve control limits and who may acknowledge a violation, and build their screens on the three surfaces.
4. Session 4: The workflow. Capture a measurement, chart it in real time, evaluate the run rules on every point, open an spc_violation, and require an assignable cause code and corrective action before it can close.
5. Session 5: Move the data. Import characteristics, specification limits and measurement history, reload the history so limits and capability can be recomputed, and compare them with the old tool's figures before cut-over.
6. Session 6: Cut over and retire. Run old and new side by side, compare chart limits and Cp/Cpk results, cut over, and cancel the SPC and inspection tool subscription with the saving recorded.

HOMEWORK Build the SPC and inspection module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the project and work-management tool you use now (Smartsheet, Asana, monday.com, Microsoft Project, Wrike, ClickUp or similar): its projects, users, dependency types, baselines and what it costs a year; list what people work around, such as finish-to-start-only links, no baseline and budgets without commitments.
2. Session 2: Extend the spine. Add the prj_ tables to the Foundation schema: prj_portfolio, prj_request, prj_project, prj_task, prj_dependency, prj_baseline, prj_assignment, prj_time_entry, prj_budget_line, prj_commitment, prj_raid_item, prj_status_report, prj_punch_item and prj_evm_snapshot, keyed to core_person, core_site and core_calendar, with money in integer cents.
3. Session 3: Roles and screens. Add rows to the Role and Exposure Matrix for the project manager, sponsor, task assignee, team member who logs time, approver of timesheets and budgets, and stakeholder who reads status, and build their screens on the three surfaces: Gantt, board, list, calendar and portfolio timeline.
4. Session 4: The workflow. Build the planning and control workflow: intake scoring and approval, a WBS with FS, SS, FF and SF dependencies and lag, a critical path method engine that reschedules successors when a predecessor moves, baselines and variance, budgets with commitments, earned value snapshots, and RAID, punch and status reporting.
5. Session 5: Move the data. Import tasks with dates and dependencies from a Smartsheet, Asana, monday.com or Microsoft Project export (CSV or XML) as a new baseline, check the imported network against the old tool, and archive closed projects read-only.
6. Session 6: Cut over and retire. Run old and new side by side, compare task dates, critical path, committed amounts and earned value against the old tool, cut over, and cancel the project and work-management subscription with the saving recorded.

HOMEWORK Build the Projects, jobs and tasks module (Project, Portfolio and Capital Project Management) on your spine, move your real projects in as a new baseline, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the document control tool you pay for today (SharePoint used as a controlled library, or a quality management document module): its documents, document types, users, yearly cost and the workarounds people use. Classify three real documents by type (SOP, work instruction, specification, form, policy) and note who approves each.
2. Session 2: Extend the spine. Add the doc_ tables to the Foundation schema: doc_doc_type, doc_controlled_document, doc_revision, doc_review_task, doc_document_link, doc_distribution, doc_controlled_print, doc_periodic_review and doc_external_document, keyed to core_person, core_site, core_job_role, core_attachment and core_e_signature.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for the owner, author, reviewer, approver, QA approver, reader and administrator, and their screens: the document register, a revision editor with redline compare, a review and approval inbox, and a read-and-understood list.
4. Session 4: The workflow. Run the revision lifecycle (draft, in review, approved, effective, superseded) with serial or parallel review routing, reject with reason, e-signatures that re-authenticate and show name, date and time and meaning, and a database rule that allows only one effective revision per document. Gate the effective date on training completion and publish doc.revision.effective.
5. Session 5: Move the data. Import documents from the old tool with metadata and revision history (CSV plus files): historical revisions arrive as superseded with their original effective dates, signatures are never re-signed, each file is stored with its sha256, and the effective revision is checked against the stored hash.
6. Session 6: Cut over and retire. Add controlled print with reconciliation, periodic review with overdue escalation, and a PDF/A rendition of each effective revision with hash verification. Run old and new side by side, compare the results, cut over, and cancel the document control subscription with the saving recorded.

HOMEWORK Build the Documents and e-signature module on your spine, move your real documents and revision history in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the help desk, ITSM and customer-support tools you use now (for example Zendesk, Freshdesk, Jira Service Management): channels, queues, SLA rules, users, what each costs a year, and what people work around.
2. Session 2: Extend the spine. Add the svc_ tables to the Foundation schema: svc_support_group, svc_business_hours, svc_sla_policy, svc_category, svc_ticket, svc_ticket_message, svc_sla_event, svc_catalog_item, svc_problem, svc_change_request, svc_configuration_item, svc_ci_relationship, svc_kb_article, svc_macro and svc_csat_response, keyed to core_person, core_site and core_equipment.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for requesters, agents, support leads, change approvers and CI owners, and their screens on the three surfaces: a portal for requesters, an agent queue, and a lead view of SLA risk.
4. Session 4: The workflow. Email-to-ticket threading, a catalogue request, routing to support groups and macros; SLA due times from business hours, holidays and pause statuses with breach warnings; resolve with a recorded resolution, CSAT on resolve, and the major incident, problem and change flows with a back-out plan.
5. Session 5: Move the data. Import open tickets with their messages, plus users and organisations, from the old tool's export or API, linking each to core_person and the customer record; import closed tickets as history and articles as drafts for review.
6. Session 6: Cut over and retire. Run old and new side by side, compare first response time, time to resolution and SLA attainment with the old tool's figures, cut over, and cancel the help-desk subscription with the saving recorded.

HOMEWORK Build the Help desk and Service Management module (M19) on your spine, move your real tickets in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the marketing automation and email tool you use now (HubSpot Marketing Hub, Mailchimp, ActiveCampaign or similar): its contacts, consent status, lists, templates, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the mkt_ tables (mkt_consent and mkt_suppression first, then mkt_segment, mkt_email_template, mkt_campaign, mkt_email_send, mkt_email_event, mkt_flow, mkt_score_rule, mkt_attribution_touch, mkt_ad_spend_daily) to the Foundation schema, with crm_contact kept as a soft link.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for marketers, approvers, the send and webhook routes, and the contact, and their screens on the three surfaces, covering every later session's reads and writes.
4. Session 4: The workflow. Build the consent ledger and suppression list, segments with a rule builder, templates and sends through an ESP API with webhooks, a journey with a wait and a branch, lead scoring with MQL hand-off to the CRM, and attribution of won jobs to channels.
5. Session 5: Move the data. Import contacts with consent status, lists, templates and engagement history, then upload ad spend; never import a contact without its consent source, and load suppressions before anything else.
6. Session 6: Cut over and retire. Run old and new side by side, reconcile attribution totals to won revenue for each model, check deliverability (complaint rate under 0.3%), cut over, and cancel the old subscription with the saving recorded.

HOMEWORK Build the Email and text marketing module (mkt_ tables) on your spine, move your real contacts in with their consent source, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the CMS, website builder or wiki you use now (WordPress, Webflow, Contentful, Confluence or similar): its content, users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add cms_content_type, cms_entry, cms_entry_version, cms_media_asset, cms_locale, cms_nav_menu and cms_nav_item to the Foundation schema, keyed to core_person and core_attachment.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for authors, editors, publishers and internal knowledge-base readers, and their screens on the three surfaces.
4. Session 4: The workflow. Move an entry through draft, in_review, approved, scheduled and published; preview it through the real front end, revalidate pages, and route cms_web_form submissions to CRM leads or help-desk tickets.
5. Session 5: Move the data. Import pages, media and redirects from a WordPress, Webflow or Contentful export into content types; build the full redirect map and check every old address resolves in one hop or fewer.
6. Session 6: Cut over and retire. Run old and new side by side, compare the results, cut over, and cancel the CMS subscription with the saving recorded.

HOMEWORK Build the Website and content (CMS) module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the HR records, time-and-attendance and recruiting tools you use now: the employee data, time clocks, leave rules, users, what they cost a year, and what people work around.
2. Session 2: Extend the spine. Add the hr_ tables (hr_employment, hr_position, hr_job_assignment, hr_compensation, hr_time_off_policy, hr_time_punch, hr_timesheet and the rest) to the Foundation schema, with effective dating so job and pay history is never overwritten, and mark the restricted data (compensation, candidates, FMLA designation, Form I-9 files).
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for employees, supervisors, HR and payroll, with compensation, FMLA leave designation, candidate data and Form I-9 files restricted at field level, no right to change a punch, and their screens on the three surfaces.
4. Session 4: The workflow. Punch in and out (kiosk, mobile or web), edit punches with the original value and a reason, apply overtime rules (federal weekly plus one state daily rule), approve timesheets, run time-off requests with an accrual tested against written policy examples, schedule shifts with a qualification check, and export a payroll batch that reconciles to approved totals.
5. Session 5: Move the data. Import employees, job history, time-off balances (as dated opening entries) and open requisitions; verify balances against the old system before the first pay period; walk one candidate through an accepted offer to a hire with onboarding tasks; never import or store Social Security, bank or card numbers.
6. Session 6: Cut over and retire. Run old and new side by side for a pay period, compare hours and balances, cut over, and cancel the old HR records and time-and-attendance subscriptions with the saving recorded.

HOMEWORK Build the People, time and attendance module on your spine, move your real data in, run it alongside the old tool for one full pay period (weekly pay makes this fit week 3), and cut over.

1. Session 1: What you pay for today. Map the training records or learning-management tool you use now: its skills, courses, assignments, completions and certificates, its users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the trn_ tables (trn_skill, trn_role_requirement, trn_course, trn_assignment, trn_completion, trn_practical_assessment, trn_qualification, trn_external_certificate) to the Foundation schema, keyed to the spine's core_person and core_job_role.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for trainees, trainers, assessors and supervisors, and their screens on the three surfaces, including who may sign an assessment.
4. Session 4: The workflow. Assign training by trigger, record completions and dual-signed practical assessments, grant qualifications with expiry, and answer the point-of-use check (is this person qualified now?) so the operator screen blocks unqualified work.
5. Session 5: Move the data. Import completions and external certificates with their original dates and evidence, map legacy course codes to skills, and flag anything already expired.
6. Session 6: Cut over and retire. Run old and new side by side, compare the results and the live skills matrix with its single-point-of-failure report, cut over, and cancel the training records or learning-management tool subscription with the saving recorded.

HOMEWORK Build the Training records and competency module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the EHS tool you use now (incidents, observations, OSHA logs, permits, chemical and SDS records): its data, its users, what it costs a year, and what people work around. Classify three real records by the ehs_ tables that would hold them.
2. Session 2: Extend the spine. Add the ehs_ tables to the Foundation schema: ehs_incident, ehs_injury_case, ehs_investigation, ehs_observation, ehs_risk_assessment and ehs_risk_step, ehs_permit, ehs_loto_procedure, ehs_isolation_point, ehs_loto_application and ehs_osha_annual_summary, keyed to core_site, core_person and core_equipment.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for everyone on site (reporting), the EHS role (the only role that reads injury case fields, with privacy-case handling), supervisors and managers, and their screens: a phone report screen, an investigation screen and a permit screen; plus the risk scale and who is told at each severity.
4. Session 4: The workflow. Report an incident or hazard from a phone in seconds, investigate to a root cause, raise actions classified by the hierarchy of controls, verify and close; run the recordability decision and generate the OSHA 300, 300A and 301 records, an ITA file and the TRIR and DART rates; issue permits and apply, verify and remove LOTO, blocking a work order until isolation is verified.
5. Session 5: Move the data. Import open incidents, cases and actions with their original recordability determinations, so OSHA logs stay reproducible for the five-year retention period, plus the LOTO procedures and the inspection schedule.
6. Session 6: Cut over and retire. Run old and new side by side, compare the generated 300 and 300A with the old tool's and a hand-completed form, cut over, and cancel the EHS tool subscription with the saving recorded.

HOMEWORK Build the Safety (EHS) module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the BI, dashboard and reporting tools you use now (for example Power BI, Tableau, Looker, Metabase, Grafana, Domo, Qlik Sense or Klipfolio): list the most-used reports, who reads them, the seats and cost per year, and where a figure is calculated in the chart instead of defined once.
2. Session 2: Extend the spine. Add the dash_ tables to the Foundation schema: dash_dashboard, dash_dashboard_version, dash_panel, dash_dashboard_share, dash_report_schedule, dash_report_delivery, dash_alert_rule and dash_alert_event, keyed to core_person, core_job_role, core_org_unit, core_attachment and core_action_item, and register two metrics in the data fabric to bind panels to.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for who builds, publishes, views and acknowledges, and their screens: role dashboards on the operator, supervisor and manager surfaces, with row-level security applied to every panel query.
4. Session 4: The workflow. Bind panels to registered metrics (a panel cannot be saved without a metric key), keep drafts and immutable published versions, add site, line, product and period filters, and drill from any number to its records and its metric definition, version and source data; a panel with no data shows "no data", never zero.
5. Session 5: Move the data. Schedule a PDF or CSV report with a delivery log, add a threshold alert with acknowledgement and an action item, then rebuild the incumbent's top five reports on registered metrics (the first in the session, the other four as homework) and compare every number with the old tool.
6. Session 6: Cut over and retire. Run the old tool and the new dashboards side by side for a period, compare every number, cut over, and cancel the BI seats with the saving recorded against the Retired BI seats KPI.

HOMEWORK Build the Dashboards and reporting module on your spine: register your metrics in the data fabric, build role dashboards whose panels are bound only to registered metrics, add a scheduled report and an alert, run it alongside the old BI tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the manufacturing execution system (MES) you use now against the ISA-95 equipment and material models and the 11 MESA functions: its data, its users, what it costs a year, and what people work around.
2. Session 2: Extend the spine. Add the mes_ tables to the Foundation schema: mes_product_definition, mes_operation_definition, mes_operation_step, mes_operation_parameter, mes_operation_material, mes_production_order, mes_operation_run, mes_step_record, mes_parameter_value, mes_equipment_state_event, mes_production_count, mes_material_consumption, mes_material_production, mes_labor_record and mes_shift_performance, keyed to core_item, core_equipment, core_lot and core_person, with no second equipment hierarchy.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for operators, supervisors, planners, quality and process engineers, and their screens on the three surfaces: the dispatch list, the guided operator execution screen, the downtime reason screen and the shift performance view.
4. Session 4: The workflow. Release a production order, dispatch it to a work centre and run its operations: step-by-step execution with interlocks the database enforces (qualification, calibration due, material scan, previous step complete), parameter capture with in-spec evaluation, material consumption and lot production, downtime with a reason code, and OEE per shift to ISO 22400.
5. Session 5: Move the data. Import product definitions, open production orders and the last 12 to 24 months of lot genealogy; check that every operation points to a real work centre and every lot link resolves before cut-over.
6. Session 6: Cut over and retire. Run old and new side by side, check a lot trace and one shift's OEE against a hand calculation, cut over, and cancel the manufacturing execution system (MES) subscription with the saving recorded.

HOMEWORK Build the Manufacturing execution (MES) module on your spine, move your open orders, product definitions and recent genealogy in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the LIMS you use now: its sample types, methods, specifications, instruments, users and what it costs a year; list what people work around, such as results overwritten in spreadsheets or paper notebooks.
2. Session 2: Extend the spine. Add the lims_ tables to the Foundation schema: lims_test_method, lims_specification, lims_spec_limit, lims_sampling_point, lims_sample, lims_custody_event, lims_worklist, lims_test, lims_result, lims_oos_investigation, lims_stability_study, lims_stability_pull, lims_reagent and lims_coa, keyed to core_item, core_lot, core_person, core_equipment and core_e_signature.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for analysts, reviewers, approvers and requesters, and their screens on the three surfaces; the rights cover every add, change and read the later sessions need, including superseding a result.
4. Session 4: The workflow. Register a sample with its specification version pinned, record every custody step, assign tests on a worklist, capture results, evaluate in spec, OOS and OOT against the pinned version, supersede rather than overwrite, run an OOS Phase I and Phase II investigation, then two-level review with e-signatures and the certificate of analysis.
5. Session 5: Move the data. Import methods, versioned specifications, and open samples with their history; re-evaluate a sample of historical results against the migrated specifications and check every specification is versioned and in force before cut-over.
6. Session 6: Cut over and retire. Run old and new side by side, compare turnaround, backlog, OOS rate and right-first-time, cut over, and cancel the LIMS subscription with the saving recorded.

HOMEWORK Build the Laboratory (LIMS) module on your spine, move your real methods, specifications and open samples in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the warehouse management system (WMS) you use now: its locations, handling units, users, what it costs a year, and what people work around; list which of receiving, put-away, replenishment, picking, packing, shipping and counting it covers.
2. Session 2: Extend the spine. Add the wms_ tables to the Foundation schema: wms_location_profile, wms_handling_unit, wms_inbound_shipment, wms_inbound_line, wms_receipt, wms_putaway_rule, wms_replenishment_rule, wms_wave, wms_task, wms_outbound_order, wms_outbound_line, wms_shipment, wms_package, wms_cycle_count and wms_cycle_count_line, keyed to core_storage_location, core_item, core_lot and core_person, with soft links to the inventory ledger; then build the GS1-128 label parser that receiving uses.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for receivers, pickers, packers, supervisors and inventory control, and their screens on the three surfaces, including a phone scan screen for receiving and picking.
4. Session 4: The workflow. Receive against an advance ship notice (ASN) and decode the GS1-128 label, route to quarantine for quality, direct put-away by rule, allocate earliest-expiry first (FEFO), release a wave, pick and pack with scan confirmation, ship with a bill of lading, and run a cycle count with variance approval; every completed task posts one ledger transaction.
5. Session 5: Move the data. Import the location master, then opening balances by license plate as inventory opening transactions; check on-hand by location matches the inventory ledger before cut-over.
6. Session 6: Cut over and retire. Run old and new side by side, compare pick accuracy and inventory record accuracy, run a wall-to-wall count at cut-over, and cancel the warehouse management system (WMS) subscription with the saving recorded.

HOMEWORK Build the Warehouse (WMS) module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the PLM, PDM or bill-of-materials tool you use now (such as Teamcenter, Windchill, Arena or OpenBOM): its parts, bills of materials, change history, users, what it costs a year, and what people work around; classify the lifecycle state of ten real parts.
2. Session 2: Extend the spine. Add the plm_ tables to the Foundation schema: plm_part, plm_part_revision, plm_bom, plm_bom_line, plm_substitute, plm_manufacturer_part, plm_file, plm_ecr, plm_eco, plm_eco_ecr_link, plm_eco_affected_item, plm_eco_approval and plm_compliance_declaration, keyed to core_item, core_person, core_party, core_uom and core_attachment, with a seed of parts, revisions and a five-level bill of materials.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for the design engineer, change board member, manufacturing engineer and buyer, and their screens on the three surfaces: part and BOM editor, change order review, and a read-only released-BOM view.
4. Session 4: The workflow. Raise a change request, convert it to a change order with affected items, assess where-used impact across five BOM levels, collect change board e-signatures, set effectivity and stock and work-in-progress disposition, release the new revision and publish plm.eco.approved and plm.eco.implemented.
5. Session 5: Move the data. Import parts, current released revisions and bills of materials first, with change history as closed change orders only where audit obligations require; check that every assembly resolves to released components and that one revision resolves for each part and date or serial.
6. Session 6: Cut over and retire. Run old and new side by side, compare BOM explosions, where-used results and change order status, cut over, and cancel the PLM tool subscription with the saving recorded.

HOMEWORK Build the Product lifecycle (PLM) module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.

1. Session 1: What you pay for today. Map the field service management tool you use now: its data, its users, what it costs a year, and what people work around. Note whether your installed assets are tied to the serials you shipped, and whether scheduling counts travel time.
2. Session 2: Extend the spine. Add the fsm_ tables to the Foundation schema: fsm_service_site, fsm_territory, fsm_installed_asset, fsm_service_contract, fsm_contract_asset, fsm_technician, fsm_service_work_order, fsm_appointment, fsm_service_line, fsm_customer_signoff, fsm_parts_request, fsm_warranty_claim and fsm_service_pm_plan, keyed to core_party, core_item, core_person and core_storage_location.
3. Session 3: Roles and screens. New rows in the Role and Exposure Matrix for dispatchers, technicians, service managers and customers, and their screens: a dispatch board, an offline technician phone screen and a customer sign-off screen.
4. Session 4: The workflow. Check entitlement when a job is booked, create a work order from a case or a PM plan, dispatch by skills, territory and travel time, complete it on a phone offline with parts, time, photos and a signature, sync parts usage to van stock, and hand billable lines to accounting.
5. Session 5: Move the data. Import customers, sites, installed assets from shipped serials, contracts and open work orders, and closed jobs as history for a first-time-fix baseline; check every asset has a site and every contract an end date before cut-over.
6. Session 6: Cut over and retire. Run old and new side by side, compare first-time fix and SLA results, cut over, and cancel the field service management tool subscription with the saving recorded.

HOMEWORK Build the Field service module on your spine, move your real data in, run it alongside the old tool for at least one week, and cut over.