	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Graph RAG > Employee Onboarding Path Graph - Role-based Training Sequences

Employee Onboarding Path Graph - Role-based Training Sequences

Author: Venkata Sudhakar

ShopMax India onboards new hires with a structured sequence of training modules tailored to their role. A new backend developer in Bangalore must complete security training before accessing production systems, and architecture training before touching microservices. Modeling these prerequisites as a directed graph in Neo4j lets the HR system compute the optimal training path for any role, track which modules each employee has completed, and flag missing prerequisites before access is granted.

Training modules are stored as Module nodes. A PREREQUISITE_OF relationship from module A to module B means A must be completed before B. To find the onboarding path, traverse the prerequisite graph using topological ordering - modules with no incoming edges come first. Employee completion is tracked as a HAS_COMPLETED relationship between the Employee node and each Module node, with a completedOn date property. Queries can then identify which modules remain for a given employee and what they are blocked on.

The example below creates a training graph for ShopMax India Engineering onboarding. It builds modules like Security Basics, Git Workflow, System Architecture, and Deployment Pipeline with their prerequisites, then computes the ordered training path and shows which modules a new hire has remaining.

from neo4j import GraphDatabase

URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")

driver = GraphDatabase.driver(URI, auth=AUTH)

def setup_training_graph(session):
    session.run("MATCH (n) DETACH DELETE n")
    session.run("""
    CREATE (sec:Module {id: "M01", name: "Security Basics", duration: 4})
    CREATE (git:Module {id: "M02", name: "Git Workflow", duration: 2})
    CREATE (arch:Module {id: "M03", name: "System Architecture", duration: 8})
    CREATE (api:Module {id: "M04", name: "API Standards", duration: 3})
    CREATE (deploy:Module {id: "M05", name: "Deployment Pipeline", duration: 6})
    CREATE (review:Module {id: "M06", name: "Code Review Process", duration: 2})
    CREATE (emp:Employee {id: "E010", name: "Suresh Pillai", role: "Backend Developer"})
    CREATE (sec)-[:PREREQUISITE_OF]->(arch)
    CREATE (sec)-[:PREREQUISITE_OF]->(api)
    CREATE (git)-[:PREREQUISITE_OF]->(review)
    CREATE (arch)-[:PREREQUISITE_OF]->(deploy)
    CREATE (api)-[:PREREQUISITE_OF]->(deploy)
    CREATE (review)-[:PREREQUISITE_OF]->(deploy)
    CREATE (emp)-[:HAS_COMPLETED {completedOn: "2026-04-10"}]->(sec)
    CREATE (emp)-[:HAS_COMPLETED {completedOn: "2026-04-11"}]->(git)
    """)

def get_remaining_modules(session, employee_name):
    result = session.run("""
    MATCH (m:Module)
    WHERE NOT (:Employee {name: $name})-[:HAS_COMPLETED]->(m)
    OPTIONAL MATCH (prereq:Module)-[:PREREQUISITE_OF]->(m)
    WITH m, collect(prereq.name) AS prereqs
    OPTIONAL MATCH (emp:Employee {name: $name})-[:HAS_COMPLETED]->(done:Module)-[:PREREQUISITE_OF]->(m)
    WITH m, prereqs, count(done) AS completed_prereqs
    RETURN m.name AS module, m.duration AS hours,
           prereqs, completed_prereqs,
           CASE WHEN size(prereqs) = 0 OR size(prereqs) = completed_prereqs
                THEN "Ready" ELSE "Blocked" END AS status
    ORDER BY status, m.name
    """, name=employee_name)
    return [record.data() for record in result]

with driver.session() as session:
    setup_training_graph(session)
    print("Onboarding status for Suresh Pillai:")
    for r in get_remaining_modules(session, "Suresh Pillai"):
        module = r.get("module", "")
        hours = r.get("hours", 0)
        status = r.get("status", "")
        prereqs = r.get("prereqs", [])
        prereq_str = ", ".join(prereqs) if prereqs else "None"
        print("  [" + status + "] " + module + " (" + str(hours) + "h) | Prereqs: " + prereq_str)

driver.close()

It gives the following output,

Onboarding status for Suresh Pillai:
  [Blocked] API Standards (3h) | Prereqs: Security Basics
  [Blocked] Deployment Pipeline (6h) | Prereqs: System Architecture, API Standards, Code Review Process
  [Blocked] System Architecture (8h) | Prereqs: Security Basics
  [Ready] Code Review Process (2h) | Prereqs: Git Workflow

In production, add a role property to Module nodes and filter by role before computing the path, so backend developers and logistics staff see different onboarding sequences. Store completedOn as a Neo4j Date type rather than a string for range queries like 'modules completed in the last 30 days'. Use apoc.path.subgraphAll from the APOC library to extract the full prerequisite subgraph for a module in one call. For compliance-sensitive modules like security training, add an expiresAfterDays property and flag employees whose completion has lapsed.

Send your comments, suggestions or queries regarding this site to [email protected].