Hi Polkadot community,
I would like to introduce FlowFarm, a project we are building to bring perpetual derivatives markets, USDC liquidity, and on-chain market infrastructure to the Polkadot ecosystem.
- Telegram: @flowfarmio
- Contact: contact@flowfarm.io
This post is intended as an ecosystem and technical feedback thread. It is not a token sale announcement, investment solicitation, public fundraising campaign, or request for forum members to promote the project.
FlowFarm is being developed as a Polkadot-native perpetuals parachain, inspired by the GMX model but implemented with native Polkadot SDK / FRAME runtime logic instead of Solidity contracts. The goal is to build an app-specific chain for transparent perpetual markets, pooled liquidity, keeper-executed orders, oracle-priced execution, and risk controls designed directly at the runtime level.
We are still early, and the current implementation is intentionally local/devnet focused. We are sharing this now because we want feedback from the Polkadot community, especially around architecture, ecosystem fit, integrations, liquidity design, and what would make a derivatives protocol genuinely useful inside Polkadot.
Why FlowFarm?
Polkadot has strong infrastructure for app-specific execution, shared security, interoperability, and long-term modularity. We believe derivatives and liquidity infrastructure can benefit from that model.
Many perpetuals protocols are deployed as smart contracts on general-purpose chains. That can work, but it often means core trading logic, risk controls, execution flows, and operational assumptions are layered on top of a runtime that was not designed specifically for that market structure.
FlowFarm takes a different approach:
- Build the trading venue as an app-specific parachain.
- Put markets, liquidity, orders, fees, liquidation logic, ADL, referrals, and protocol accounting into native runtime modules.
- Use deterministic runtime-level checks for solvency, leverage, utilization, and execution constraints.
- Keep the MVP narrow enough to reason about and audit before any public launch.
What FlowFarm is building
The current FlowFarm architecture includes:
- Perpetual markets with USDC collateral.
- Pooled USDC liquidity backing trader positions.
- Two-phase order flow where users create requests and keepers execute them using fresh oracle reports.
- Market increase and decrease orders.
- Limit and stop-market order flows.
- TWAP order support.
- Take-profit / stop-loss sidecar order support.
- Runtime liquidation logic.
- Auto-deleveraging mechanics for extreme risk conditions.
- Protocol fee, LP fee, referral, and price-impact accounting.
- Rust indexer and GraphQL-compatible API for frontend and keeper workflows.
- Keeper service for local execution loops.
- Frontend and marketing site for early user-facing communication.
Why Polkadot?
We think Polkadot is a strong fit for this kind of product because:
- App-specific chains can encode domain logic directly into the runtime.
- Runtime upgrades allow protocol evolution without redeploying fragmented contract systems.
- XCM can eventually support asset movement and integrations across parachains.
- Polkadot’s shared security model can support specialized applications without every app needing to bootstrap its own validator set.
- The ecosystem has room for more DeFi primitives that are native to Polkadot rather than bridged from other ecosystems.
The long-term goal is not just to launch another perps UI, but to build derivatives infrastructure that feels native to Polkadot’s architecture.
Current status
FlowFarm is currently in active development.
The current implementation should be treated as a local/devnet-stage system. Before any public deployment, we expect the project to need further work across:
- Production oracle design.
- External audit.
- Public testnet process.
- Final tokenomics.
- Governance and admin-control hardening.
- Production keeper operations.
- XCM / live asset integration.
- Monitoring and incident runbooks.
- Liquidity and market launch planning.
We are being deliberate here because perpetuals protocols are high-risk systems. Solvency, oracle correctness, liquidation behavior, and accounting safety matter more than rushing to launch.
What we would like feedback on
We would appreciate feedback from Polkadot builders, governance participants, DeFi users, validators, and ecosystem teams on the following:
1. What would make a perpetuals protocol valuable specifically for the Polkadot ecosystem?
2. Which assets or markets would make the most sense after a `DOT_USD` `BTC_USD` `ETH_USD`?
3. What are the strongest expectations from the community before a DeFi protocol asks for trust?
4. Would a runtime-native perps chain be more compelling than deploying smart contracts on an existing execution environment?
5. What would you want to see before using, integrating with, or supporting FlowFarm?
Near-term roadmap
Our near-term focus is:
- Continue hardening the runtime logic.
- Improve test coverage around trading, liquidity, liquidations, ADL, and fee accounting.
- Prepare public-facing documentation.
- Improve frontend flows.
- Publish more technical architecture details.
- Engage with ecosystem teams around stablecoin, oracle, and liquidity integrations.
- Prepare for a testnet path once the core safety gates are stronger.
Closing
FlowFarm is being built with the belief that Polkadot can support serious, app-specific DeFi infrastructure.
We would appreciate any technical feedback, ecosystem suggestions, integration ideas, or criticism from the community.
Social links are listed at the top of this post.