Developer Graph Explorer

A graph-based developer exploration and job-matching application built with Flask, CognoDB, and the official Neo4j Python driver.

The application models developers, projects, technologies, skills, and jobs as connected graph entities. It uses Cypher and graph traversal to explore developer experience and identify relevant job opportunities.

Features

Search developers dynamically
Explore projects built by a developer
Explore technologies used by projects
Match developer skills with job requirements
Recommend jobs using matching skills and shared technologies
Demonstrate multi-hop graph traversal
Seed realistic graph data
Interactive Flask web application

Use Case

The application focuses on developer project exploration and job matching.

It answers questions such as:

What projects has a developer built?
What technologies are used in those projects?
Which jobs match the developer's skills?
Which technologies are shared between the developer's projects and a job?
Which jobs are connected through both skill and technology relationships?

Why a Graph Database?

This use case is relationship-centric rather than row-centric.

A developer is connected to projects, projects are connected to technologies, developers are connected to skills, and jobs are connected to both required skills and technologies.

A graph database makes these connected questions natural to query because the application can traverse relationships across multiple entity types.

For example, the main recommendation query connects:

Developer
   |
   +-- HAS_SKILL --> Skill <-- REQUIRES -- Job
   |
   +-- BUILT --> Project -- USES --> Technology <-- USES -- Job

This allows the application to identify jobs that match both the developer's skills and the technologies used in the developer's projects.

This type of connected traversal becomes more cumbersome to express and maintain in a traditional relational schema as relationships become deeper.

Graph Model

Developer
    |
    | BUILT
    v
Project
    |
    | USES
    v
Technology


Developer
    |
    | HAS_SKILL
    v
Skill
    ^
    | REQUIRES
    |
Job
    |
    | USES
    v
Technology

Nodes

Developer
Project
Technology
Skill
Job

Relationships

Developer -[:BUILT]-> Project
Project -[:USES]-> Technology
Developer -[:HAS_SKILL]-> Skill
Job -[:REQUIRES]-> Skill
Job -[:USES]-> Technology

Data Model

The seed data contains:

4 developers
5 projects
8 technologies
6 skills
4 jobs

The dataset is loaded from seed.cypher using the included loading script.

Main Queries

1. Projects

Find projects built by a selected developer.

MATCH (d:Developer {name: $developer_name})-[:BUILT]->(p:Project)
RETURN d.name AS developer,
       p.name AS project,
       p.category AS category
ORDER BY project

This demonstrates a parameterized developer-to-project traversal.

2. Project Technologies

Find technologies used across a developer's projects.

MATCH (d:Developer {name: $developer_name})
      -[:BUILT]->(p:Project)
      -[:USES]->(t:Technology)
RETURN d.name AS developer,
       p.name AS project,
       t.name AS technology
ORDER BY project, technology

This is a multi-hop traversal:

Developer → Project → Technology

3. Matching Jobs

Find jobs whose required skills overlap with a developer's skills.

MATCH (d:Developer {name: $developer_name})
      -[:HAS_SKILL]->(s:Skill)<-[:REQUIRES]-(j:Job)
RETURN d.name AS developer,
       j.title AS job,
       j.company AS company,
       collect(s.name) AS matching_skills,
       count(s) AS skill_matches
ORDER BY skill_matches DESC

This traverses:

Developer → Skill ← Job

4. Graph-Based Job Matches

The main recommendation query combines skill and technology relationships.

MATCH (d:Developer {name: $developer_name})
      -[:HAS_SKILL]->(s:Skill)<-[:REQUIRES]-(j:Job)
      -[:USES]->(t:Technology)<-[:USES]-(p:Project)<-[:BUILT]-(d)

RETURN d.name AS developer,
       j.title AS job,
       j.company AS company,
       collect(DISTINCT s.name) AS matching_skills,
       collect(DISTINCT t.name) AS shared_technologies,
       count(DISTINCT s) AS skill_matches,
       count(DISTINCT t) AS technology_matches

ORDER BY skill_matches DESC, technology_matches DESC

This query connects multiple parts of the graph:

Developer
   ↓ HAS_SKILL
Skill
   ↑ REQUIRES
Job
   ↓ USES
Technology
   ↑ USES
Project
   ↑ BUILT
Developer

It returns:

Matching skills
Shared technologies
Skill match count
Technology match count

This is the primary graph-centric feature of the application.

Technology Stack

Python
Flask
CognoDB
Official Neo4j Python Driver
Cypher / openCypher
HTML5
CSS3
python-dotenv

Project Structure

wexa-devgraph/
│
├── queries/
│   └── graph_queries.cypher
│
├── templates/
│   └── index.html
│
├── app.py
├── run_query.py
├── load_seed.py
├── seed.cypher
├── test_connection.py
├── requirements.txt
├── .env
├── .gitignore
└── README.md

CognoDB Setup

Create an account at the CognoDB Cloud console.
Create a free c0 database instance.
Save the generated Bolt URI and password.
Use the official Neo4j Python driver to connect to the instance.
Store the connection details in environment variables.

CognoDB provides a Bolt connection URI similar to:

bolt+s://<instance-id>.databases.cognodb.cloud

Environment Variables

Create a .env file in the project root:

COGNODB_URI=your_cognodb_uri
COGNODB_USERNAME=cognodb
COGNODB_PASSWORD=your_password

Never commit .env to GitHub.

Installation

Clone the repository:

git clone https://github.com/tarunreddykalluri/wexa-devgraph.git
cd wexa-devgraph

Create a virtual environment:

python -m venv venv

Activate it on Windows:

venv\Scripts\activate

Install dependencies:

pip install -r requirements.txt

Load Seed Data

Configure the CognoDB credentials in .env.

Then run:

python load_seed.py

This loads the developers, projects, technologies, skills, jobs, and graph relationships from seed.cypher.

Test the Database Connection

python test_connection.py

Run Graph Queries

Examples:

python run_query.py projects

python run_query.py project_technologies

python run_query.py matching_jobs

python run_query.py graph_job_matches

A developer can also be supplied explicitly:

python run_query.py projects "Tharun Kumar"

Run the Application

Start Flask:

python app.py

Open:

http://127.0.0.1:5000

Enter a developer name and click Explore.

Example developers:

Tharun Kumar
Priya Sharma
Arjun Rao
Rahul Mehta

Screenshots