DEV Community: Daniel Stepanian

SaaS System Design - Graphmotivo

Daniel Stepanian — Mon, 09 Feb 2026 11:48:45 +0000

Background

In the last months of 2025 I was under great impression of graphs: graph databases, knowledge graphs, graph algorithms, Neo4j, GraphRAGs. I feel like these technologies open another valuable approach of understanding reality through the lens of relations between them. We can visualize relations, train ML models, find patterns and make better predictions, and understand knowledge domains better.
Under such data-science-oriented influence I also have been learning the DevOps side on intense 5-weekend bootcamp, which gave me abilities to set up, run, monitor and move software production deployments.

Idea, project overview

The idea of using knowledge graphs, embeddings to match buyer persona’s treats to product use cases, and matching it all to Google/META ad configs to reach the right people came to me much earlier and during a couple of months, the final idea matured in my head. I started working on Graphmotivo in late November 2025, and devoted much of my free time throughout December and January. By coincidence, we saw a significant increase in the quality of AI programming, which allowed me to create this project in such a short time: 1.5 months.
Graphmotivo is a future marketing intelligence platform that uses Expert AI Agentic workflows and knowledge graphs, which allows marketers and business owners generate buyer personas, use case story journeys, ad targeting inspirations, and explorable identity graphs of simulated buyer personas.

Development Process

My primary tool was Cursor 2.1.49 version with Composer for researching and planning the work, sometimes Auto mode for simpler stuff, and Sonnet 4.5 / Opus 4.5 for hardest parts, and debugging, which often took place for 2-4 hours to find root causes and make fixes. In total, around 500m tokens were used.

The development process was iterative: I started with the design doc, architecture plan, and building every service step by step, starting with the heart: Neo4j graph database + Agentic workflows to fill it in with data, based on user prompts. I tested several agentic workflows frameworks: Google ADK - Agent Development Kit (dropped it because it had a constraint of running up to 10 steps in a workflow), LangGraph (dropped as it was too complex for debugging, too much of important parts what works and how was hidden under abstraction). So I ended up creating a custom Python workflow of agents that: think about persona matching the business description, research of these persona traits, what they do, their problems, what website they visit. Then another set of agents extracts nodes and relations and translates them to a Cypher query according to a specific database schema that I created during a project planning phase. Cypher queries are invoked, graphs are created. Other agents, based on research agents’ data, generate ad targeting configs, user journey story, generate images for the scenario and return data from Neo4j that can be then used in web-based graphs for visualization. These workflows are deployed in a separate container, and are controlled by API.

Once a scenario generation process was working on local docker containers (this was achieved after ~50+ failing 5 minute agentic workflow processes during development) - I’ve finally got json files that could be loaded to the demo UI. Frontend was built in a separate container, for backend I used Supabase, which is an open source Firebase alternative that makes backend setup much faster, as it comes with Postgres database, storage, authorization out-of-the-box. Payment Integration with Paypal, sandbox tests, and when everything worked locally, I went to the next step: Production deployment.

Building a production environment was based on a central plan in a .md file that was preceded with a research & planning phase. The production steps were:

Pre-deployment preparations (env, code verifications, security hardening)
VPS, DNS setups, server hardening, firewall, user permissions
Infrastructure config with Docker compose
Reverse proxy setup, SSL
Docker Compose deployment, database migrations, RLS policies, network security hardening
GCP integrations: Google Oauth authorization, Pub-sub automation for a spend safety cap - Gemini API cost usage to detach the budget account from the project once spend crosses a treshold.
CI/CD with Github Actions
Testing, debugging the layout, agentic workflows (another 50+ failed during this phase before getting it working), testing auth, payments sandbox > production
Grafana + Loki containers for observability
Ansible playbooks for future reproducibility

Results

In mid-January 2026, everything was working as intended, and the platform was hosted at: https://graphmotivo.dstepanian-tech.ovh/

It offers 3 demo persona purchase story explorations, a flexible token-based payment system allowing users to request their own custom persona + user journey presentation with graph explorations.

There are some improvements that could be done in future i.a. with UX optimization, graph database deduplication (e.g. META vs Meta Ads) but for this stage it’s good enough. It was fun building this, but it required a tight focus and patience to work in Cursor. Sometimes it still feels like working with ultra-fast but clueless temps. These also helped through the process: basic technical understanding of how LLMs work, statistics, AI-augmented programming experience and best practices to guide programming models correctly to the goal, ensure they know what’s needed, and use them to identify root causes of errors together.

Failed Machine Learning Experiment: Training XGBoost Classifier with 1.5m signals

Daniel Stepanian — Sun, 08 Feb 2026 19:15:25 +0000

In 2022 I started creating trading strategies in Python, and I had in mind some powerful ML-based strategies, but had neither knowledge, nor abilities to code and test them. Now, although I still have no experience with professional Machine Learning with deep mathematics, I thought that I could use AI to write code for this (Sonnet 4.5), and suggest model parameters (Grok Thinking).

When looking at many market price charts, I was under the impression that there are some patterns that can be utilized and with a right set of trading strategy and position optimization to get automated at least a couple percents of return. It’s clear that this is not true - usually the market presents a distorted picture. Yet, tempted with the ability to check it myself in a quick prototype project, I proceeded with an experiment to verify if a hypothesis based on my earlier impressions could be true. I used 2 Jupyter notebooks: XGBoost model training and Strategy backtest.

First, I downloaded 5y data of 15m timeframe price points for top 30 crypto tokens into parquet files. Then created an algorithm to find all price points, after which there was a price drop bigger than 3% within the 10 next 15 min blocks, and extracted preceding 10 price points with technical analysis indicators as training data for XGBoost classifier - for identification of moments preceding price drops. 500k Drop signals were found, and I added another 1 million with random non-drop preceding samples, in total 1.5m training samples, with 20% from these used for testing.

I’ve also normalized drops, as 3% drop on Bitcoin has a different magnitude than the same drop on Dogecoin. So I’ve chose the drop threshold = -2 expressed with Z-score approach: drop_zscore=drop_pct/volatility. It means that it’s a drop with 2x typical volatility (based on std deviation).
Then feature engineering process based on indicators momentum, volatility, price differences. Data preparation, then XGBoost training with parameters from Grok’s recommendation:

*Recommended hyperparameters:**
- `max_depth`: 3-7 (prevents memorizing noise)
- `learning_rate`: 0.01-0.1 (smaller = better with more trees)
- `n_estimators`: 200-500 (with early stopping)
- `subsample` / `colsample_bytree`: 0.6-0.9 (prevents overfitting)
- `scale_pos_weight`: 3-10 (handles class imbalance)

The model performed very similarly on test predictions and train set:

============================================================
TRAIN SET PERFORMANCE
============================================================
ROC-AUC Score: 0.6899

Classification Report:
              precision    recall  f1-score   support

   No Signal       0.93      0.62      0.74   3149036
      Signal       0.19      0.66      0.29    426220

    accuracy                           0.62   3575256
   macro avg       0.56      0.64      0.52   3575256
weighted avg       0.84      0.62      0.69   3575256

Confusion Matrix:
[[1938267 1210769]
 [ 144995  281225]]

============================================================
TEST SET PERFORMANCE (Unseen Data)
============================================================
ROC-AUC Score: 0.6761

Classification Report:
...
Train AUC: 0.6899
Test AUC:  0.6761
Difference: 0.0138
✓ Good generalization - minimal overfitting

Basic returns turned out to be the most important feature for drop prediction. Yet there are too many false positives, which could hurt a portfolio.

So I thought, maybe a set of position parameters could save this signal and make it usable? So I proceed with the backtesting notebook. I loaded the model, created a backtesting trading simulation environment, and a set of trading position parameters: TP, SL, delay, cooldown. I tried a grid search optimization approach - to test 900 scenarios with parameter combinations and find algorithmically the best one. It took 3 hours on my local computer, and yet… All scenarios resulted in 100% loss! The process failed miserably.

It was nice working on this step-by-step with Cursor + Sonnet 4.5. I’ve read a lot about XGBoost when building this, so just telling the assistant what needs to be done and why, and seeing it creating neat notebooks that work out-of-the-box or after 1-2 debug-fix iterations, felt almost seamless. Working with Jupyter Notebooks in Cursor is not convenient - the notebook needs to be closed, reopened and rerunned manually after changes applied in Agent mode. So I ended up in Ask Mode and pasting the code blocks manually.