Infrastructure for Building and Managing
Your Factors

A library of hundreds is constant work.

A serious factor library is not a handful of signals. It is dozens, often hundreds, and it keeps growing as researchers test new ideas. Every one has to be built correctly, then kept alive: refreshed on a schedule so the numbers stay current, versioned when a methodology changes so last year's backtest still reproduces, kept consistent so a factor means the same thing on the quant desk and in a portfolio manager's attribution report, auditable so any number traces back to its definition, and delivered into the tools people actually work in.

That is a large, ongoing, specialized effort. As the library grows, the code grows with it and gets harder to keep clean. Refresh pipelines, versioning, access, and consistency all have to hold together, every day, for years. And the work never stops, because the next idea always means another factor to build and fold into the library.

MDO is the infrastructure that carries all of it, running inside your own Snowflake account. It makes building a factor easy, whether it is the first one or the three hundredth, and it keeps the whole library managed automatically: the refresh, the versioning, the access, the consistency, the audit trail. The factors stay proprietary to your firm and never leave your environment. MDO is the software that manages them, not a service you hand them to. Custom Formulas are how a firm puts it to work.

Managing a factor is a lifecycle, not a step.

Each stage below is real work to get right. MDO manages all of them, so a Custom Formula moves through the whole lifecycle without anyone rebuilding plumbing.

A Custom Formula is code you can read.

Not a number handed down from a vendor. Not a black box an AI spat out. Here is an example, a price acceleration factor. The entire definition:

def FL_TEC_PRICEACC(universe, params=None):
    """Price acceleration: current 3M total return minus the prior, non-overlapping 3M total return."""
    import mdosnow as mdo
    from snowflake.snowpark.functions import expr
    dims = ['day', 'security']
    universe = mdo.as_universe(universe[dims], dimensions=dims)

    # Total-return index now (PX0) and 3 and 6 months back (PX_T3, PX_T6)
    mdo.PlugData(universe, items={'PX0': 'DS_TOTRET'}, toCurrency='USD', recent=-10)
    mdo.PlugData(universe, items={'PX': 'DS_TOTRET'}, shift=[-3, -6],
                 periodType='month', toCurrency='USD', recent=-10)

    # recent quarter (PX0/PX_T3) minus prior quarter (PX_T3/PX_T6)
    universe.with_column('FL_TEC_PRICEACC',
        expr('(PX0 / NULLIFZERO(PX_T3) - PX_T3 / NULLIFZERO(PX_T6)) * 100.0'))
    return mdo.as_universe(universe[dims + ['FL_TEC_PRICEACC']], dimensions=dims)

Anyone on the team can open that, see precisely how the factor is computed, and change it. The methodology is not a guess. It is the source. That is what makes a library trustworthy enough to run a process on.

Calling a formula is one line. The same line for everyone.

Whether the caller is a quant, a PM, or an internal dashboard, the call is identical:

mdo.CFData(universe, name='FL_TEC_PRICEACC', formulaGroup='MDO_DEMO_FACTORS_V2')

That returns the factor for every name in the universe, alongside any other formula in the library called the same way. A slice of global large caps on a recent month-end:

Factor values as of the 2026-06-30 month-end.

Whatever your process runs on, every factor sits in the same library, named, categorized, refreshed on the same cadence, and callable through the same one line. Common categories:

A screen, a risk report, a PM dashboard, and a backtest all pull from the same definitions. Every consumer sees the same number because they are all calling the same formula. And that number does not drift: MDO runs the saved factor, not an AI, so the same factor on the same date returns the same result every time, whether in a backtest today or an audit six months from now.

Different firms, same shape.

The pattern shows up again and again across the teams MDO works with.