In this post, we are going to look at the design approaches one should follow to run a trading strategy across multiple accounts.
Design Approaches
One Strategy Instance Per Account
In this approach, you build a trading strategy that is designed to run on a single account. So in order to run it across multiple accounts, you need to run multiple instances of this strategy (one instance per account).
One Strategy for All Accounts
In this approach, you build your trading strategy in such a way that it can handle multiple accounts.
How to choose a correct design approach?
There are pros and cons of each approach. And the one you should choose really depends on your specific scenario.
One Strategy Instance Per Account
Pros
- Helps reduce complexity (as the code becomes simple)
- High scalability (You can easily run it across multiple accounts)
- For high level programming languages like C# or Java
- Not for charting software like AmiBroker or MetaTrader etc.
Cons
- Novice programmers find this approach difficult
- Does not scale well on charting software
- The major reason for this is that the charting software are hardware intensive. Understandably so as any graphics processing tasks require a high CPU.
- Users should use stuff like scanners which process faster
- Starting multiple strategy instances on a lot of accounts can be tiring job
- Another limitation primarily for charting software as they are not really a trading system
- An ideal trading system just has a single start button (most of these are custom made)
One Strategy for All Accounts
Pros
- Novice programmers find it easy to code (say if there is a feature like group account which internally maps to multiple trading accounts)
- It is easy, but only for very simple trading strategies that mostly just require placing an order
- Quite easy to manage on charting software as users do not have to start multiple charts (reduces the burden of setting each chart’s strategy parameters)
- Hardware requirement is small (which is helpful in case of charting software)
Cons
- Difficulty increases when it comes to debugging and investigating issues
- Not at all easy when your strategy is complex and involves (order modification/cancellation, fund management etc.)
Conclusion
Based on the explanation given above, you need to evaluate your use case and make the correct choice.
If we are to recommend, we will always say go with (One strategy instance per account) design approach.
