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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Graph RAG > Succession Planning Graph - Identifying Leadership Pipelines in Neo4j

Succession Planning Graph - Identifying Leadership Pipelines in Neo4j

Author: Venkata Sudhakar

ShopMax India's leadership team needs to plan for succession - when a VP Engineering or Director leaves, who internally is ready to step up? Traditional HR systems store performance ratings in flat tables and require manual analysis to identify readiness. Neo4j models the career ladder as a graph: role nodes define requirements, QUALIFIES_FOR edges connect employees to roles they are ready for (with a readiness score), and HAS_PREREQUISITE edges link roles in career progression order. HR can query the graph to instantly find the top internal candidates for any open position.

The succession graph has three node types: Role (title, level, minExperience), Employee (name, tenure, city), and Skill (name). Relationships include QUALIFIES_FOR (employee to role, with a readiness score 0-100), HAS_SKILL (employee to skill), and REQUIRES_SKILL (role to skill). A succession query matches employees with QUALIFIES_FOR edges to the target role, filters by minimum readiness threshold, and sorts by readiness descending to produce a ranked shortlist. The query can also traverse HAS_PREREQUISITE to find employees who are one role away from being ready.

The example below creates ShopMax India role hierarchy from Developer to CTO, adds five employees with varying skills and readiness scores, then queries the succession pipeline for the VP Engineering vacancy and also finds employees who are close to qualifying but need one more skill.

from neo4j import GraphDatabase

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

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

def setup_succession_graph(session):
    session.run("MATCH (n) DETACH DELETE n")
    session.run("""
    CREATE (dev:Role {title: "Developer", level: 1})
    CREATE (sr:Role {title: "Senior Developer", level: 2})
    CREATE (mgr:Role {title: "Engineering Manager", level: 3})
    CREATE (vp:Role {title: "VP Engineering", level: 4})
    CREATE (cto:Role {title: "CTO", level: 5})
    CREATE (dev)-[:HAS_PREREQUISITE]->(sr)
    CREATE (sr)-[:HAS_PREREQUISITE]->(mgr)
    CREATE (mgr)-[:HAS_PREREQUISITE]->(vp)
    CREATE (vp)-[:HAS_PREREQUISITE]->(cto)
    CREATE (e1:Employee {name: "Priya Nair", tenure: 8, city: "Bangalore"})
    CREATE (e2:Employee {name: "Amit Verma", tenure: 6, city: "Bangalore"})
    CREATE (e3:Employee {name: "Sneha Iyer", tenure: 5, city: "Hyderabad"})
    CREATE (e4:Employee {name: "Kiran Rao", tenure: 4, city: "Mumbai"})
    CREATE (e5:Employee {name: "Divya Pillai", tenure: 3, city: "Chennai"})
    CREATE (e1)-[:QUALIFIES_FOR {readiness: 92}]->(vp)
    CREATE (e1)-[:QUALIFIES_FOR {readiness: 85}]->(mgr)
    CREATE (e2)-[:QUALIFIES_FOR {readiness: 78}]->(mgr)
    CREATE (e2)-[:QUALIFIES_FOR {readiness: 60}]->(vp)
    CREATE (e3)-[:QUALIFIES_FOR {readiness: 70}]->(mgr)
    CREATE (e4)-[:QUALIFIES_FOR {readiness: 55}]->(mgr)
    CREATE (e5)-[:QUALIFIES_FOR {readiness: 45}]->(sr)
    """)

def get_succession_pipeline(session, role_title, min_readiness):
    result = session.run("""
    MATCH (emp:Employee)-[q:QUALIFIES_FOR]->(role:Role {title: $title})
    WHERE q.readiness >= $min
    RETURN emp.name AS candidate, emp.city AS city,
           emp.tenure AS tenure, q.readiness AS readiness
    ORDER BY q.readiness DESC
    """, title=role_title, min=min_readiness)
    return [record.data() for record in result]

def get_near_ready(session, role_title, below_threshold):
    result = session.run("""
    MATCH (emp:Employee)-[q:QUALIFIES_FOR]->(role:Role {title: $title})
    WHERE q.readiness < $threshold
    RETURN emp.name AS candidate, q.readiness AS readiness,
           ($threshold - q.readiness) AS gap
    ORDER BY gap
    """, title=role_title, threshold=below_threshold)
    return [record.data() for record in result]

with driver.session() as session:
    setup_succession_graph(session)

print("Succession pipeline for VP Engineering (readiness >= 70):")
    for r in get_succession_pipeline(session, "VP Engineering", 70):
        name = r.get("candidate", "")
        city = r.get("city", "")
        tenure = r.get("tenure", 0)
        score = r.get("readiness", 0)
        print("  " + name + " (" + city + ", " + str(tenure) + "yr) - Readiness: " + str(score))

print()
    print("Near-ready candidates for VP Engineering (gap analysis):")
    for r in get_near_ready(session, "VP Engineering", 70):
        name = r.get("candidate", "")
        score = r.get("readiness", 0)
        gap = r.get("gap", 0)
        print("  " + name + " - Score: " + str(score) + " (gap: " + str(gap) + " points)")

driver.close()

It gives the following output,

Succession pipeline for VP Engineering (readiness >= 70):
  Priya Nair (Bangalore, 8yr) - Readiness: 92

Near-ready candidates for VP Engineering (gap analysis):
  Amit Verma - Score: 60 (gap: 10 points)

In production, calculate readiness scores dynamically using a Cypher formula that weights tenure, skills matched, and recent performance review data rather than storing static scores. Connect the succession graph to the skills graph from the previous tutorial so that QUALIFIES_FOR edges are computed automatically when an employee earns all required skills for a role. Set a development plan trigger: when the gap is under 15 points, automatically generate a recommended training path using the PREREQUISITE_OF graph from the onboarding tutorial. For ShopMax India, review succession pipelines quarterly and flag roles with no candidates above 70 readiness as critical risk positions needing external hiring.

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