Interview - Knowledge Graph Data Engineer

1

🟢 EASY

2 points

What is the primary purpose of Neo4j in enterprise data architecture?

To store and query data as interconnected nodes and relationships in a graph database

To provide a semantic layer for understanding relationships between entities and enabling traversal-based queries

To serve as a knowledge graph backbone for AI systems requiring contextual reasoning and entity linking

To replace traditional relational databases with a document-oriented NoSQL solution

2

🟢 EASY

2 points

What is GraphRAG and how does it improve retrieval quality?

GraphRAG combines graph databases with Retrieval-Augmented Generation to provide contextually rich, relationship-aware information to LLMs

It uses knowledge graphs to enhance retrieval by providing entity relationships, metadata, and semantic connections alongside raw text chunks

GraphRAG enables multi-hop reasoning by traversing graph relationships to find relevant context beyond simple vector similarity

It's a visualization tool for displaying database relationships in a graphical user interface

3

🟢 EASY

2 points

What is the role of Cypher in Neo4j?

Cypher is Neo4j's declarative query language for pattern matching and graph traversal

It allows developers to express complex relationship queries using ASCII-art style pattern syntax like (node)-[relationship]->(node)

Cypher enables creation, reading, updating, and deletion of nodes, relationships, and properties in the graph

Cypher is an encryption protocol used to secure Neo4j database connections

4

🔵 MEDIUM

3 points

How would you design an ETL pipeline from Microsoft Fabric to Neo4j for banking transaction data?

Extract data from Fabric using Spark/SQL, transform into nodes (Accounts, Transactions, Customers) and relationships (OWNS, MADE_TRANSACTION), load via Neo4j batch import or Cypher scripts

Implement CDC (Change Data Capture) for incremental updates, use MERGE operations to handle upserts, maintain data lineage metadata in graph properties

Design hierarchical entity model with proper indexes on unique identifiers, use APOC procedures for bulk operations, implement data validation and quality checks

Copy all transaction records as individual text files and manually import them using Neo4j Browser interface

5

🔵 MEDIUM

3 points

What are APOC procedures in Neo4j and when would you use them?

APOC (Awesome Procedures On Cypher) is a library of 450+ procedures and functions extending Neo4j's capabilities for common data operations

Use APOC for bulk data loading (apoc.load.json, apoc.load.csv), data transformation (apoc.convert, apoc.text), and advanced graph algorithms

APOC provides utilities for database operations (apoc.periodic.iterate for batching), schema manipulation, and integration with external systems

APOC is a machine learning framework for training neural networks on graph data

6

🔵 MEDIUM

3 points

How do you implement incremental delta updates in a Neo4j pipeline?

Use MERGE statements with unique constraints to upsert nodes/relationships, implement timestamp-based filtering on source data to identify changes

Leverage CDC from source systems (Fabric Change Feed), maintain watermark tables for tracking last processed timestamps, use batch processing for efficiency

Implement idempotent pipelines using MATCH/MERGE patterns, handle deletions with soft delete flags or separate cleanup processes, log all changes for auditability

Delete entire graph and reload all data from scratch on every pipeline run

7

🔵 MEDIUM

3 points

What indexing strategies would you use to optimize Neo4j for agent retrieval?

Create unique constraints on key identifiers (entity IDs, customer numbers), implement composite indexes on frequently queried property combinations

Use full-text indexes (db.index.fulltext) for natural language search on text properties, implement range indexes for temporal queries

Add vector indexes for embedding-based similarity search in GraphRAG scenarios, ensure relationship indexes for traversal-heavy queries

Avoid all indexes as they slow down write operations and Neo4j performs best with sequential scans

8

🔵 MEDIUM

3 points

How would you structure embeddings in a Neo4j GraphRAG implementation?

Store embeddings as vector properties on nodes (text chunks, entities), use Neo4j vector indexes for similarity search, link chunks to entities via relationships

Create separate embedding nodes connected to source entities, implement hybrid search combining vector similarity with graph traversal for context enrichment

Maintain metadata about embedding model, version, and generation timestamp, enable entity linking to connect semantically similar but disconnected graph regions

Store all embeddings in a separate Redis cache and never persist them in Neo4j

9

🔵 MEDIUM

3 points

What are the key considerations for data lineage in a Neo4j knowledge graph?

Track source system, ingestion timestamp, and pipeline version as node properties, maintain DERIVED_FROM relationships between transformed and source entities

Implement audit nodes recording data transformations, changes, and business rules applied, enable temporal queries to reconstruct graph state at any point in time

Use labels and metadata to identify data quality scores, validation status, and confidence levels, support compliance requirements with full traceability

Data lineage is not relevant in graph databases as relationships provide all necessary context

10

🟠 HARD

4 points

Design a graph model for a banking system supporting multi-agent workflows with accounts, transactions, customers, and risk signals.

Core entities: (Customer)-[:OWNS]->(Account), (Account)-[:MADE_TRANSACTION {amount, timestamp, type}]->(Account), add RiskSignal nodes with [:FLAGGED_BY] relationships, include temporal properties for point-in-time queries

Hierarchical structures: (Customer)-[:HAS_PROFILE]->(CustomerProfile {KYC_data}), (Transaction)-[:INVOLVES]->(Account), (Transaction)-[:HAS_CATEGORY]->(Category), support graph algorithms for fraud detection via relationship patterns

Agent-optimized design: Create aggregate nodes for common queries (MonthlyAccountSummary), use directed relationships with properties for efficient traversal, implement indexes on entity IDs and transaction timestamps, add metadata for entity resolution and linking

Store everything as a single JSON document in one node and let agents parse the entire structure on every query

11

🟠 HARD

4 points

How would you optimize a Neo4j query that's taking 30+ seconds to retrieve customer transaction history with relationship patterns?

Profile query with EXPLAIN/PROFILE, identify missing indexes on relationship types and properties, use MATCH patterns that leverage indexed lookups, avoid Cartesian products and unbounded variable-length paths

Implement query result caching for frequently accessed patterns, denormalize hot paths with aggregate relationships, use LIMIT/SKIP for pagination, consider graph projection for complex analytical queries

Optimize relationship direction (follow direction of most selective relationships first), use parameters instead of literals, batch multiple queries using APOC, consider adding intermediate summary nodes for common aggregations

Increase server RAM to 1TB and hope the query becomes faster without changing anything

12

🟠 HARD

4 points

Describe your approach to implementing hybrid search (vector + graph traversal) for agentic retrieval in a financial knowledge graph.

Vector search: Use Neo4j vector index to find top-k semantically similar text chunks/entities based on query embedding, implement approximate nearest neighbor (ANN) search with cosine similarity

Graph expansion: From vector-matched entities, traverse relationships (1-3 hops) to enrich context with connected entities, transactions, and metadata, use Cypher path patterns to find relevant subgraphs

Hybrid ranking: Combine vector similarity scores with graph-based relevance (PageRank, relationship strength), implement re-ranking based on entity importance and recency, return structured context with relationships for agent reasoning

Only use basic keyword search without vectors or graph traversal to keep things simple

13

🟠 HARD

4 points

What strategy would you use to scale Neo4j ingestion for processing 100M+ nodes and 500M+ relationships?

Use neo4j-admin import for initial bulk load (fastest method), split data into batches, leverage parallel processing with proper uniqueness constraints, disable indexes during bulk load and rebuild after

Implement incremental ingestion with APOC apoc.periodic.iterate for batched MERGE operations, use UNWIND for batch Cypher statements, tune heap size and page cache for large datasets, implement retry logic for transient failures

Design partitioned ingestion strategy (by entity type, time range, or business domain), use multiple Neo4j instances with Fabric for distributed queries if needed, implement monitoring and health checks for long-running pipelines, compress/archive historical data

Import everything in a single transaction using a simple CREATE statement without any batching

14

🔴 CRITICAL

5 points

You're building the core memory layer for PwC's agentic AI system. The system has 50+ agents querying Neo4j for banking operations context. How do you architect this for reliability, performance, and explainability?

Architecture: Deploy Neo4j cluster (causal cluster for HA), implement read replicas for agent queries, use Fabric for federated querying across domains (Finance, Ops, Supply Chain), implement query routing based on agent type and data access patterns

Performance: Build materialized views for common agent query patterns, implement multi-level caching (query cache, application cache with Redis), use graph projections for analytical workloads, optimize indexes for agent retrieval patterns, implement connection pooling and query timeout policies

Explainability: Maintain full lineage metadata (source, transformation, confidence), implement versioned graph snapshots for temporal queries, log all agent queries with context, build audit trails showing reasoning paths through graph, provide citation tracking via relationship properties

Use a single Neo4j Community Edition instance with no replication, caching, or monitoring

15

🔴 CRITICAL

5 points

Design an end-to-end data quality framework for a knowledge graph powering mission-critical banking agents. Include validation, monitoring, and remediation strategies.

Ingestion Quality: Implement schema validation at pipeline entry, check referential integrity (all relationships point to valid nodes), validate data types and required properties, detect duplicates using entity resolution, measure completeness and accuracy against source

Graph Quality: Run automated health checks (orphaned nodes, broken relationships, constraint violations), implement graph algorithms for anomaly detection (unusual degree distributions, isolated subgraphs), validate business rules via Cypher queries, measure semantic consistency across entity linking

Monitoring & Remediation: Build quality dashboards tracking KPIs (entity coverage, relationship density, freshness), implement alerting for quality degradation, create automated remediation workflows for common issues, maintain quality audit logs, enable human-in-the-loop validation for critical entities, version control graph schema changes

Don't implement any quality checks - trust that source data is always perfect and agents will handle any issues

🔗 Technical Interview

📋 Candidate Information

📊 Final Score

🟢 Easy

🔵 Medium

🟠 Hard

🔴 Critical

📋 Interview Report