Connecting the Dots: Integrating Your Existing Database with Graph.do

Your business runs on data. It likely lives in robust, familiar SQL databases, spreadsheets, or data lakes—organized neatly into rows and columns. This structure is excellent for transactional records and aggregations. But what about the intricate web of relationships hidden between those rows? How do you easily see how a customer, a product, and a support ticket are all connected? For that, you need a graph.

Traditional databases can tell you what happened, but they struggle to show you how things are connected. Answering questions like "Which marketing campaigns influenced customers who bought product X and also left a 5-star review?" can require complex, slow, and brittle SQL joins.

This is where relationship analysis shines, and graph.do is the simplest way to unlock it without abandoning your existing infrastructure. This post will guide you on how to bridge the gap and integrate your current database with graph.do to transform your flat data into powerful, interactive network graphs.

Why Your Relational Database is Hiding a Powerful Secret

Every database with foreign keys or join tables is a graph in disguise. A users table connected to an orders table, which in turn connects to a products table, is a simple graph.

The problem is, you can't see it that way. You can't visually explore it. The power of a network graph is its ability to make these connections intuitive. Instead of complex queries, you can visually traverse paths, identify clusters, and spot anomalies. This kind of data visualization is transformative for:

• Fraud Detection: Spotting rings of fraudulent accounts that share common devices or addresses.
• Supply Chain Logistics: Visualizing dependencies and identifying single points of failure.
• Knowledge Graphs: Mapping internal expertise, documents, and projects.
• Social Network Analysis: Understanding influence and community structures.

The insights are there, locked in your tables. graph.do gives you the key.

The Integration Hurdle: From Tables to Networks

So, why doesn't everyone do this? Traditionally, moving to a graph database model was seen as a massive undertaking. It meant:

• Complex Migration: A complete "rip-and-replace" of your existing database.
• New Query Languages: Learning Cypher or Gremlin instead of using familiar SQL.
• Infrastructure Overhead: Managing and scaling a new type of database.

graph.do eliminates these barriers. It’s not just another database; it's an agentic workflow platform designed to sit on top of your data ecosystem. It provides graphs as a service, allowing you to get all the benefits of relationship analysis without the pain of migration.

Enter graph.do: Your Data's Relationship Navigator

With graph.do, you don't have to move your data. You simply connect it. Our platform provides flexible data ingestion APIs, allowing you to easily build and update your graphs dynamically from your existing sources.

Think of it as a powerful new lens for your data. Your SQL database remains the source of truth, while graph.do provides the rich, interactive visualization and analysis layer.

The Power of a Simple Graph API

The magic lies in our developer-first approach. We've abstracted away the complexity of graph data modeling and querying into a clean, simple graph API. You can define nodes (the "things" in your data) and edges (the relationships between them) with just a few lines of code.

Here's how effortlessly you can create a graph from your data:

import { graph } from '@do/sdk';

// Agentically create and visualize a graph from your data
const myGraph = await graph.create({
  name: 'Project Team Graph',
  nodes: [
    { id: 'dev1', label: 'Alice', properties: { role: 'Engineer' } },
    { id: 'pm1', label: 'Charlie', properties: { role: 'Product Manager' } },
    { id: 'design1', label: 'Bob', properties: { role: 'Designer' } },
  ],
  edges: [
    { from: 'dev1', to: 'pm1', label: 'reports to' },
    { from: 'design1', to: 'pm1', label: 'reports to' },
    { from: 'dev1', to: 'design1', label: 'collaborates with' },
  ],
});

// A unique, shareable URL is instantly generated for your interactive graph
console.log(myGraph.url);

This simple call creates a fully interactive graph visualization that your team can explore, filter, and analyze in real-time.

Your 3-Step Roadmap to Integration

Getting started is straightforward. Here’s a conceptual guide to connecting your existing database with graph.do.

Step 1: Identify the Connections in Your Data

Look at your database schema.

• Tables often represent Nodes. A Customers table becomes a set of "Customer" nodes.
• Rows within those tables become individual nodes (e.g., each customer is a node).
• Foreign Keys or Join Tables represent Edges. If your Orders table has a customer_id, that's a "placed" edge from a Customer node to an Order node.

Step 2: Push Data to the Graph API

Write a simple script that reads from your database and uses the graph.do SDK or API to create nodes and edges. You can run this as a one-time batch job to create an initial snapshot or set it up as a recurring task or data stream to keep your graph continuously updated.

Step 3: Visualize, Query, and Discover

Once your data is pushed, graph.do handles the rest. Our platform automatically organizes the entities into a high-performance graph, ready for exploration. You immediately get a URL to an interactive visualization. Click on nodes, expand connections, filter by properties, and start discovering the patterns that were impossible to see in your tables.

Did you know? graph.do is built on a scalable, cloud-native architecture. Our agentic workflows automatically optimize data handling, queries, and rendering to ensure high performance, even with millions of nodes and edges.

Unlock Your Data's Full Potential Today

Your existing database is a goldmine of relational information. Don't let its tabular structure limit your ability to understand the connections within. By integrating with graph.do, you can layer powerful, intuitive data visualization and relationship analysis on top of your current systems—without the cost and complexity of a full migration.

Ready to connect the dots in your data? Explore the graph.do platform and turn your tables into actionable insights.