.jpg)
An anonymous Solana trading team uses RPC Fast to detect token launches, feed its trading logic, and submit response transactions through concurrent delivery routes. Its challenge is keeping the path from an incoming event to a trading decision short while maintaining enough execution data and recorded evidence to verify what happened afterward.
The system runs on customer-owned bare metal in the same Frankfurt data center as its RPC Fast endpoint. Aperture TxStream supplies early transaction data, Yellowstone supplies execution observations, and Solana RPC supports checks and reconciliation outside the immediate trading path.
About the client: Token launches and bonding-curve trading
The team operates an automated strategy focused on sniping new token launches and trading along bonding curves. RPC Fast is its main provider for streaming, RPC access, and transaction delivery.
The customer owns the trading application, local state, strategy logic, and recording infrastructure. Its server runs Linux on an AMD Ryzen 9 9900X with 12 cores, 24 threads, and 96 GB RAM, hosted by CherryServers in Frankfurt.
That hardware runs the trading system; it is not presented as a customer-operated Solana RPC node. The deployment combines the team’s own application infrastructure with RPC Fast’s managed services.
The challenge: Act early and verify afterward
The team’s priorities extend beyond receiving a fast feed:
- Low and predictable latency;
- Complete delivery within the subscribed scope;
- Fast recovery after reconnects;
- Clear status information during issues;
- Research data that reflects what the trading system observed.
A single transaction feed does not serve every purpose equally. Early transaction visibility helps the strategy react; execution observations establish what ran; finalized data supports reconciliation.
The architecture assigns those responsibilities to separate inputs. It also keeps synchronous RPC confirmation outside the CREATE-to-BUY path: the app does not require an RPC confirmation response before progressing through that latency-sensitive sequence.
Production architecture: Distinct roles for each feed
The customer describes the core execution path as:
.jpg)
The data from the RPC Fast feeds, with the lowest possible latency, gave the client’s app plenty of time to decide and deliver their txs. Here are the other components, explained:
As developers of RPC Fast, we enjoy seeing such purposeful use of our products, powering the app with efficient trading logic.
So, the whole architecture will look like this:
.jpg)
The role of TxStream and its connections with the app
The client’s side app consumes TxStream in non-batch mode, receiving one transaction per gRPC message. Thus, it offers access to a decoded transaction feed reconstructed from shreds, before normal validator replay metadata is available.
This leaves a separate responsibility inside the trading application: interpreting transaction instructions and extracting the information its strategy needs. Receiving decoded transaction structures does not remove the need for application-specific interpretation.
Our anonymous customer does not use TxStream’s optional real-time simulation. Shredstream is available in its standalone comparison and probe tooling, but it is not an input to the current trading runtime.
The case therefore shows a specific use of Aperture: early transaction delivery feeding local strategy logic.
Yellowstone and RPC support execution checks
Yellowstone supplies the live execution observations. Its finalized stream supports subsequent checks against final on-chain state.
RPC serves startup checks, background refresh, and reconciliation through methods including getTransaction and getSignatureStatuses. The client does not use WebSocket methods, high-cost account queries, or getProgramAccountsPaginated in this setup.
The operational distinction is timing: verification remains part of the system, but synchronous RPC confirmation is not a prerequisite on the CREATE-to-BUY path. A fast decision and a reconciled trading record are separate responsibilities.
Benefits of app co-location with its data source
The customer places its trading server in the same data center as the RPC Fast endpoint to keep the network-to-decision path short and stable.
That placement addresses one part of the latency budget. Transaction interpretation, strategy evaluation, signing, delivery, and on-chain execution remain separate stages.
For this deployment, the benefit is architectural: the team controls its application hardware and places it close to our service supplying its live inputs.
.jpg)
Are there any best delivery providers for snipping project?
The team uses RPC Fast Beam sender across its configured delivery routes – Astralane, bloXroute, Nozomi, other paths, and Jito.
We use concurrent delivery rather than depending on a single provider. I would not name one provider as consistently best.
The customer uses Beam’s fastest mode and does not use its provider score feed. Both HTTP and persistent QUIC are integrated; the team has no controlled comparison establishing that one consistently performs better.
Beam supports HTTP and QUIC submission, with provider-specific routing. Here, concurrent delivery is the customer’s application-level choice, rather than evidence that Beam automatically selects a winning route.
Data quality and structure for the bot
The customer records its streaming data independently. Each recording retains:
- Original protobuf messages;
- Receive timestamps;
- Source and session identifiers;
- Sequence information.
Messages are stored in compressed, time-partitioned segments with checksums and separate derived indexes. Older segments move to network storage.
This preserves more than transaction contents. Receive timestamps and sequence information help the team examine what information was available when the bot made a decision.
The resulting research dataset remains bounded by subscription filters and observed coverage. It is not a complete blockchain or wallet history. Historical research also uses other archival providers, so those lookups should not be attributed entirely to RPC Fast.
.jpg)
Why recorded arrival information matters
A final on-chain record answers what happened. A timestamped stream recording helps answer what the app knew when it acted.
For example, when reviewing a launch decision, the team has the original received messages and their timing to compare with the bot’s actual behavior. That supports investigation of differences between a historical strategy replay and live decisions.
Using the same source feeds improves comparability; it does not reproduce every condition of live execution. The distinction matters when interpreting backtest results: observed market inputs and achieved transaction execution are separate parts of the outcome.
Reliability: Monitor delivery quality, not only connectivity
The system runs 24/7 and continuously compares its streams with each other and with independent data. The team tracks delivery gaps, reconnects, and ordering.
This makes data quality an explicit operational concern. An open connection is insufficient evidence that the application received every expected event in the expected sequence.
The customer reports satisfaction with support and no negative experience with RPC or streaming services. Those statements reflect the interview; no observation period or measured uptime percentage was supplied.
Consolidating streaming, RPC, and part of transaction delivery with RPC Fast simplifies the team’s operations and monitoring. Independent comparisons remain part of its verification process.
Results: The customer’s perspective
The team reports the following satisfaction with the latency numbers:
Our median latency from trigger to finalized transaction is usually about 40-50ms.
The other benefits are a consistent result of carefully crafted architecture:
- Early transaction inputs for token-launch trading.
- A short, co-located path between the endpoint and trading application.
- Concurrent submission across configured routes.
- Production-feed recordings for research and comparison with actual decisions.
- One primary provider for streaming, RPC, and transaction-delivery services.
When your workload needs a different infrastructure profile
This case study pairs customer-owned application hardware with RPC Fast’s managed endpoints. As traffic grows, the next step depends on what becomes constrained: service limits, node resources, or deployment requirements.
RPC Fast offers two options for these workloads: an Enterprise plan for custom limits, features, service combinations, and fallback arrangements; and dedicated nodes for isolated resources and node-level customization.
These options also work together—for example, dedicated infrastructure with an Enterprise fallback service.
Dedicated-node configurations support custom plugins and data streams, with infrastructure sized around the workload. An Enterprise does not, by itself, ensure dedicated hardware; specify isolation explicitly when required.
If the existing endpoints meet your latency targets but request or subscription limits constrain growth, discuss Enterprise. If you need isolated capacity, custom Geyser plugins, or control over node configuration, evaluate dedicated nodes.
Build the trading path around distinct responsibilities
This project is a good example of a team that owns its strategy engine and prioritizes early transaction visibility, local processing, and multiple delivery routes. Its design separates acting on an event from observing execution, reconciling final state, and researching the decision afterward.
RPC Fast supplies the managed streaming, RPC, and delivery services. The customer retains responsibility for strategy logic, application state, recording, and cross-source verification.

.jpg)
.jpg)