NR 1 risk inventory: How to automate with Python and JSON

Why automate the NR 1 risk inventory?

Managing occupational health and safety requires handling a massive volume of data regarding workplace hazards and worker exposure. In practice, this means maintaining complex spreadsheets that frequently corrupt, contain broken formulas, or duplicate information. Automation through scripts solves this bottleneck by turning static spreadsheets into dynamic and auditable data pipelines.

Regulatory Standard number 1 (NR 1) establishes that companies must implement an Occupational Risk Management program known as PGR. When dealing with dozens of departments and hundreds of job roles, manual control becomes unfeasible and prone to failures that trigger severe labor penalties. The technical purpose of this article is to show how to model this data in a structured way and process it using code.

To achieve this goal, the ideal choice is using structured JSON files, which act as organized drawers where every piece of data has its exact place. Adopting this approach ensures information flows without context loss between safety engineering and IT systems, as detailed in our guide on how to digitize NR 1 PGR and integrate risk data via API.

Modeling occupational risk data in JSON

The first step in building a reliable automation system is defining the data contract format. In programming, JSON (JavaScript Object Notation) is the gold standard because it is lightweight and easily parsed by any modern language. Instead of relying on scattered spreadsheet cells, we structure hazards, sources, and control measures into a well-defined hierarchical dictionary.

Imagine a file grouping risks by company sector, detailing the probability of an event occurring and the severity if it materializes. In practice, this structure allows any software to read the file and automatically compute the residual risk level. This prevents subjective assessments from slipping through the cracks during internal safety audits.

Below we present a functional example of a JSON file structured to store the risk inventory cleanly and fully integrated with batch processing scripts:

{
  "company": "Example Industry Ltd",
  "department": "Packaging Production",
  "risks":[
    {&br>      "id": "R-01",
      "factor": "Intermittent noise",
      "probability": 3,
      "severity": 2,
      "control_measure": "Mandatory use of earmuffs"
    },
    {&br>      "id": "R-02",
      "factor": "Repetitive physical strain",
      "probability": 4,
      "severity": 3,
      "control_measure": "Job rotation every 2 hours"
    }
  ]
}

Processing and validating the inventory with Python

With data structured in JSON, the next step is writing a Python script to read, validate, and compute risk levels in an automated fashion. Python shines in this task due to its robust standard library and ease of handling nested data structures without boilerplate overhead.

In practice, the script opens the configuration file, validates whether all mandatory legal fields are filled out, and applies the evaluation matrix to determine if a risk is tolerable or critical. If any essential information is missing, the program halts execution and warns the safety engineer before the official report is generated.

The functional code below demonstrates how to load the JSON file, iterate over risks, and calculate criticality by multiplying probability and severity:

import json

def process_inventory(file_path):
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            data = json.load(f)
    except FileNotFoundError:
        print("Inventory file not found.")
        return

    print(f"Processing risks for: {data['company']} - {data['department']}
")

    for risk in data['risks']:
        risk_level = risk['probability'] * risk['severity']
        status = "CRITICAL" if risk_level >= 8 else "Tolerable"
        
        print(f"Risk [{risk['id']}]: {risk['factor']}")
        print(f"  Risk Score: {risk_level} ({status})")
        print(f"  Action: {risk['control_measure']}
")

if __name__ == '__main__':
    process_inventory('inventory.json')

Generating reports and integrating workflows

After validating and computing risk scores, the automation cycle is completed by generating consolidated reports in formats like Markdown, HTML, or PDF for immediate distribution to management. Instead of manually drafting documents every time a factory floor change occurs, the script updates the document in fractions of a second.

In practice, this approach ensures total traceability, since any modification to the original JSON file is logged in the technology team's version control system. This perfectly aligns with the principle of continuous improvement required by modern technical standards, reducing paperwork time so professionals can focus on actual hazard mitigation.

Furthermore, the processed file can be pushed directly to corporate endpoints, powering real-time management dashboards. This synergy between engineering and development elevates the company's regulatory compliance maturity.

Final Thoughts

Automating the NR 1 risk inventory using Python and JSON structures represents a natural evolution for companies seeking efficiency and precision in occupational safety. By replacing repetitive manual processes with clean, auditable code, we eliminate human error and ensure continuous legal compliance.

Adopting this engineering mindset in risk management protects workers more effectively and simplifies the work of safety professionals. The future of regulatory compliance inevitably relies on the integration between technical standards and modern data pipelines.