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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Graph RAG > Modeling Employee Hierarchy in Neo4j - Org Charts with Cypher

Modeling Employee Hierarchy in Neo4j - Org Charts with Cypher

Author: Venkata Sudhakar

ShopMax India operates across Mumbai, Bangalore, Delhi, Hyderabad, and Chennai with hundreds of employees in engineering, logistics, sales, and support teams. Modeling who reports to whom is a classic problem that relational databases solve poorly through recursive self-joins. Neo4j, a native graph database, treats relationships as first-class citizens and stores the employee hierarchy as nodes connected by directed edges. ShopMax India uses Neo4j so the HR team can traverse the full management chain in a single query without writing complex SQL.

In Neo4j, each employee is a node with the label Employee and properties such as id, name, role, and city. The reporting relationship is modeled as a directed edge (emp)-[:REPORTS_TO]->(manager). Cypher is the declarative query language: MATCH (emp)-[:REPORTS_TO]->(mgr {name: $name}) returns direct reports, while REPORTS_TO* follows the chain to any depth. The neo4j Python driver connects via the Bolt protocol at bolt://localhost:7687 and sessions run Cypher statements with parameter substitution to prevent injection.

The example below creates ShopMax India tech division with a CTO at the root, two VPs, two engineering managers, and two developers. It queries direct reports for Priya Nair (VP Engineering) and prints the full org chart under the CTO using variable-length REPORTS_TO* path matching.

from neo4j import GraphDatabase

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

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

def create_org_chart(session):
    session.run("MATCH (n) DETACH DELETE n")
    session.run("""
    CREATE (cto:Employee {id: "E001", name: "Arjun Sharma", role: "CTO", city: "Mumbai"})
    CREATE (vp1:Employee {id: "E002", name: "Priya Nair", role: "VP Engineering", city: "Bangalore"})
    CREATE (vp2:Employee {id: "E003", name: "Rahul Mehta", role: "VP Products", city: "Delhi"})
    CREATE (mgr1:Employee {id: "E004", name: "Sneha Iyer", role: "Eng Manager", city: "Bangalore"})
    CREATE (mgr2:Employee {id: "E005", name: "Kiran Rao", role: "Eng Manager", city: "Hyderabad"})
    CREATE (dev1:Employee {id: "E006", name: "Amit Verma", role: "Senior Dev", city: "Bangalore"})
    CREATE (dev2:Employee {id: "E007", name: "Divya Pillai", role: "Developer", city: "Bangalore"})
    CREATE (vp1)-[:REPORTS_TO]->(cto)
    CREATE (vp2)-[:REPORTS_TO]->(cto)
    CREATE (mgr1)-[:REPORTS_TO]->(vp1)
    CREATE (mgr2)-[:REPORTS_TO]->(vp1)
    CREATE (dev1)-[:REPORTS_TO]->(mgr1)
    CREATE (dev2)-[:REPORTS_TO]->(mgr1)
    """)

def get_direct_reports(session, manager_name):
    result = session.run("""
    MATCH (emp:Employee)-[:REPORTS_TO]->(mgr:Employee {name: $name})
    RETURN emp.name AS name, emp.role AS role, emp.city AS city
    ORDER BY emp.name
    """, name=manager_name)
    return [record.data() for record in result]

def get_org_chart(session, root_name):
    result = session.run("""
    MATCH path = (emp:Employee)-[:REPORTS_TO*]->(root:Employee {name: $name})
    RETURN emp.name AS name, emp.role AS role, length(path) AS level
    ORDER BY level, emp.name
    """, name=root_name)
    return [record.data() for record in result]

with driver.session() as session:
    create_org_chart(session)
    print("Direct reports to Priya Nair:")
    for r in get_direct_reports(session, "Priya Nair"):
        name = r.get("name", "")
        role = r.get("role", "")
        city = r.get("city", "")
        print("  " + name + " (" + role + ") - " + city)
    print()
    print("Full org chart under Arjun Sharma (CTO):")
    for r in get_org_chart(session, "Arjun Sharma"):
        level = r.get("level", 0)
        name = r.get("name", "")
        role = r.get("role", "")
        print("  " * level + name + " (" + role + ")")

driver.close()

It gives the following output,

Direct reports to Priya Nair:
  Kiran Rao (Eng Manager) - Hyderabad
  Sneha Iyer (Eng Manager) - Bangalore

Full org chart under Arjun Sharma (CTO):
  Priya Nair (VP Engineering)
  Rahul Mehta (VP Products)
    Kiran Rao (Eng Manager)
    Sneha Iyer (Eng Manager)
      Amit Verma (Senior Dev)
      Divya Pillai (Developer)

In production, create a uniqueness constraint on Employee.id to prevent duplicate nodes on re-import. Use MERGE instead of CREATE to safely upsert employee data from the HR system. Add an index on Employee.name and Employee.id for fast MATCH lookups. Keep the REPORTS_TO direction consistent - always pointing from subordinate to manager - to avoid ambiguous traversal results. For very deep hierarchies (more than 10 levels), consider caching the full path as a list property on each node to avoid repeated variable-length traversals under load.

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