Portfolio Optimizer with Selectable Risk Models: A Comparison
Two optimizers can take the same list of tickers, the same price history, and the same weight limits — and still hand you two different portfolios. The difference is usually not the optimizer. It is the risk model underneath it.
If you are evaluating a portfolio optimizer with selectable risk models, you are not shopping for a solver. Least-squares minimizers are a solved problem. You are deciding how much control you want over the statistical lens that every allocation has to pass through, and how much of that control you are willing to build and maintain yourself. This article compares the options on the market, sets out the criteria that actually matter, and shows where RSJ Portfolio fits.
The Buying Decision: Why Risk Model Choice Matters
A fixed risk model is a fixed opinion about what “risk” means. Every portfolio it produces is filtered through one estimator — usually plain return variance and a full covariance matrix. That is a reasonable default, and it is also a silent constraint: it assumes correlations are stable, that upside and downside volatility are equally undesirable, and that estimation error affects every candidate the same way.
Selectable risk models remove that assumption. You choose the estimator before capital is allocated, so you can match the measurement to:
- The asset class — equity index constituents rarely behave like a basket of small caps or a multi-currency list.
- The market regime — a covariance matrix estimated on a calm decade behaves differently on the way into a drawdown.
- The mandate — an investor who cares about drawdown depth wants a different estimator than one who cares about day-to-day standard deviation.
This is why selectable risk models are a primary differentiator in the portfolio optimizer market. Method lists are easy to publish and hard to compare, but the number of estimators you can switch between is a concrete, checkable number — and it determines how many distinct portfolios you can build from one candidate list.
RSJ Portfolio takes this position explicitly: it selects candidates that correlate weakly, or whose downside correlates weakly, and lets you pick the objective, the risk estimator, and the weight constraints independently. This article covers the landscape, the criteria, and where that approach is the right buy — and where it is not.
The Landscape: What Portfolio Optimizers Exist Today
Broadly, three groups.
1. Spreadsheet and script-based tooling
A spreadsheet with COVARIANCE.P and Solver, or a Python notebook with a covariance function and an optimizer call. Maximum flexibility, zero procurement, and complete transparency into every line. You also own the data ingestion, the cleaning, the alignment, the cache, and the tests. Rebuilding it after a dependency upgrade is your weekend.
2. Open-source optimization libraries
Libraries that expose portfolio objectives and constraint handling, plus separate packages for data access. Good defaults, readable source, and a community. The catch is that estimator choice is usually expressed as a different function call or an argument on a matrix you already had to assemble cleanly. Data hygiene sits outside the library, so it becomes your problem again.
3. Dedicated desktop applications
Packaged software with a UI, a data layer, and a documented parameter set. Less flexible, far less maintenance. RSJ Portfolio belongs here: it is a Windows desktop application that builds a statistically optimized stock portfolio from historic end-of-day prices, using modern portfolio theory allocation, with the objective, the risk estimator, and the weight constraints all selectable.
This comparison is aimed at individual investors and quants making a practical decision, not at institutional platforms with mandate-driven procurement.
Selection Criteria for a Portfolio Optimizer with Selectable Risk Models
Five criteria separate a tool you will keep using from one you abandon after the first backtest.
Ease of use. How much statistics and programming do you need to run an optimization and read the result? A tool that requires you to construct a clean returns matrix has already failed this criterion for most users.
Automation and data handling. Does the tool ingest end-of-day prices, clean them, and cache them locally — or does it expect a tidy input? Every hour spent reconciling split-adjusted prices is an hour not spent on allocation decisions.
Security and licensing. Local execution versus cloud dependency matters if your holdings are not public. Licensing matters too: know whether what you buy is a single-user license, and what it covers.
Price and integration. How the license is priced and how the tool fits your existing research workflow — exports, files, interoperability with the notebooks you already use.
Methodological depth. The number and type of risk models, return models, allocation methods, and weight constraints. This is where selectable risk models live, and it is the criterion this article is about.
Side-by-Side Comparison: Risk Models and Allocation Methods
| Tool category | Selectable risk models | Allocation methods | Data handling | Licensing model |
|---|---|---|---|---|
| Spreadsheet / script-based | As many as you implement and test yourself | Whatever you code | You supply a cleaned, aligned matrix; ingestion and caching are yours | Your own time plus data subscriptions |
| Open-source libraries | Typically one estimator per call path; switching means writing code | Library-dependent objectives | You supply aligned prices; cleaning and caching are outside the library | Open source; maintenance cost is time |
| Dedicated desktop application (RSJ Portfolio) | Eight risk models, switchable | Minimum volatility, maximum Sharpe ratio, minimum semi variance, hierarchical risk parity, conditional value at risk | Multiple data providers, price cleaning pipeline, local cache, conversion path for multi-currency portfolios | Single-user license |
Beyond the allocation methods, RSJ Portfolio also exposes selectable return models and weight constraints. The practical consequence is the whole point of this comparison: the same candidate list can be optimized under different risk definitions, and the resulting allocations can be compared before committing capital.
That comparison is only meaningful if you understand what each method optimizes. Hierarchical risk parity in particular is widely misunderstood — it is covered in depth in What Is Hierarchical Risk Parity? A Plain-Language Explainer rather than re-explained here. The same applies to the correlation reasoning behind weak-correlation selection, which is walked through in How to Reduce Portfolio Volatility Using Correlation Analysis.
How RSJ Portfolio Implements Selectable Risk Models in Practice
The workflow is managed end to end. There is no protocol layer, no scripting, and no raw optimizer call to wire up.
- Install the Windows application from the downloads page. The installer is published under a versioned filename with its SHA-512 alongside it.
- Activate the single-user license.
- Configure the data provider, the local currency, the date range, and the cleaning settings — the parameters worth setting before the first run are documented in the getting-started guide.
- Build the candidate list by searching symbols in the selection step.
- Run the recommendation and select the objective, the risk estimator, and the weight constraints you want.
- Read and export the resulting allocation.
Before the first run, verifying the installer is a two-minute habit:
# Compare the output with the SHA-512 shown next to the versioned filename
# on the downloads page before you install.
sha512sum RSJPortfolio-Setup-<version>.exe
Because the parameter set is large, keep your own record next to each export. This is not a config file the product reads — it is a note that makes runs reproducible:
# Your own run record, kept next to the exported allocation.
as_of: 2026-10-22
local_currency: EUR
date_range: [2016-01-01, 2026-09-30]
data_provider: "<configured in the app>"
cleaning: "<settings used>"
objective: minimum_semi_variance
risk_model: "<one of the eight>"
constraints:
note: "weight limits as configured"
Switching risk models happens in the interface, not in code — which is exactly the contrast with the hard way:
# The hard way: a sketch of what "just switch the estimator" costs in a script.
import numpy as np, pandas as pd
from scipy.optimize import minimize
prices = pd.read_csv("prices.csv", index_col=0, parse_dates=True)
returns = prices.pct_change().dropna()
def min_volatility(returns, shrink=False):
cov = returns.cov()
if shrink: # new estimator -> new code path, new tests
cov = 0.9 * cov + 0.1 * np.diag(np.diag(cov))
n = cov.shape[0]
res = minimize(
lambda w: w @ cov @ w,
x0=np.ones(n) / n,
bounds=[(0.0, 0.2)] * n,
constraints={"type": "eq", "fun": lambda w: w.sum() - 1},
)
return res.x
# Every additional objective, risk model or constraint is another branch to
# maintain, document and re-validate after each dependency upgrade.
That is one estimator and one objective. Multiply it by eight risk models, five allocation methods, and a set of weight constraints, and the maintenance burden is the real price of the scripted route.
Two parts of the managed path are worth calling out because they decide whether the output is usable at all. First, data: RSJ Portfolio runs a price cleaning pipeline and keeps a local cache, and it supports a conversion path for portfolios quoted in several currencies. The details of building a comparable cleanup yourself are in Automating End-of-Day Price Cleanup for Portfolio Backtests. Second, validation: before any allocation reaches a broker, you should check input quality, the chosen risk model, and how stable the weights are across nearby parameter settings — the full routine is in How to Validate Portfolio Optimizer Output Before You Trade.
Start with the getting-started recommendations, then change one parameter at a time — see RSJ Portfolio for the workflow and the current license terms.
Verdict: Who Should Pick Which Approach
- Choose a managed desktop workflow (RSJ Portfolio) if you want selectable risk models, selectable objectives and weight constraints, local execution, and a data layer you do not maintain. Install once, configure once, then compare allocations across risk definitions in the UI.
- Stay with scripting or open-source libraries if you need full control over every intermediate object, are comfortable owning the data pipeline, and can absorb ongoing maintenance and validation as a real cost rather than a footnote.
- A single fixed risk model may be enough if your universe is homogeneous and your mandate never changes. Be aware of what you are giving up: when the regime shifts, a tool that cannot change its estimator cannot change its answer.
A short recommendation matrix:
| Your situation | Practical fit |
|---|---|
| You want to compare allocations across risk definitions without writing code | RSJ Portfolio |
| You need reproducibility across many parameter combinations | RSJ Portfolio, with a run record per export |
| You need custom estimators that no packaged tool exposes | Script-based or open-source |
| You need cloud-scale batch runs across thousands of universes | Neither of the above as described here |
| You only ever run one method on one universe | A simpler tool is sufficient |
FAQ
What does ‘selectable risk models’ mean in a portfolio optimizer?
It means the tool lets you choose how risk is estimated before the optimizer allocates capital. Instead of forcing a single covariance or variance estimator, the user can switch between different risk models, which changes how the optimizer perceives the risk of each candidate and therefore changes the resulting allocation. RSJ Portfolio offers eight risk models alongside selectable objectives and weight constraints.
Can a Windows desktop portfolio optimizer handle multiple data providers and currencies?
Yes. RSJ Portfolio supports multiple data providers, a local cache, and a conversion path for portfolios quoted in several currencies. The configuration step lets you set the data provider, local currency, date range, and cleaning settings before running the optimizer.
What is the difference between an allocation method and a risk model?
The allocation method is the objective the optimizer solves for, such as minimum volatility, maximum Sharpe ratio, minimum semi variance, hierarchical risk parity, or conditional value at risk. The risk model is the estimator used to measure risk inside that objective. RSJ Portfolio lets you select both independently, so the same candidate list can be optimized under different combinations.
How do I know the optimizer’s output is reliable before I trade?
Validate the output by checking the input data quality, the chosen risk model, and the stability of the allocation across nearby parameter settings. RSJ Portfolio includes a price cleaning pipeline and local cache to support this. For a detailed validation workflow, see How to Validate Portfolio Optimizer Output Before You Trade.
Conclusion
The optimizer is not the decision. The risk model is. A tool that lets you switch estimators — and pairs that with cleaning, caching, and a documented parameter set — lets you build several defensible portfolios from one candidate list and choose between them deliberately, instead of accepting the single answer a fixed estimator gives you.
RSJ Portfolio is the managed path to that: a Windows desktop application with eight risk models, five allocation methods, selectable return models and weight constraints, and a local workflow that starts with configuration and ends with an export you can validate. Check the pricing and license page for current terms and the single-user license, then download the installer with its published SHA-512 — and run your first candidate list under two different risk models before you commit a single currency unit.
Related posts
- How to Validate Portfolio Optimizer Output Before You Trade
- How to Reduce Portfolio Volatility Using Correlation Analysis
- Automating End-of-Day Price Cleanup for Portfolio Backtests