PROPELOO

BLOCKCHAIN / INFRASTRUCTURE

Blockchain infrastructure engineered for production.

PROPELOO engineers production-grade blockchain systems — from protocol architecture and smart contracts to nodes, wallets, APIs and the data infrastructure that makes it observable and maintainable. We build for teams that understand the difference between a proof of concept and a system that holds under real-world load.

The architecture decisions made in week two determine what the system can do in year two.

Most blockchain projects don't fail because the smart contract was buggy. They fail because the architecture around it — the data model, the off-chain computation strategy, the key management approach, the indexing layer — was designed for a demo, not for a product. The EVM doesn't care about your roadmap. The contract you deploy on mainnet is immutable. The wallet key management strategy you choose defines your security model permanently. These decisions need to be right before the first sprint begins, not revisited after the first major incident.

What sits underneath a production blockchain system.

A blockchain product is not a smart contract. It is a stack of engineering systems — each with its own failure modes, performance characteristics and security surface.

System Layers

  • Application / UX Layer: Web app, mobile app, dApp browser, wallet interface
  • API & Integration Layer: REST APIs, GraphQL, WebSocket, on-chain read/write
  • Smart Contract Layer: Business logic, state management, access control, upgrade patterns
  • Indexing & Data Layer: Event indexing, The Graph, custom indexers, off-chain storage
  • Network & Infrastructure: Nodes, RPC providers, validator infrastructure, monitoring

Core Technical Capabilities

  • Protocol Architecture

    Custom L1/L2 design, consensus selection, genesis configuration and network bootstrapping for purpose-built chains.

  • Smart Contract Systems

    Solidity and Rust contract development across EVM and Solana — including upgrade patterns, proxy architecture and formal verification preparation.

  • Wallet Infrastructure

    Custodial, non-custodial and MPC wallet systems with hardware wallet support, account abstraction (ERC-4337) and multi-sig governance.

  • Node & RPC Infrastructure

    Full node deployment, archive nodes, validator setup, private RPC endpoints and load-balanced node clusters.

  • Indexing & Data

    Custom blockchain indexers, The Graph subgraphs, event stream processing and queryable on-chain data for analytics and product features.

  • Security & Audit Readiness

    Internal security reviews, test coverage requirements, testnet staging, and preparation for third-party smart contract audits.

How we think about blockchain.

The hard part of blockchain isn't the smart contract. It's deciding what actually belongs on-chain, what doesn't, and why — before a single line of code is written.

  • Start with the problem, not the technology

    Blockchain is a tool with real costs — gas fees, immutability, operational complexity. We ask whether the problem actually requires decentralisation before recommending it. If a well-designed database solves it more reliably, we will say so.

    Axiom: RIGHT PROBLEM BEFORE RIGHT STACK

  • Design for production, not for demos

    A system that works in a pitch deck is not a system. We design the data model, the indexing layer, the key management approach and the failure modes in week one — because those decisions are nearly impossible to reverse once users are on mainnet.

    Axiom: PRODUCTION-GRADE FROM SPRINT ONE

  • Security is an architecture property

    Reentrancy, oracle manipulation, access control gaps and key management failures are architectural problems, not coding mistakes. They require architectural solutions. Security is designed in from the contract skeleton — not reviewed in after deployment.

    Axiom: THREAT MODEL BEFORE FIRST COMMIT

  • Build for the system you will need, not the one you have today

    A blockchain system needs to survive changing product requirements, team changes and ecosystem upgrades. Clean abstractions, documented upgrade paths and observable infrastructure mean the system can evolve without being rebuilt.

    Axiom: EVOLVABLE SYSTEMS OUTLAST CLEVER CODE

The decisions that define a blockchain system.

These choices compound. Getting them right early costs a week. Getting them wrong costs a product.

  • Which blockchain?

    Impact: Irreversible at scale. Migration requires a new contract and a migration event.

    • Ethereum mainnet — largest ecosystem, highest cost
    • Ethereum L2 (Arbitrum/Base/Optimism) — lower fees, Ethereum security
    • Solana — high throughput, different programming model
    • Polygon — EVM compatible, lower cost, more centralised
    • Custom chain — full control, build your own ecosystem
  • On-chain vs off-chain logic

    Impact: Determines gas cost structure, compute limits and trust assumptions for the entire system.

    • All logic on-chain — maximum trustlessness, high gas cost, limited compute
    • Hybrid — core settlement on-chain, computation off-chain with proof
    • Minimal on-chain — only settlement and ownership, all logic off-chain
  • Custodial vs non-custodial

    Impact: Defines the security model and regulatory posture permanently.

    • Custodial — simpler UX, company holds keys, regulatory exposure
    • Non-custodial — user holds keys, better security, higher UX friction
    • MPC — keys split across parties, balance between UX and security
  • Upgrade strategy

    Impact: Immutable contracts can never be patched. Upgradeable contracts require governance.

    • Immutable contracts — maximum trustlessness, no bug fixes
    • Transparent proxy — upgradeable, clear upgrade path, centralised control
    • UUPS proxy — gas efficient, upgrade logic in implementation
    • Diamond pattern — modular upgrade, complex but powerful
  • Data indexing

    Impact: Determines how quickly product features can be built on top of on-chain data.

    • The Graph subgraph — decentralised, community-maintained
    • Custom indexer — full control, own infrastructure
    • Third-party (Alchemy, Moralis) — fast setup, vendor dependency
  • L1 vs L2

    Impact: Fee structure and finality time affect product design decisions downstream.

    • L1 (Ethereum) — maximum security, highest cost
    • L2 Optimistic rollup — lower cost, 7-day withdrawal period
    • L2 ZK rollup — lower cost, fast finality, complex development
    • App-specific chain — custom fee model, own validator set

What blockchain infrastructure becomes.

  • DeFi Protocol

    Automated market makers, lending protocols, yield strategies and liquidity management systems built on audited smart contracts with multi-sig governance and oracle integration.

  • RWA Platform

    Real-world asset tokenization infrastructure connecting legal ownership structures to on-chain tokens, with compliance, KYC/AML and secondary market liquidity.

  • NFT Infrastructure

    Beyond the mint — royalty enforcement, dynamic metadata, staking, cross-chain bridges and marketplace infrastructure for serious NFT products.

  • DAO Governance

    On-chain voting systems, treasury management, proposal execution and multi-sig councils for decentralised organisations that need reliable governance.

  • Payment Infrastructure

    Stablecoin payment processing, cross-border settlement, B2B crypto payment rails and wallet-to-wallet payment systems for FinTech products.

  • Game Economy

    On-chain asset ownership, in-game currencies, player economy mechanics and NFT-based item systems for Web3 games that need a sustainable token model.

The stack depends on the chain.

We select technology based on the blockchain architecture, not preference. EVM projects use different tooling from Solana projects.

  • Smart Contracts

    Solidity for EVM ecosystems, Rust for Solana. Foundry for fast property-based testing. OpenZeppelin for audited base contracts. Slither for static analysis on every commit.

    Stack: Solidity, Rust (Solana), Hardhat, Foundry, OpenZeppelin, Slither

  • Blockchain Infrastructure

    Chain selection follows the product — throughput, cost, ecosystem and compliance posture. We deploy on whichever network the architecture requires, not whichever we prefer.

    Stack: Ethereum, Solana, Polygon, Arbitrum, Base, Cosmos SDK

  • Indexing & Data

    On-chain events are not queryable at product speed. We build indexing layers that turn on-chain activity into low-latency, queryable application data — the backbone of every analytics and product feature.

    Stack: The Graph, Custom Indexers, PostgreSQL, Redis, WebSocket, Event Streams

  • Wallet & Key Management

    Key management defines the security model permanently. ERC-4337 for account abstraction and gas sponsorship. MPC for institutional-grade threshold custody. Gnosis Safe for multi-sig governance.

    Stack: ERC-4337, MPC Wallets, Gnosis Safe, WalletConnect, Metamask SDK

  • Backend & APIs

    The off-chain layer is where the product lives. Node.js and Go for high-throughput API services. ethers.js and viem for reliable on-chain read/write. REST and GraphQL depending on query complexity.

    Stack: Node.js, Go, ethers.js, viem, REST, GraphQL

  • Infrastructure

    Reliable node access, observable deployments and reproducible infrastructure. Alchemy and Infura as RPC fallbacks. Datadog for chain-level monitoring and alerting on anomalous transaction patterns.

    Stack: AWS, Docker, Kubernetes, Alchemy, Infura, Datadog

Smart contract security is not a review. It is architecture.

The most expensive security failures in blockchain history were architectural decisions, not coding mistakes.

  • Reentrancy Protection

    Guard modifiers, check-effects-interactions pattern and reentrancy lock design across all state-changing functions.

  • Access Control

    Role-based access control, ownership patterns, multi-sig requirements and timelocks for privileged operations.

  • Oracle Security

    Price feed manipulation resistance, TWAP vs spot price decisions, oracle fallbacks and circuit breakers.

  • Key Management

    Hardware security modules, MPC threshold schemes, key rotation procedures and recovery mechanisms without single points of failure.

  • Upgrade Risk

    Proxy contract security, admin key protection, upgrade timelocks and emergency pause mechanisms for upgradeable systems.

  • Audit Preparation

    Comprehensive test coverage, natspec documentation, formal invariant definitions and staged testnet deployment before mainnet.

From architecture to mainnet.

  1. 01. Technical Discovery

    Chain selection, architecture design document, on-chain vs off-chain boundary definition, token model design and security assumptions.

  2. 02. Contract Architecture

    Contract system design, proxy strategy, access control model, upgrade path and integration interface specification.

  3. 03. Infrastructure Design

    Node infrastructure, indexer design, wallet system architecture, API specification and data model.

  4. 04. Engineering

    Contract development with parallel frontend/backend track. Weekly deliverables. Testnet deployment at each milestone.

  5. 05. Security & Testing

    Internal security review, 95%+ test coverage, gas optimisation, formal fuzzing and preparation for third-party audit.

  6. 06. Testnet & Audit

    Full testnet deployment, third-party audit coordination, bug fix cycle and security re-verification before mainnet.

  7. 07. Mainnet Launch

    Staged mainnet deployment, monitoring setup, incident response plan, on-call protocol and post-launch support.

Built. Shipped. Proven.

Engineering cases from PROPELOO blockchain projects — architecture decisions, trade-offs and outcomes from real production systems.

  • Institutional Liquidity & Settlement Protocol

    Challenge: Previous protocol choked during market volatility — gas spikes caused 14% transaction failures and desynchronised off-chain order state, eroding trader confidence.

    Architecture: Engineered a custom L2 rollup with off-chain sequencer and KZG state proofs. Deployed UUPS proxy contracts behind a 48h timelock multi-sig. Parallel indexer pipeline for sub-100ms query latency on order history.

    Outcome: Handled $320M in 24h peak volume with zero failed transactions. Average gas fee dropped 97.4% to $0.008 per trade.

  • Multi-Chain Wallet Infrastructure with Account Abstraction

    Challenge: Consumer wallet products on EVM chains required users to hold native ETH for gas, creating a 40% onboarding drop-off for non-crypto-native users.

    Architecture: Implemented ERC-4337 smart contract wallet with a bundler stack and paymaster sponsorship layer. Session keys for dApp interaction without repeated signing prompts. Full social recovery path without a custody dependency.

    Outcome: Gas sponsorship eliminated native token requirement at onboarding. Session key architecture reduced transaction confirmation steps from 5 to 1 for returning users.

  • On-Chain Data Indexing Pipeline for DeFi Analytics

    Challenge: DeFi protocol had no queryable history layer — product teams were rebuilding historical state from raw RPC calls on every analytics request, causing 8-second load times.

    Architecture: Built a dual-track indexing system: The Graph subgraph for decentralised community-facing queries, custom Go indexer with PostgreSQL + Redis for high-frequency internal analytics. Event stream processing with reorg-safe cursor management.

    Outcome: Analytics dashboard load time reduced from 8s to 210ms. Custom indexer handles 40,000 events/minute without backlog during chain congestion.

Frequently Asked Questions

Do you help us decide whether blockchain is actually the right choice for our product?

Yes — and we will tell you honestly if it isn't. Blockchain adds real engineering cost and operational complexity. The first thing we do is work through whether the problem actually requires decentralisation, immutability or trustless execution. If a conventional database solves the problem more reliably, we will say so. If blockchain is the right tool, we will explain exactly why and where it fits in the architecture.

Can you integrate blockchain into an existing product rather than building from scratch?

Absolutely. Many of the most valuable blockchain projects are integrations — adding on-chain settlement, tokenisation, or wallet support to a working product. We assess your existing architecture, define the integration boundary cleanly, and build the blockchain layer so it doesn't introduce instability into what already works.

Can we start with an MVP before committing to the full system?

Yes. We structure blockchain projects in validated phases. A typical MVP covers the core smart contract logic, a minimal indexer, a basic API layer and a testnet deployment — enough to validate the product mechanic before building the full infrastructure. This de-risks the investment and gives you something concrete to demonstrate to investors or early users.

How do you handle smart contract security? Can you guarantee the contract is safe?

We do not use the word guarantee — it is not honest in this context. What we do is engineer security into the architecture from day one: threat modelling before the first contract is written, role-based access control from the skeleton, invariant testing with Foundry, static analysis on every commit, and a third-party audit before any mainnet deployment that holds user funds. Security is a process, not a checkbox.

Which blockchain networks do you support?

EVM networks including Ethereum mainnet, Arbitrum, Base, Optimism and Polygon. Solana for high-throughput applications. Cosmos SDK for custom appchain architectures. The right network depends on your throughput needs, user geography, cost tolerance and compliance posture — we run a structured chain selection process in the first engagement week with no network affiliations that bias the result.

Can you work alongside our existing engineering team?

Yes. We work in three modes: fully embedded as your blockchain engineering team, as a specialist layer alongside your existing developers, or as an architecture and review partner that advises your team. We adapt to what you already have rather than requiring a clean slate.

What happens after the system launches?

We set up monitoring, alerting and an incident response plan before mainnet. Post-launch we offer a structured support and maintenance engagement covering smart contract monitoring, infrastructure health, dependency upgrades and feature development. You are never handed a deployed system with no-one watching it.

How do you scope a project without a full specification?

We run a structured discovery sprint — typically 3–5 days — that produces a technical brief, architecture diagram, and milestone plan. This becomes the contract baseline, so both sides agree on scope before a single line of production code is written. Change after that point is handled through a transparent change-order process.

Who owns the code and intellectual property?

You do, unconditionally. Every deliverable — contracts, infrastructure code, design files, documentation — transfers to you at the milestone it is invoiced. We retain no licence, no attribution requirement, and no ongoing dependency on PROPELOO tooling.