Original URL: http://www.theregister.co.uk/2012/11/19/spreadsheets/
How spreadsheets (nearly) conquered and killed the financial industry
Would you trust millions on an Excel formula?
In my first job out of college I worked at a timesharing firm. For those of you who don’t know, timesharing, whose heyday was in the late 1970s, allowed companies to use large mainframe-based systems without themselves having to purchase these huge computers and hire an army of support staff.
Once signed up, a company shares a multitasking mainframe machine with hundreds of other customers, giving each user, seated at a dumb terminal, the illusion of being connected to his or her own personal mainframe.
For this, customers would pay towards development and support costs for the systems and, more importantly, cough up for usage costs based on the number of processor minutes they clocked each month. This was a very profitable business — until the advent of the PC and desktop computing.
The eventual fate of my employer became clear to me after one colleague left the company: he ported the huge, wildly complicated accounting system that cost one of our clients tens of thousands of dollars a month in usage and maintenance costs to ... a VisiCalc spreadsheet running on an Apple II.
To our former customer, this meant instant savings of a good half-million dollars a year. Mainframes, even for companies that owned their own, became dinosaurs almost overnight. They were massively big, expensive, lumbering machines that despite their size still couldn’t do many of the things a PC could.
The advent of the client-server model (to run systems that were too large for a desktop machine, or had to support many users) meant a tiny step back in the direction of the terminal, but desktop computing had nevertheless firmly taken hold. In the investment banking business where I worked, the spreadsheet was a magical thing whose arrival happened to coincide with the rise of super-sophisticated financial products.
VisiCalc: Those were the days...
With VisiCalc (and later Lotus 1-2-3, and later still Excel), traders could bang out prices and work through complex scenarios whenever the mood hit them, and without any assistance from developers. By the 1990s, spreadsheets were as important a part of traders’ lives as desk calculators had been a couple of decades earlier. Today, it’s inconceivable for a trader, especially someone on a derivatives desk, not to have advanced knowledge of Excel. Some traders go much deeper than that, to the point of having Visual Basic skills on par with a mid-level developer.
While the most difficult spreadsheets are now built by dedicated development and quantitative analyst teams, trading desks are more or less in charge when it comes to the daily management of their Excel libraries. Having direct control over the “calculators” they use means traders don’t need to put in a formal request for every minor formula-tweak they need implemented, or every slight change to the scenarios they want to run, and then wait for someone else to implement it — a process that would make much of their day-to-day work impossible given the speed of market movements.
A well-designed spreadsheet leaves plenty of room for users to fine tune it on their own as new kinds of deals are negotiated and trading conditions shift. And of course, many spreadsheets are built and maintained by traders with no assistance at all. Still, there will always be times when a requirement is complex enough that it calls for a change to the underlying code by a full-time quant or tech team. However, considering that speed is of the essence even when traders can’t implement sheet changes themselves, the rules for formal “change management” are generally far more lax for spreadsheet work.
The bad old days of change management
Anyone who has worked for even a medium-sized financial firm knows that pushing through changes to a production system at these companies can be enough to send you over the edge. In the worst case I’ve seen, the process entailed, at a minimum, filling out a web-based form, submitting your change request to a long line of managers (every one of whom had to approve it, in turn), and sitting in on a conference call to discuss the change and get it cleared by the production-support team. If your change had to go live on a Friday evening, it had to be approved on the previous Wednesday’s conference call.
This process was mandatory for all changes, no matter how trivial. The web form was literally the most complex I’ve ever come across, so filled with arcane codes and cross-references that I never saw anyone go through the process from scratch; standard practice was to take the form you’d submitted on some previous occasion and update the relevant fields to reflect this week’s change.
That previous change form was based on an earlier one, and so on back to some primordial request page that an unknown, intrepid developer had filled out in the distant past. Requiring your change to go through the full chain of approving managers was semi-pointless, since many of them were so senior they had no idea what the change was about, or worked in an entirely different area of the firm, and as a result automatically pushed the APPROVE button.
Nevertheless, these managers had to be chased down if they’d been too lazy or busy to approve your change as the deadline approached. Then there was the chance that one of them was on holiday, or that you’d missed filling in one of the form’s forty fields, or any number of other problems.
Step forward the spreadsheet, saviour of those chained to change requests
Though there seemed to be no hope of having this process simplified, there was a tacit recognition by management that it was completely unworkable in the dynamic and fast-moving world of spreadsheet development by “rapid deployment” teams working closely with the business. (I managed one of these teams, with members in London, New York, and Hong Kong, each supporting their local desk.)
For these developers, unlike the teams who supported larger-scale, Linux-and-Java-based systems, the usual rules simply didn’t apply. Spreadsheet changes could be pushed out at will, and at a moment’s notice.
In addition to removing a tremendous amount of drudgery and bureaucracy from these developers’ lives, this across-the-board exemption made it much easier for traders to get their day-to-day work done, since their requests could be implemented almost immediately.
This resulted in a kind of positive feedback loop, where desk developers began to be seen as the only ones who could deliver usable systems when they were needed.
But while it was true that development of large systems was tortuously slow and horribly error-prone, it was clear to anyone working in technology that there were many reasons for this divergence: in addition to being burdened with the tedious rollout procedure described above, teams tasked with building industrial-strength systems suffered from top-heavy management, uncooperative system administrators and support staff (one of many symptoms of an out-of-control bureaucracy), and a distance from the desk that proved disastrous — all in sharp contrast to the rapid deployment teams, who sat next to the traders all day and are were intimately familiar with their workflows.
Furthermore, the design and coding of a Java system is always significantly more involved than relatively simple Excel scripting, making it easy for people doing the latter to become instant heroes.
Excel with Excel
All these factors led to an ever-increasing reliance on rapid-deployment teams and spreadsheets. Large development projects either failed outright or couldn’t be launched to begin with because they needed big teams and long-term horizons for the design, development, and QA.
So the desk frequently went with the “stopgap” of a spreadsheet.
This would invariably be seen as tactical (i.e., short-term), but again and again, when the more permanent system never arrived, the spreadsheet became the de facto strategic solution, much easier than trying to address the bigger problems that were causing so many large-scale development projects to falter. As a result, many processes that were plainly too big or complex to run in Excel over the long term did.
The result: frequent memory blowouts, painfully slow calculation cycles, and PCs pushed past way their limit. With piles of money riding on the deals that were being priced, or the risks that were being hedged, these seemingly minor PC hiccups had the potential to cause not-at-all-minor losses.
But the temptation to go with the quick solution was too great, and large-scale development too trouble-plagued, for most people to look at this state of affairs objectively.
While the example I’ve just described was the most extreme I’ve seen, the tendency to reach for the quick and dirty solution of an Excel spreadsheet whether appropriate or not is common on trading desks everywhere. Traders like the idea of having direct control of their processes, or at least being able to see their workings; large-scale systems become harder to design and build as they get more complex, and the development teams harder to manage; and rapid-deployment teams are generally free from the burdensome rules that other developers have to adhere to, making them more agile in their response to fast-changing business requirements.
But this short-sightedness can lead to a variety of problems: relying on lightweight, desktop-based solutions for business-critical functions; giving too much power to users in situations that require centrally managed checks and balances; and circumventing the professional monitoring and full-time production support that naturally come with large-scale systems.
Giving users too much control and flexibility can be a very bad idea when the processes involved are especially delicate, or where the amount of money at stake is large enough to render even an innocent mistake disastrous. ®