Historically, the various software and technology solutions that serve financial planners have been very fragmented. Independent firms were often stuck with small, homegrown solutions for financial planning, client relationship management (CRM) and portfolio reporting software. Alternately, they were forced to work with software providers that simply didn't have enough resources for growth and development. Advisors with larger firms often had access to the best software, but since it was a proprietary solution of the parent firm, the advisor effectively faced a world where key client and business data might be held captive.
As the world transitions into the digital age, though, this landscape is rapidly changing, due both to the accessibility brought about by having near-universal access to "the cloud" from any computer or device and any location, and the emergence of application programming interfaces (APIs) that allow disparate software packages to integrate in a way that has never before been possible.
These changes in turn are driving several new emerging trends. The first is that now independent software companies are often larger and better developed than home-grown proprietary solutions. This development encourages new firms to innovate and makes it easier than ever for advisors to change firms knowing that they will have more portable client and business data and access to similar (or even better) software after making a change.
In addition, the growing integrations through software APIs are rapidly bringing advisors towards the "Holy Grail" of a unified central solution for CRM, portfolio management and reporting, and financial planning software, which is further driven by a growing number of "integrators"—firms that help adapt software packages through their APIs to develop customized advisory-firm-specific Grail solutions.
As of now, these trends are still under way and will be playing out for many more years. Nonetheless, the direction is clear, and remarkably positive for both startup technology firms—who have more opportunity for growth and success than ever—and advisors, who may enjoy software in the future that is simultaneously cheaper, more efficient, more innovative, more integrated, and just downright superior to anything we've ever had in the past.
How We Got to This Point
In the past, the world of software for financial planners was very fragmented. Large firms (i.e., wirehouses and insurance companies) developed their own proprietary solutions, typically integrating together (at least partially) the financial planning, CRM and portfolio reporting software into a unified package. Although the integrations were often limited (at least by today's standards), and the consolidated software could be somewhat clunky and inefficient, the reality was that the best software solutions were at the largest firms.
By contrast, advisors in the independent space struggled. The options were few and far between; many solutions were tiny, struggling software companies or even home-grown software originally built within a planning firm and then sold to other advisors. In the case of CRM in particular, large, non-industry-specific platforms simply had a lightly customized template for advisors to overlay (e.g., Act! and Goldmine). For independent RIAs, there was often little choice but to accept what was offered and make the best of it. Independent broker-dealers often tried for more, but struggled with the lack of scale necessary to internally create and offer the best proprietary solutions.
The end result of these challenges was that many advisors within larger firms effectively became captive to their company's software solutions, as going independent meant taking a step down in software and technology, and even if there was a competitor with "comparable" technology (which was often hard to determine) the change still meant walking away from your client and business data, which was often embedded within and effectively "held hostage" by the current employer and its software.
For those at smaller or independent firms, they weren't necessarily held captive to a platform because of its technology, but the alternative wasn't much better: making a decision from among the very limited small-company solutions available. Although the planning firm might own its data in such a scenario, migrating it from one software platform to another was difficult and expensive, or outright impossible as well. In the meantime, the software evolved very little, as most of these "tiny" firms simply didn't have the resources to reinvest for growth and development.
The Impact of the Digital Age
Over the past several years, the technology landscape for financial planning (and other industries) has begun to shift dramatically as financial planning enters the digital age; these changes are being driven by two major forces.
The first is the rise of the Internet and an ever-growing amount of bandwidth that has made it possible to interact with software primarily through digital connectivity. The end result of this change: software no longer needs to run on your computer in order for you to use it. Instead, it can exist "in the cloud" and still be accessed from your computer.
Although the near-term benefit is simply that firms no longer have to buy their own hardware to run local installations of software, the longer-term impact is far more profound: with cloud-based computing, your software can be accessed from any location, and any device—which also means it can be accessed from any employer and on any advisory platform.
The second major trend has been the emergence of application programming interfaces (APIs). The basic concept of an API is that software is built with various hooks and openings, which allows programmers from other companies to program their software to connect with, latch on to, and interact with the first software.
Think of it this way. When you use your computer, you don't actually interact with the physical box full of computer parts; instead, you use a keyboard, mouse and monitor to see and interface with your hardware and software. Software of the past was like having the computer with no mouse or keyboard; you could see what it was doing on the monitor, but you had no way to interact with it. When software is built with an application programming interface—the key word being "interface"—it's like building in a mouse and keyboard, so other software can now interact with it. The end result: software packages are beginning to "talk" to one another and communicate.