Multi-factor · Rotation · Grid
Technical implementation · Not investment advice
Strategy Programming Service
You provide the trading idea and logic; we turn your approach into code that can run automatically. We can also run strategy backtests to verify how that logic would have executed on historical data. Available for mainstream quant trading platforms and markets in China and overseas. Custom front-end pages for visual strategy management are also available. We only do technical implementation and replay — we do not interpret markets, and we do not provide investment judgments or buy/sell advice.
- Stocks · QMT
- Futures · vnpy / Tianqin
- Backtest · Historical replay
Markets and platforms we support
From requirement discussions through go-live delivery, we cover mainstream quant trading platforms and markets in China and overseas. On the market and trading software you specify, we turn your finalized objective rules into runnable code.
Stocks
Covers common strategy types such as multi-factor, rotation, and grid: we turn your given objective rules into backtestable, auto-executable code, and can integrate mainstream backtest frameworks and trading environments.
- Multi-factor / index enhancement / sector & style rotation
- Grid, DCA, conditional filters, and rebalance rule coding
- Automate stocks / ETFs / convertibles per your rules
- Vectorized and event-driven backtests with historical replay
Futures
Covers CTA, arbitrage, machine-learning and similar strategy types: we turn your given signals and constraints into backtestable, auto-order code for mainstream futures backtest and execution frameworks.
- CTA trend / mean-reversion / breakout rule implementation
- Cross-instrument arb, spread, and roll condition coding
- ML signal integration and inference-pipeline engineering
- Backtest-engine wiring, external params, historical replay
What we actually deliver
Tooling code that auto-executes your rules, plus optional strategy backtests that replay historical execution results and statistics. Not an investment plan or stock-picking logic; backtests are not return promises and do not indicate future results.
Stock rule automation
Encode your filters, scoring, rebalance, and constraints (e.g. limit-up/down filters, order slicing) into auto-execution code. We do not make stock-selection judgments for you.
Futures rule automation
Encode your signals, portfolio constraints, spread conditions, and account-level risk controls into auto-execution code. We do not recommend contracts.
Strategy backtesting
Replay orders and positions on historical data per your objective rules, and deliver verifiable backtest results with technical notes — to check that rule encoding matches historical execution. No market commentary, no return promises, and no indication of future results.
Engineering delivery
Runnable source, externalized parameters, inspectable logs; we help verify that “the code faithfully executes your rules”, and fix program errors during the warranty period.
Service scope
We state what we can and cannot do, so expectations align before we start.
What we can do
- Turn trading logic from your notes or docs into runnable programs for the environment you choose
- Code and modularize strategy types such as multi-factor, rotation, grid, CTA, and arbitrage
- Run historical backtests of your given rules with agreed fees and slippage assumptions
- Engineer execution paths: orders, position state, retries, and logging
- Connect your existing market/factor APIs so signals feed execution and constraint checks
- Deliver runnable source code with deployment notes and integration support
What we don't do
- Interpret markets, recommend buy/sell names, or promise returns
- Originate trading ideas for you (you provide the logic; we land the tech)
- Help circumvent exchange or broker compliance requirements
- Crack, steal paid data, or access third-party systems without authorization
- Hold accounts, trade funds on your behalf, or offer custodial management
Common execution environments
We write for the quant software or frameworks you already use, reducing rewrite cost when switching environments.
- Stocks · XtQuant
QMT / XtQuant
Implement your objective rules for pre-market filters, intraday execution, conditionals, and risk parameters as runnable code.
- Stocks · MyQuant
MyQuant
Turn your given factor / rotation / rebalance rules into one codebase that can switch across backtest, paper, and live.
- Stocks · Hundsun
Ptrade
On the broker side, code your confirmed rules into order-capable programs to reduce execution drift from environment differences.
- Futures · VeighNa
vnpy
Modular implementation of your signals and risk rules, easy for you to change parameters and extend later.
- Futures · TqSdk
Tianqin
Implement your given rules for market-data subscription, backtest, and live switching in one codebase.
- Futures · GeeWoo
Jizhi
Following Jizhi terminal conventions, write your rules as strategy scripts and complete integration backtests.
- Futures · TradeBlazer
TradeBlazer
Migrate your existing chart formulas / conditionals into backtestable executable code, with unified parameters and logs for self-check.
- General · Pine Script
TradingView
Write indicator / alert scripts per your given conditions; when needed, bridge to stock or futures execution ends (still only executing your rules).
How we work together
We lock your objective rules and technical boundaries first, then code and backtest. We assess whether rules can be implemented and historically replayed for verification — not whether a trade “should” be made.
- 01
Lock objective rules
Confirm market, platform, universe, timeframe, and your objective entry/exit/risk conditions; assess technical feasibility, timeline, and quote.
- 02
Write executable code
Implement on the target platform from finalized rules; keep key parameters external and structure clean so you can change thresholds yourself. We do not change rule meaning.
- 03
Strategy backtest / paper verification
Under period, fee, and slippage assumptions you accept, replay rule execution on historical data and check that logic behavior matches the encoding. For verification only — not to recommend trades or promise returns.
- 04
Go-live and defect support
Help connect accounts, gateways, or APIs; use paper or controlled trials to verify the execution path works. Q&A during delivery; fix program defects in warranty. We do not direct specific trades.
How we charge
Quoted by complexity and effort, not lines of code. Figures below are common starting points; final pricing follows discussion.
Basic implementation
Clear rules and simple conditions: an auto-execution program for one symbol or a small set of objective conditions.
¥2,000from
- One execution environment: stocks or futures
- Full runnable source delivered to your rules
- Basic backtest or paper run to verify rule implementation
- Integration support within 30 days
- Free program-error fixes within 60 days
Strategy backtest
Standalone strategy backtest: replay execution of your given rules on historical data, with verifiable results and technical notes (historical execution check — not a return promise).
¥1,500from
- Build the backtest from your objective rules
- Agree data window and fee/slippage assumptions
- Reproducible fills and statistics
- Rule-implementation check notes (not investment commentary)
- Q&A on result definitions within 30 days
Advanced implementation
Multi-condition logic, multi-symbol constraints, portfolio-level risk controls, or cross-platform signal bridging into an execution end — still implementing only your given rules.
¥5,000from
- Assess rule implementability before quoting
- Parameterized framework and risk module (to your thresholds)
- Optional full historical backtest with reproducible result notes
- Integration support within 60 days
- Free program-error fixes within 90 days
Institutional custom
Multi-account setups, complex scheduling, ongoing maintenance, or custom development under NDA.
Custom quote
- Dedicated timeline and staged acceptance
- Delivery docs and code notes
- Deployment integration and continued support
- Warranty scope can be agreed separately
- NDA available
Cases
Technical references for strategy types built from client-given ideas — multi-factor, rotation, CTA, machine learning, and more. Not strategy recommendations or investment advice.
Multi-factor selection & rebalance
Encode client-given factor blends, score ranking, and position constraints into backtestable, auto-rebalancing execution code.
Sector / style rotation
Implement scheduled rebalances and constraint checks from client-given rotation signals, position caps, and turnover cadence.
ETF grid & DCA
Turn client-given grid spacing, add/reduce conditions, and DCA cadence into backtestable executable code.
Multi-symbol CTA trend
Automate client-given trend tests, sizing formulas, and drawdown/exposure caps across symbols, with historical backtests.
Machine-learning signal execution
Wire client-given model signals or inference outputs into feature alignment, order placement, and risk-constraint engineering.
Calendar / cross-instrument arb
Monitor and trade client-given spread thresholds, leg ratios, and margin constraints, with reproducible backtests.
Start a technical discussion
WeChat or email both work. Please send the instruments and trading logic; voice chat is also fine.
- Please write executable objective conditions (e.g. indicator thresholds, position caps, limit-up/down handling). Avoid vague wording such as “use discretion” or “trade by feel”.
- Once rules are finalized, we generally avoid major changes; if rules change mid-project, cost and timeline are re-discussed.
- We only do technical implementation and integration: no investment analysis, forecasts, stock/contract picks, return promises, or investment advice.
- Strategy backtests only replay the execution process and statistics of your given rules on historical data, to verify that coding matches the logic. Not investment advice and not an implication of future returns.