Developing a cryptocurrency recommendation system: where the signal breaks
A rule found on historical data works only in the market regime where it was discovered.
While market volatility is low and liquidity is distributed predictably, the weights confidently separate assets; when the regime changes — a sharp move or a shift of volume between venues — the same logic starts producing false signals, and the more often the more confident it looked on the previous segment.
The gap manifests in the first days after a trend break, when the model has not yet accumulated the new context.
The second source of errors is data latency. Price, volume, and network data arrive asynchronously and at different frequencies, and some sources return a snapshot with a delay of one or two intervals.
If the assembly and calculation of the score are not time-aligned, the recommendation is formed on an outdated picture: the analyst sees a recommendation that the market no longer confirms.
The quality of historical data makes the picture worse.
Gaps, different time zones among sources, retroactive candle revisions, and survivorship bias, from which delisted instruments have dropped out, make the dataset “convenient”: the model has never seen how the market behaves when half of the assets disappear. On such a dataset, any configuration looks more reliable than it will be in production.
For the analytics pipeline, this results in lost trust in recommendations: decisions are made, but feedback on them is not collected, and it is no longer possible to assess exactly where the system went wrong.
We break down how this is addressed — from resilience to regime shifts and control of data freshness to checking the quality of history before building anything on it.
What changes after implementation: signal accuracy and response speed
Before implementation, scores were calculated in batches: the market had already moved, and the output caught up with a delay.
Multi-factor scoring moves recalculation to an event-driven model — the weight of each factor changes with price, volume, and liquidity, rather than on a schedule.
Accuracy and false positive rate
Scoring maintains several independent factors and mutes the signal if they diverge from one another. The confirmation threshold is configured separately by asset class: the false positive rate is reduced by about half without losing the number of accepted signals.
Market depth data is pulled from several sources, including CoinGecko, so output does not degrade if one of them fails.
Recalculation speed during market movement
Recalculation is triggered by an event, not a timer: the score updates within seconds after a volatility spike.
A recommendation that becomes outdated during calculation is marked as stale and does not reach the consumer — an entire class of failures goes away, where a decision was made based on yesterday's market snapshot.
Resilience under peak load
The recalculation queue is separated from output delivery: a spike in requests does not slow down revaluation, and revaluation does not block the interface. At peaks, response time remains steady, and throughput grows by adding workers without rewriting the scoring logic.
Comparison of asset valuation modes: streaming, batch, hybrid
The calculation mode determines how quickly a recommendation reflects market changes and how much infrastructure it consumes.
The choice is not binary: stream processing, batch recalculation, and hybrid mode address different tasks, and they often coexist on the same dashboard — new assets are calculated continuously, while historical profiles are recalculated at night.
The selection criterion is acceptable output latency and load profile. If the signal is needed at the moment of entering a position, daily recalculation is not suitable: by evening, factor weights diverge from the market.
If recommendations are updated for a long-term portfolio, continuous processing adds load without a gain in accuracy.
| Option | When suitable | Limitations |
|---|---|---|
| Batch recalculation | Long-term portfolios, updates once a day or less often, heavy models | Output latency — hours; during sharp market moves, factor weights become outdated |
| Stream processing | Signals at the moment of trade, reaction to volatility within seconds | Constant load at peaks, need spare capacity and control of event queues |
| Hybrid mode | Mixed scenarios: frequent adjustments on top of infrequent full recalculation | Harder to maintain — two calculation branches and rules for reconciling them |
In practice, hybrid mode is chosen more often: heavy recalculations run in batches, while lightweight adjustments run as a stream. This smooths peak load and keeps output latency within limits set by the product itself, not by the infrastructure.
Implementation stages: from data discovery to handover to operations
Before calculating scores, we analyze the data: exchange trades and order book, on-chain metrics, news and social signals — each source has its own update frequency and latency.
A system built on top of a dirty stream reproduces its distortions, so the first stage is inventory and quality measurement, not model training.
- Data source discovery. We compile a list of streams, and for each we record frequency, latency, history depth, and delivery method. Separately, we calculate the share of gaps, duplicates, and anomalous values — they show which sources will need cleaning and which will need replacing.
- Calculation scheme. We determine which factors make up the final asset score: price and volume dynamics, liquidity, volatility, on-chain activity, news sentiment. For each, we define the window, normalization method, and outlier cutoff rules so that different scales become comparable.
- Weight tuning. We calibrate factor contributions on historical data and cap them so that one noisy signal does not pull the recommendation toward itself. We move weights into configuration rather than code — they can be edited without rebuilding and releasing.
- Validation on historical slices. We run the scheme over sequential periods, training only on the past — this eliminates lookahead. We look not only at returns but also at ranking stability when the period shifts and when an individual factor is disabled.
- Acceptance and handover to operations. We deploy the calculation, set up monitoring of input data quality and score drift, and document the procedure for reviewing weights and the rollback order to the previous version of the scheme.
After handover, the client's team can see why an asset received exactly that score: each factor and its contribution remain observable rather than dissolving into a “black box.” This makes the system maintainable by the client's own engineers.
What we hand over: configurations, schemas, regulations, documentation
The project closes not with a demonstration but with a set of artifacts by which the recommendation calculation system can be operated and developed without us.
Everything listed is handed over to your repository with modification rights — not a report, but working units: configuration, schemas, regulations, documentation.
- Calculation configuration files: factor weights, signal trigger thresholds, averaging windows, rules for excluding low-liquidity instruments — with comments on where each value came from and beyond which boundary the score quality drops.
- Data flow schemas: from quote and on-chain event sources to the recommendation dashboard, with control points, latencies at each segment, and the place where each metric is calculated.
- Access policies: roles for reading and for modifying weights, separation of rights to historical data and to production pipeline configuration, audit log of all edits with author and timestamp.
- Feature update procedure: recalculation frequency, procedure for adding a new factor, mandatory validation on historical data before rollout, and the procedure for rolling back configuration to the previous one.
- Calculation documentation: aggregation formulas for the multi-factor score, assumptions for missing data, system behavior on source delay or loss.
- Monitoring: a set of control metrics for output quality, degradation thresholds, on-call engineer actions, and alert templates.
- Deployment and recovery guide: building the environment from scratch, storage migrations, the checkpoint from which the system recovers after a failure.
From practice: rebuilding asset valuation for an exchange analytics pipeline
We examine a case from an exchange analytics pipeline: a single signal needed to be replaced with multi-factor asset scoring so that recommendations would not break during volatile periods.
The work proceeded in iterations — first we captured baseline metrics, then assembled factors and rebuilt the calculation itself.
What did not work
Recommendations were built on a single feature — price dynamics over the last few hours. In a calm market, the share of erroneous recommendations stayed around 34%, while during sharp moves the output effectively flipped: an asset entered the buy list already at the reversal.
A full recalculation of the set took more than 40 minutes, so by the time of publication some signals had already become outdated, and calculation stability during peak hours was maintained only through manual intervention by analysts.
What we changed and what we achieved
We assembled a multi-factor score: price patterns, order book depth, pair liquidity, volatility, and correlations within the basket.
Each factor received a weight, and the final score received a confidence threshold: below it, the recommendation is not published and goes into observation mode.
We moved the calculation to the columnar storage ClickHouse and made recalculation incremental — only for changed instruments.
Error analysis was built into the cycle itself: a rejected recommendation is tagged with a reason — stale signal, thin liquidity, factor conflict — and weights are reviewed based on accumulated statistics.
The metric outcome: the share of erroneous recommendations fell from 34% to 11%, full recalculation dropped from 40 to 3 minutes, and the share of recommendations canceled within an hour after publication fell from 27% to 6%.
There are no more calculation failures under load: the queue degrades gradually, prioritizing major pairs.
How streaming asset valuation differs from batch valuation
The difference is when the score is calculated. Batch valuation recalculates the entire asset list on a schedule, while streaming updates the score on every event — as soon as a trade arrives or the order book changes. The data is the same; the moment of calculation and the pipeline requirements differ.
In terms of latency and load, these are two different profiles. A streaming pipeline keeps the feature window in memory and calculates increments: reaction is in seconds, but the load is constant and is planned with headroom for market peaks.
Batch produces short bursts: during idle time resources are free, but the decision arrives with a delay of the recalculation window.
Debugging differs more strongly. Batch calculation is deterministic: one data window yields one result, and a failure is reproduced by re-running.
Streaming depends on the order and timing of event arrival, so deduplication, idempotent writing, and input stream persistence are needed — otherwise the incident cannot be investigated.
The choice of mode rests on the required reaction time and how quickly the features themselves change.
With multi-factor scoring involving dozens of factors, batch recalculation remains the primary method, while streaming covers features with second-level reaction: volume spikes and sharp price movements.
If the pipeline is already deployed, there is no need to rewrite it: the batch layer remains the source of truth, while streaming is layered on top as an accelerator — it reads the same data stream from a source such as CoinGecko and writes to the same score store.
The mode is switched by configuration, so we first roll out the hybrid and compare the discrepancy on historical windows.
Technical concerns: data, latency, model resilience
Recommendations rely on a stream of quotes, market depth, and trade history — data arrives unevenly, with varying latency and gaps.
Below are answers to concerns that usually arise before the start: source delays, liquidity gaps, model overfitting, history volume, and integration with your platform.
What happens if a data source is delayed or interrupted?
Quotes come from several independent providers and are cross-checked. If one lags or emits an outlier, the system takes the confirmed snapshot and marks the score as incomplete, and in the event of a liquidity gap, it stops output instead of calculating from an outdated price.
How do you protect against model overfitting?
Training and validation are separated in time, with a gap left between windows — the model cannot peek at future data. We calculate quality separately for each period, so a drop on a new segment is visible immediately, not after launch.
How many historical slices are needed and how are they stored?
Periods of both growth and decline are needed, including low liquidity. We store slices as snapshots with a fixed step: feature recalculation does not break if a provider retroactively corrects history.
What about data quality?
We filter out gaps, duplicates, and trade splitting at ingestion using explicit rules. The share of rejected records and discrepancies between sources are sent to monitoring — they show whether the data is degrading.
How will this integrate into the current platform?
We connect via API and event exchange, without migrating databases or changing storage. We deliver recommendations as ready scores or as a set of factors — we agree on the format, and a return to the previous logic remains available.
Let's discuss the task: what to send for an estimate and work plan
An estimate for a crypto asset recommendation system is calculated not by code volume but by the number of sources that need to be brought into a single multi-factor score.
Below is what to send so that we come back with an estimate and work plan, rather than clarifying questions a week later.
- Integration points. List the systems from which data is taken: exchange feeds, wallets, internal databases, analytics exports. Note whether there is streaming ingestion or only scheduled exports — the recalculation architecture depends on this.
- Data access. A test environment and read-only access to storages, sandboxes of exchange sources. Production keys are not needed at the first stage — we work on copies and anonymized slices.
- Set of scoring factors. What is already taken into account: returns over periods, volatility, liquidity, on-chain activity, holder concentration. Which weights you consider workable and where they diverge from practice.
- Current metrics. How a recommendation is currently formed, how long recalculation takes, what share of signals reaches the user, and where discrepancies with analysts' manual decisions are recorded.
- Target scenarios. What the system should output: list ranking, portfolio risk assessment, entry or exit signal. Response format — screen, export, notification.
- Constraints and rules. Compliance requirements, disclaimers, regional restrictions, decision history for reviewing disputed cases.
If some data is missing, describe it in words; at the start, it will be replaced by a manual export or a historical slice. Send what you have: based on this set, we will come back with a labor estimate, stage composition, and work plan.