Tech Stack Selector -- Postgres + Neo4j Knowledge Graph

This project provides a price-focused technology stack selector.
It uses a Postgres relational database for storing technologies and pricing, and builds a Neo4j knowledge graph to support advanced queries like:

"Show me all backend, frontend, and cloud technologies that fit a $10-$50 budget."

📌 1. Database Schema (Postgres)

The schema is designed to ensure data integrity and price-tier-driven recommendations.

Core Tables

price_tiers -- Foundation table for price categories (tiers like Free, Low, Medium, Enterprise).
Category-Specific Tables -- Each technology domain has its own table:
- frontend_technologies
- backend_technologies
- cloud_technologies
- database_technologies
- testing_technologies
- mobile_technologies
- devops_technologies
- ai_ml_technologies
tools -- Central table for business/productivity tools with:
- name, category, description
- primary_use_cases
- popularity_score
- Pricing fields: monthly_cost_usd, setup_cost_usd, license_cost_usd, training_cost_usd, total_cost_of_ownership_score
- Foreign key to price_tiers

All category tables reference price_tiers(id) ensuring referential integrity.

🧱 2. Migration Files

Your migrations are structured as follows:

001_schema.sql -- Creates all tables, constraints, indexes.
002_tools_migration.sql -- Adds tools table and full-text search indexes.
003_tools_pricing_migration.sql -- Adds cost-related fields to tools and links to price_tiers.

Run them in order:

psql -U <user> -d <database> -f sql/001_schema.sql
psql -U <user> -d <database> -f sql/002_tools_migration.sql
psql -U <user> -d <database> -f sql/003_tools_pricing_migration.sql

🕸️ 3. Neo4j Knowledge Graph Design

We map relational data into a graph for semantic querying.

Node Types

Technology → {name, category, description, popularity_score}
Category → {name}
PriceTier → {tier_name, min_price, max_price}

Relationships

(Technology)-[:BELONGS_TO]->(Category)
(Technology)-[:HAS_PRICE_TIER]->(PriceTier)

Example graph:

(:Technology {name:"NodeJS"})-[:BELONGS_TO]->(:Category {name:"Backend"})
(:Technology {name:"NodeJS"})-[:HAS_PRICE_TIER]->(:PriceTier {tier_name:"Medium"})

🔄 4. ETL (Extract → Transform → Load)

Use a Python ETL script to pull from Postgres and load into Neo4j.

Example Script

from neo4j import GraphDatabase
import psycopg2

pg_conn = psycopg2.connect(host="localhost", database="techstack", user="user", password="pass")
pg_cur = pg_conn.cursor()

driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password"))

def insert_data(tx, tech_name, category, price_tier):
    tx.run("""
    MERGE (c:Category {name: $category})
    MERGE (t:Technology {name: $tech})
    ON CREATE SET t.category = $category
    MERGE (p:PriceTier {tier_name: $price_tier})
    MERGE (t)-[:BELONGS_TO]->(c)
    MERGE (t)-[:HAS_PRICE_TIER]->(p)
    """, tech=tech_name, category=category, price_tier=price_tier)

pg_cur.execute("SELECT name, category, tier_name FROM tools JOIN price_tiers ON price_tiers.id = tools.price_tier_id")
rows = pg_cur.fetchall()

with driver.session() as session:
    for name, category, tier in rows:
        session.write_transaction(insert_data, name, category, tier)

pg_conn.close()
driver.close()

🔍 5. Querying the Knowledge Graph

Find technologies in a price range:

MATCH (t:Technology)-[:HAS_PRICE_TIER]->(p:PriceTier)
WHERE p.min_price >= 10 AND p.max_price <= 50
RETURN t.name, p.tier_name
ORDER BY p.min_price ASC

Find technologies for a specific domain:

MATCH (t:Technology)-[:BELONGS_TO]->(c:Category)
WHERE c.name = "Backend"
RETURN t.name, t.popularity_score
ORDER BY t.popularity_score DESC

🗂️ 6. Suggested Project Structure

techstack-selector/
├── sql/
│   ├── 001_schema.sql
│   ├── 002_tools_migration.sql
│   └── 003_tools_pricing_migration.sql
├── etl/
│   └── postgres_to_neo4j.py
├── api/
│   └── app.py (Flask/FastAPI server for exposing queries)
├── docs/
│   └── README.md

🚀 7. API Layer (Optional)

You can wrap Neo4j queries inside a REST/GraphQL API.

Example response:

{
  "price_range": [10, 50],
  "technologies": [
    {"name": "NodeJS", "category": "Backend", "tier": "Medium"},
    {"name": "React", "category": "Frontend", "tier": "Medium"}
  ]
}

✅ Summary

This README covers: - Postgres schema with pricing and foreign keys - Migration execution steps - Neo4j graph model - Python ETL script - Example Cypher queries - Suggested folder structure

This setup enables price-driven technology recommendations with a clear path for building APIs and AI-powered analytics.

5.6 KiB Raw Blame History