20Build against Buy

In November 2018 Virtu Financial agreed to buy Investment Technology Group, an agency broker, and in March 2019 it completed the purchase for about $1.0 billion in cash, $30.30 a share. Its stated reasons were to offer its clients a complete suite of agency services, “including transparent trading and workflow technology, analytics, and liquidity solutions”, running on Virtu’s own infrastructure, and about $123 million a year of expense savings within two years. A firm can write the software it needs, license it, or buy the company that wrote it together with its clients and its people. The last is the most expensive way to acquire software, and sometimes the only way to acquire a business built on it.

20.1 What firms build and what they buy

The usual rule is that a firm builds what makes it different and buys what makes it the same. A market maker’s quoting engine and risk checks are its edge, and it builds them (Books 11 and 13); its payroll, email and much of its post-trade processing are the same as everyone’s, and it buys them. The hard cases sit in between: order and execution management systems (Book 10), the security master (Book 7), the machine-learning platform (Book 12). They are needed by everyone, they touch the firm’s edge at the edges, and they are expensive both ways.

20.2 Total cost of ownership

The chapter’s example is an order-management system over seven years (Listing 20.1). Building it takes seven engineers for two years, then three a year to maintain it, plus $0.2 million a year of infrastructure. Buying it costs a $1.2 million licence rising 5% a year, a $1.0 million integration fee and two engineers in the first year, and one engineer of support every year. An engineer-year costs $350 000 loaded, and the firm adds 30% for the work the engineer would otherwise have done: $455 000. The discount rate is 8%. All figures are illustrative; Boehm’s Software Engineering Economics (1981) is the classic reference on estimating the development and maintenance terms.

def build_costs(b, horizon):
    ey = b.wage * (1 + b.kappa)
    return [b.dev_engineers * ey if t < b.dev_years else b.maint_engineers * ey + b.infra for t in range(horizon)]


def buy_costs(y, horizon):
    ey = y.wage * (1 + y.kappa)
    out = []
    for t in range(horizon):
        c = y.licence * (1 + y.escalator) ** t + y.support_engineers * ey
        if t == 0:
            c += y.integration_fee + y.integration_engineers * ey
        out.append(c)
    return out


def npc(costs, r):
    """Net present cost, each year's cost paid at the year end."""
    return sum(c / (1 + r) ** (t + 1) for t, c in enumerate(costs))

Building costs $3.19 million in each of the first two years and $1.57 million a year after (Figure 20.1); buying costs $3.57 million in the first year and then $1.72 million, rising with the licence to $2.06 million in year seven. Undiscounted, the build costs $14.2 million over seven years and the purchase $14.9 million. Discounting favours buying, since the build’s costs come first: the net present costs are $11.04 million and $11.30 million (Figure 20.2).

Over seven years the break-even loaded engineer-year is $363 000: at the firm’s $350 000 building wins, by $0.26 million of present cost, and a firm paying more for its engineers should buy. From the seventh year on, building stays cheaper at every longer horizon. The margin is thin, which is the common case: the decision rarely turns on the base case and often on what could go wrong.

20.3 Lock-in and the option to switch

Lock-in lets a vendor raise its price at renewal by up to the switching cost without losing the client. The chapter models the risk on a binomial tree: at each renewal the licence may rise 30% with probability 0.3; switching to another vendor costs $2.0 million and resets the price. With the price risk, the expected present cost of buying rises from $11.30 million to $13.46 million, $2.42 million more than building; the option to switch vendors, exercised when it pays, brings it back to $12.90 million. The option is worth $0.56 million, and its value is the reason to keep switching costs low (Listing 20.2). The best policy is simple: switch once the price has risen twice, by 69%, except in the last year, when a single year of savings no longer pays for the move (Figure 20.3).

def _tree(y, horizon, r, u, p, switch_cost, allow):
    base = buy_costs(y, horizon)
    lic = [y.licence * (1 + y.escalator) ** t for t in range(horizon)]
    disc = [1 / (1 + r) ** (t + 1) for t in range(horizon)]
    memo, policy = {}, set()

    def v(t, k):                        # k: number of price rises in the current multiplier
        if t == horizon:
            return 0.0
        if (t, k) in memo:
            return memo[(t, k)]
        stay = (base[t] + lic[t] * (u ** k - 1)) * disc[t] + p * v(t + 1, k + 1) + (1 - p) * v(t + 1, k)
        best = stay
        if allow and k > 0:
            sw = (switch_cost + base[t]) * disc[t] + p * v(t + 1, 1) + (1 - p) * v(t + 1, 0)
            if sw < stay:
                best = sw
                policy.add((t + 1, k))
        memo[(t, k)] = best
        return best
    return v(0, 0), policy


def switch_value(y, horizon, r, u, p, switch_cost):
    """(expected NPC of staying, expected NPC with the best switching policy, option value) on the price tree."""
    stay, _ = _tree(y, horizon, r, u, p, switch_cost, False)
    flex, _ = _tree(y, horizon, r, u, p, switch_cost, True)
    return stay, flex, stay - flex

Escrow does not remove lock-in; it lowers the cost of the worst case, where the vendor disappears, from a rebuild under pressure to a takeover of code the firm has never run. Its value depends on whether the deposit is kept current and could be built. Real options in general (Dixit and Pindyck, Investment under Uncertainty, 1994) formalise the same idea: flexibility has a value that a static comparison leaves out, and paying for it (short contracts, standard data formats, escrow) is sometimes cheaper than the lock-in it prevents.

20.4 Tutorial: seven years of an order-management system

The licence and the wage dominate: a licence 20% cheaper makes buying $1.17 million cheaper than building, one 20% dearer makes building $1.69 million cheaper; the wage moves the answer by the same amounts in the other direction. The number of development engineers comes next. The escalator and the integration fee barely matter over seven years. The decision therefore rests on two numbers that can be negotiated or measured: the licence the vendor will accept, and what the firm’s engineers really cost and could otherwise build.

20.5 Choosing a vendor

A handoff specification (Book 12) between the firm’s systems and the vendor’s is the cheapest lock-in insurance: if the interface is the firm’s, a new vendor or an in-house build plugs into the same socket. A platform team (chapter 19) owns it.

20.6 Build: the build-against-buy model

20.7 Exercises

20.8 Problem: Seven Years of an Order-Management System

20.9 Interview questions