Loading...
Supporting developers, startups, and full-fledged companies building on Stellar and Soroban
© 2025 Stellar Development Foundation
Subscribe to the Newsletter
By Flow
Offers programmable data pipelines to help Stellar/Soroban developers automate real-time workflows by unifying classic ledger and smart contract event streaming.
Obsrvr Flow provides modular, event-driven data pipelines purpose-built for the Stellar ecosystem, enabling developers to automate real-time workflows. It ingests full classic and Soroban data via Galexie or Stellar RPC, overcoming Horizon's limitations, particularly for complex Soroban event access which is currently difficult for many builders. Developers define Directed Acyclic Graphs (DAGs) using our CLI or SDK to chain together stateless, reusable processors (microservices) that apply custom logic – like filtering, enrichment (e.g., with AI), or state calculations. Processed data streams reliably to databases, APIs, alerting systems, or even triggers Soroban contract calls. While core tooling like the CLI and processor templates will be available, developers will primarily deploy and operate these pipelines via a managed Obsrvr Flow platform, simplifying setup and maintenance.
Key features leveraging Stellar/Soroban:
Unified Ingestion: Direct access to raw classic ledger data and Soroban events/effects via Galexie or native Stellar RPC.
Programmable Processors: Build custom logic using reusable, Protobuf-enforced microservices reacting to Stellar operations or Soroban events. Chain, replay, and test processors independently.
Multi-Sink Routing: Stream processed data reliably to diverse destinations (Postgres, webhooks, Discord, triggering Soroban RPC calls).
Developer Tooling: CLI and Control Plane SDK (interfacing with the managed platform) for declarative pipeline management, schema registry, real-time observability, and retry queues.
Public Data Source: We will provide a publicly accessible, Galexie-powered data lake of Stellar ledger data (Mainnet/Testnet) via Google Cloud Storage (Requester Pays) to accelerate ecosystem development.
This unified infrastructure is vital for wallet/dApp builders (who currently often build custom indexers), analytics platforms, and custody solutions needing timely, granular, and programmable access to both classic and Soroban activity.
Yes
$120.0K
We will measure success through a combination of adoption, functionality, and ecosystem impact:
Adoption: 20+ distinct developer teams actively using the Flow CLI, SDK or processors in development or production environments by the end of Q1 2026.
Deployment: 10+ unique, custom pipelines deployed by external teams on the Flow platform, demonstrating real-world application.
Efficiency: Demonstrate measurable reduction (e.g., target >50% reduction in boilerplate code/development time) in building specific real-time automation tasks compared to traditional Horizon polling methods, showcased via at least 2 public case studies.
Value Proposition Validation: At least 3 distinct production use cases publicly highlighted (e.g., via blog posts, demos) demonstrating the value of unified classic and Soroban data streaming through Flow.
Ecosystem Impact: Obsrvr Flow becomes a recognized and recommended infrastructure component for real-time data processing within the Stellar ecosystem, with evidence of replacing custom-built internal indexers for several key teams.
Our go-to-market strategy focuses on developer adoption within the Stellar ecosystem:
Target Key Builders: Prioritize outreach to Stellar developers, particularly wallet/dApp builders, infrastructure providers, custody solutions, and analytics teams who face challenges with existing data access methods (especially for Soroban).
Leverage Public Data Source: Promote the publicly accessible Galexie data lake on GCS as a low-friction entry point for developers to experiment with raw ledger data and prototype Flow pipelines.
Developer Resources & Community: Provide comprehensive documentation, SDKs, CLI tooling, and reusable processor templates. Engage actively via Stellar developer Discord, run workshops, and create onboarding guides (potentially aligning with Stellar LaunchKit).
Ecosystem Partnerships: Collaborate closely with wallet teams, custody providers, analytics platforms, and SDF ecosystem partners for integration feedback, early adoption, and joint case studies.
Content & Use Cases: Publish blog posts, tutorials, and demos showcasing specific, high-value use cases enabled by Flow (e.g., real-time compliance monitoring, unified classic/Soroban analytics, automated Soroban interactions).
Validated core need for programmable, real-time data access through interviews with multiple Stellar infrastructure builders and application teams.
Unified solution that has both classic and Soroban data is a missing component from most indexing solutions in the ecosystem
Direct feedback from SDF teams that highlighted the need for streaming data, reinforcing the need for a unified streaming solution like Flow. (They confirmed having to build their own indexer due to these limitations).
[Deliverable 1] Core Pipeline Engine & Control Plane API
Brief description: Develop the fundamental backend service that manages pipeline state, orchestrates data flow between processors, handles errors/retries, and exposes a gRPC API for configuration and monitoring.
How to measure completion: Internal tests confirm engine can process data streams, manage basic DAGs, and handle restarts; gRPC API endpoints for defining pipelines, registering schemas, and querying status are functional and documented internally.
Estimated date of completion: June 2025
Budget: $15,000
[Deliverable 2] Flow CLI Tool
Brief description: Create the command-line interface for developers to interact with the Flow control plane. This includes commands to define, deploy, update, and inspect pipelines.
How to measure completion: CLI allows users to successfully connect to the control plane API, submit a pipeline definition (YAML), list deployed pipelines, and retrieve basic status/logs. CLI packaged for basic distribution (e.g., docker container).
Estimated date of completion: June 2025
Budget: $10,000
[Deliverable 3] Galexie Ingestion & Public Data Source (Classic)
Brief description: Implement the ingestion module to read classic Stellar ledger data (Ledgers, Transactions, Operations, Meta) from Galexie-captured files stored in Google Cloud Storage. Establish and populate the public GCS buckets (Requester Pays) for Mainnet, Testnet and Futurenet data (Following possible sep for Ledger Metadata Storage - https://github.com/stellar/stellar-protocol/discussions/1678).
How to measure completion: Ingestion module successfully parses Galexie data formats and pushes structured events (e.g., Protobuf) into the pipeline engine's input queue; Public GCS buckets are created, configured for Requester Pays, and contain recent Mainnet/Testnet/Futurenet ledger data accessible via standard GCS tools. Documentation on accessing the public data is available.
Estimated date of completion: July 2025
Budget: $5,000
[Deliverable 4] Initial Processors & Basic Pipeline Demo
Brief description: Develop and test three initial stateless processors (e.g., Account - filtering ops by account, LatestLedger - latest ledger info, TokenTransferProcessor - extracting unified asset events). Deploy a simple pipeline using these processors and create an internal demo endpoint (e.g., serving basic /latestledger data).
How to measure completion: Three processors are implemented, unit-tested, and integrated with the engine; A pipeline successfully chains these processors using the CLI; Internal endpoint returns expected data derived from the pipeline processing live or replayed classic ledger data.
Estimated date of completion: July 2025
Budget: $15,000
[Deliverable 5] Testnet Deployment & Stability Validation
Brief description: Deploy the MVP version of the Obsrvr Flow infrastructure configured to ingest and process data from the Stellar Testnet. Conduct internal testing to validate stability, DAG execution logic, error handling, and consumer routing under simulated load.
How to measure completion: A stable instance of Flow is running and processing Stellar Testnet data continuously for at least 1 week; Internal test reports confirm successful execution of multi-step DAGs, correct error logging/recovery for simulated processor failures, and reliable delivery of processed data to test sinks. Public access endpoint available for community testing.
Estimated date of completion: August 2025
Budget: $5000
[Deliverable 6] Open Source Resources (Schemas, Templates) & Public Registry
Brief description: Publish the core Protobuf schemas used for data interchange within Flow to a public repository. Release templates or examples for building custom processors (e.g., in Go/Rust) and basic pipeline configuration examples. Create basic registry for community developed processors and Protobuf schema definitions
How to measure completion: Public GitHub repository created containing Protobuf schema definitions (.proto files) with clear documentation; Public registry available with all processors and Protobuf schemas created so far; Example processor code (at least one language) demonstrating subscription and processing logic is available; Sample pipeline configuration files (YAML) are published.
Estimated date of completion: September 2025
Budget: $20000
[Deliverable 7] Developer Portal & Feedback Channel
Brief description: Launch a basic developer portal (e.g., using static site generator) with initial documentation covering architecture overview, CLI usage, public data access, and how to build a simple processor. Use Stellar Developer discord project channel as a dedicated public channel for community feedback and support. Establish other support channel options outside of discord.
How to measure completion: Developer portal website is live with core documentation sections published; Public Discord channel (or similar forum) is created, announced, and monitored for feedback and questions.
Estimated date of completion: September 2025
Budget: $5,000
[Deliverable 8] Mainnet Production Deployment & Monitoring
Brief description: Deploy the Obsrvr Flow infrastructure in a production-ready configuration to handle Stellar Mainnet data streams. Implement necessary monitoring, alerting, and scaling mechanisms for reliable operation.
How to measure completion: Production instance of Flow successfully ingesting and processing live Stellar Mainnet data; Monitoring dashboards (e.g., Grafana) are configured showing key system metrics (throughput, latency, error rates); Basic alerting rules are in place for critical failures. Infrastructure meets defined availability targets (e.g., 99.9% uptime) during the initial launch period.
Estimated date of completion: October 2025
Budget: $20,000
[Deliverable 9] Soroban Event Ingestion & Processing
Brief description: Enhance the ingestion module and pipeline engine to parse and process key Soroban events (e.g., contract deployments, function invocations, diagnostic events, standard contract events). Update relevant Protobuf schemas. Develop at least one processor specifically handling Soroban data.
How to measure completion: Flow can ingest Soroban events streamed via RPC or parsed from Galexie data; Protobuf schemas are updated to include Soroban event structures; At least one processor demonstrating filtering or aggregation of Soroban events (e.g., tracking specific contract interactions) is functional. Successful processing demonstrated on Mainnet/Testnet Soroban data.
Estimated date of completion: November 2025
Budget: $5,000
[Deliverable 10] Multi-Sink Consumer Implementation & Examples
Brief description: Implement and test support for multiple downstream consumers (sinks). Provide working examples for routing processed pipeline data to at least three distinct types of sinks (e.g., a Postgres database, a webhook endpoint, a Text/Email alert, triggering a Soroban contract call via RPC).
How to measure completion: Consumer framework supports routing data to different sink types based on pipeline configuration; Example code and configurations demonstrating data delivery to Postgres, a webhook receiver, and Text/Email (or similar alert mechanism) are documented and functional; Example demonstrating triggering a Stellar RPC call based on pipeline output is functional.
Estimated date of completion: November 2025
Budget: $15,000
[Deliverable 11] Latest Ledger Endpoint (/latestledger) & AI Example
Brief description: Deploy a public API endpoint /latestledger powered entirely by an Obsrvr Flow pipeline that provides up to date ledger information on the latest ledgers available on each network. Develop and showcase one example processor using basic AI/ML for data enrichment (e.g., transaction classification).
How to measure completion: Public /latestledger endpoint is live.; An example processor demonstrating AI/ML enrichment is implemented and included in documentation/examples.
Estimated date of completion: November 2025
Budget: $5,000
Tillman Mosley III
Proven Expertise in Building and Managing Critical Infrastructure
Dermatopathology Platform: Managed the infrastructure for a digital platform enabling remote diagnoses.
Managed Cellular Solution: Designed and maintained secure infrastructure to block unauthorized cell phone use in prisons.
DevOps Focus: Specializes in automation and platform management across multiple industries.
Tillman Mosley
No other submissions.