Platform
From a model in your head to a simulation you can examine
Signest covers the whole path — data, modelling, factor libraries, stock pools, position rules and simulated accounts — as one system running on your own infrastructure. This page describes what each part does, and, at the end, what the platform deliberately leaves to you.
1. Architecture
Four engines share one definition of the truth, so what you designed is what gets computed.
| Engine | Responsibility |
|---|---|
| Strategy engine TacticsEngine | Assembles factors, stock pools, index linkage and account-level settings into strategy sets. Entry-side and exit-side logic are separate definitions. Many strategy sets can run in parallel. |
| Rule engine RuleEngine | The global cockpit: position coefficients, behaviour switches, weighting and priority, frequency limits, order-book rules, per-account constraints. Parameters can be updated while strategies are running. |
| Execution engine TradeEngine | Inside a simulated account, converts rule output into simulated orders matched against live market data — placement, batching, cancellation and sizing informed by the visible order book. |
| Task engine TaskEngine | Scheduled work: stock-pool refreshes intraday and post-close, factor recalculation, feed parsing and storage, quality checks and backfills, report generation — each with its own execution record. |
All four rest on a substantial body of mathematical and statistical work; that is what removes the technical barrier for the user and the efficiency ceiling for the system.
2. Modelling and research
Multi-dimensional analysis
Analysis dimensions are discovered from the connected data sources and grouped automatically, so building a view does not start with schema archaeology. Every dimension of a factor model can be filtered, which is how an exploratory question becomes a reusable definition.
Inheritance and derivation
A factor model is an abstraction that can be inherited and derived without limit. Refine a parent model and its descendants can be re-validated in simulation and promoted deliberately, rather than copied by hand into five places.
No-code definition
Models are built by selecting indicators and setting conditions. The metadata layer is open and extensible: define once, use in several contexts. Advanced users can drop to SQL where it is genuinely faster — nobody has to.
Research output
Analysis results can be turned into reports and charts, saved, and distributed on a schedule — to a shared stock pool or to colleagues — so the definition used in research is the same one used downstream.
3. Factor libraries
A factor is any variable you decide matters. The library is where those definitions accumulate instead of being re-typed.
- Anything can be a factor — fundamentals, any bar period, high-frequency data, indicators, or a rule combining several of them.
- Index and stock libraries work together — a condition can require both the index-level and the stock-level library to be satisfied.
- Entry and exit sets stay separate — which keeps exits explicit instead of implied.
- External libraries can be merged — factor libraries you maintain outside Signest layer on top of the platform's own, so existing research is not stranded.
- Reusable across strategies — one library serves many strategy sets, and a change propagates instead of diverging.
4. Stock pools
Logic frozen as a model
Selection logic becomes a model rather than a one-off query, so the same rule produces today's pool and tomorrow's.
Refreshed on a schedule
The task engine updates pools intraday or after the close at the frequency you set, across the pre-open, morning, midday, afternoon and post-close windows.
Weights and priorities
Per-name weight, priority and batching belong to the pool itself, so everything downstream inherits them without manual re-entry.
5. Position and risk rules
Position size is the largest single risk factor, so it is controlled globally rather than strategy by strategy.
| Control | What it does |
|---|---|
| Position coefficient | Target exposure derived from index state and your own rules; scaling in and out follows the rule output automatically. |
| Behaviour switches | Entry only, exit only, both, or halted — per account or per strategy, switchable while running. |
| Weight and priority | Exposure is distributed across strategies and names by weight and priority, with batching where a position should be built gradually. |
| Frequency and quantity limits | Caps on counts and frequencies, so an automated run cannot spiral — the same discipline you would want in any unattended system. |
| Index linkage | Strategy parameters respond to the index factor library, so a change in market state adjusts exposure rules without manual intervention. |
| Order-book-aware sizing | Lot sizes are set with reference to the visible five- or ten-level book, so the simulation reflects what the book would plausibly have absorbed. |
6. The simulation environment
Simulated accounts
Create an account with the starting capital you choose and run it on live market data with the same strategy sets, factor libraries and computation model you designed. Nothing is placed anywhere: everything happens inside the simulator, on your machine.
Forward testing, not just backtesting
Because the simulation runs on the live feed rather than a stored file, a model meets conditions it has never seen — which is the only honest way to find out whether it was fitted to the past.
Unattended runs
A simulated strategy can run for weeks without supervision, with high availability and its own execution records, so evaluation covers a real range of market states rather than one good week.
Read it like a lab notebook
Every simulated fill, rule trigger and pool refresh leaves a record. When a result surprises you, the question "why did it do that?" has an answer you can look up.
Simulation is a way of examining a model, not a promise about it. Results obtained in a simulated account do not indicate future performance, and no amount of simulation removes market risk.
7. Technology and deployment
| Item | Detail |
|---|---|
| Implementation | Written in C++ on a microservice architecture, with its own in-memory data management and computation held entirely in memory. Execution efficiency is tens of times that of platforms built in Java or Python. |
| Footprint | The system is tiny and carries no dependency packages — unzip and run. Memory per strategy process stays under 10 MB. |
| Throughput | Design targets: 100,000 simulated orders per second, 100+ strategies on a single machine, microsecond-level execution, high availability for long unattended runs. |
| Databases | Oracle, SQL Server, MySQL and PostgreSQL, plug and play. The market-data parsing layer is developed against PostgreSQL 14 or later. |
| Current release | Windows 10 / 11 and Windows Server, x86_64: Signest_Server_Release_v2.0.0.exe and Signest_Client_Release_v3.0.0.exe. |
| Operating model | Everything runs on your own machines. We do not host your data, your models or your results. |
Performance figures are design targets from our own test benches. Actual results depend on your hardware, database and strategy complexity.
8. What the platform leaves to you
The strategy is yours
Signest ships model templates and tooling, not a strategy. No proprietary factor set, no stock recommendations, no trading signals, no "copy this" service. What a model does is what your rules say it should do.
The judgement is yours
We are not a licensed corporation and not a broker. We give no investment advice, manage no accounts, never receive or hold client funds, and make no claim about returns. What you do with a validated model — and what you risk — is entirely your decision.