Executive Summary
When deciding on what technology to adopt for their practices, financial advisors have always had the choice between building their own tools or buying 'off-the-shelf' third-party solutions. But in practice, for the vast majority of firms, it's historically almost always been better to "buy" than to "build": Because the upfront cost of building a piece of software is so high (which third-party providers are able to spread across many different users), it might take many years for a firm that builds its own software to realize enough savings to recoup the initial investment – at which point it might be time to replace or overhaul the software and start the process over again.
But in the past several years, the cost of building and developing new software has decreased thanks to the emergence of AI-powered 'vibe coding' tools, which can convert plain-English instructions from users into the code needed to make the software work – greatly reducing the need to hire a human developer to manually code the whole project (and in many cases allowing developers to work faster and more cheaply). Which in turn has changed the math about when it makes sense to build versus buy technology: Where it once might have only made sense for firms with 20+ advisors to build custom technology, many smaller firms and even solo advisors now can (and do) create their own tools. The lowering of barriers to self-built technology has led to many predictions that advisors will overwhelmingly drop their third-party software licenses and turn to 'homegrown' tools, causing mass disruption and consolidation of existing AdvisorTech providers.
While some advisors are embracing the possibilities of vibe coding and building their own tools, the evidence so far shows that third-party software providers as a whole are under no threat from vibe coded alternatives. Because even among advisors who are diving into tools like Claude to build their own technology, the vast majority are creating software that supplements, rather than replaces, their existing third-party solutions. For example, advisors in vibe coding communities like Builder FP have primarily focused on either tools that can help integrate reporting outputs from their existing software platforms into a single streamlined deliverable, or that are specific to the needs of their own niche clientele. Which makes sense given that most advisors are already fairly happy with the software that they use, and there's little reason to go through the effort of building custom software from scratch (even with the help of AI) to replace something that's already working well!
And in fact, the proliferation of AI coding tools will more likely lead to an increase, not a decrease, in the number of third-party technology solutions available. Entrepreneurs can use those same vibe coding tools to develop technology at a quicker pace and in areas that might not have been economically viable in the past (including niche areas like real estate and long-term care planning as well as categories like CRM and tax planning where there is well-established competition). Advisors may soon be able to find more tools to fill in the gaps between their existing technology – making the already crowded technology landscape even more so, and forcing advisors to spend even more time evaluating and managing their technology.
The key point is that although AI vibe coding might lower the bar for advisors to build their own tools, the reality is that few advisors consider themselves technologists and most are instead satisfied with letting a specialized third-party provider do the work of building, developing, and distributing the software that they use (not to mention handling the finer points of things like data security that are harder to master with self-built software). And while advisors can choose to build their own tools in the specific areas that their existing software doesn't cover, the proliferation of new technology suggests that those who aren't inclined to do it themselves may be able to simply wait a little while for the right solution to appear from a third party!
The Build-Vs-Buy Decision
For every piece of technology an advisor uses, there's a fundamental decision – conscious or not – between two options: To build their own custom tool in-house (or hire someone to build it for them), or to buy one 'off the shelf' from a third-party provider.
There are significant tradeoffs in building versus buying software. Historically, building, developing, and launching new software has required a substantial upfront investment of time and money, and those initial costs (not to mention the ongoing costs of maintaining and updating the tool over time) are only justified if the profits realized from adopting the software are higher than the cost of building it. And so there has been a high bar for how much a new tool would need to either increase the advisor's revenue (e.g., by allowing the advisor to do deeper planning and charge higher fees) and/or decrease overhead costs (e.g., by replacing the cost of an off-the-shelf tool), to at least break even within a reasonable amount of time.
For example, imagine it costs $100,000 for a firm to build a custom portfolio reporting system, and another $5,000 per year on average to maintain and update it – but building the tool in-house allows the firm to save $10,000 per year on the cost of third-party reporting software. The ongoing annual cost savings of the in-house software would be $10,000 − $5,000 = $5,000 (i.e., the difference between the off-the-shelf software and the ongoing maintenance of the self-built tool), and since it cost $100,000 to build, it would take $100,000 ÷ $5,000 = 20 years to make up for the upfront cost – which is in all likelihood longer than the software's useful life before it would require a substantial upgrade or replacement (another significant one-time cost).
The unfriendly breakeven math of self-built tools is why the majority of advisory firms rely on off-the-shelf options for their technology needs. Technology providers' ability to spread out their development costs over hundreds or thousands of users means they can make up the cost of building and developing software more quickly than a single advisory firm, allowing them to charge an ongoing subscription rate that isn't much more than the cost of maintaining the software. That's on top of the fact that most advisors and advisory firms simply aren't specialists in technology development, especially when it comes to things like user experience, data security, and integration with other tools. And so even setting aside the economic considerations, it's a major shift in business focus for an RIA to start making software (which is partly why when advisors do create their own software tools, they often bring them to market to sell to other advisors rather than retaining them as strictly in-house, as at that point the software has essentially become its own line of business outside that of running an advisory firm).
But off-the-shelf software comes with its own set of tradeoffs. For the economics of spreading out development costs across many users to work, there need to be many users willing to subscribe and pay for the solution they're providing. And so third-party technology providers tend to focus on solving problems that many advisory firms have. Features might be prioritized based on their potential to have the biggest impact on the highest number of users. Which is great for the technology's usefulness at a macro scale – everyone needs a CRM to do the basic CRM functions of storing and cataloguing client records, and a financial planning software to have a basic projection engine to compare a client's baseline against potential planning strategies. However, it also means that due to cost ineffectiveness, third-party tech providers don't tend to prioritize more niche functions that might only apply to a narrow slice of firms or clients.
Simply put, buying off-the-shelf software tends to be less expensive for advisory firms than building technology themselves because of the economies of scale that third-party technology providers can achieve. But because technology providers need to have a large enough market for their solutions to achieve that scale, they don't tend to address niche, firm-specific needs as well as a (more expensive) custom-built solution would. Which ultimately makes the build-versus-buy decision come down to whether it's better to have the least expensive solution, or the one that comes closest to solving for that particular advisory firm's needs – or in cases where there is no available solution that truly fits the firm's needs, then it's about whether it's worth using a custom-built solution at all, versus, for example, building an Excel template to do the task.
AI Tools Change The Calculus For Building Versus Buying Technology
The reason that building technology has historically been such an expensive endeavor is because it has required skill and knowledge in coding and software design to translate an idea into a functional, useful tool. Since most advisors aren't software developers themselves, they'd need to hire a third-party developer to build the solution for them. And since most software developers aren't necessarily experts in the structure and needs of financial advisory firms, there would often need to be an extensive iteration process as the advisor and developer went back and forth to get the design and functionality of the software just right. Many billable hours later, there would be a 'final' product launch – but it was only 'final' until a new feature or infrastructure upgrade was required, or a key component broke and needed retooling. Much like buying a home is a tradeoff between the freedom and financial upside of homeownership and the responsibility to pay for any ongoing repairs and upgrades, 'owning' software in reality means taking on an indefinite commitment to keep it functional and up-to-date.
But because much of the cost of building software is the expense of a human developer, the math changes if that developer cost is reduced or eliminated entirely. In other words, the lower the cost of building, testing and maintaining the software, the lower the bar (in terms of higher revenue or efficiency created by the software) for proprietary ownership of the software versus 'renting' it by licensing it from a third-party provider.
And over the past year-plus there have indeed been developments that can drastically reduce the cost of building certain technology. Large Language Models (LLMs), which are trained by feeding massive amounts of text-based data into a training model to predict the most logical next word in a sequence based on a given 'prompt' or input, are perhaps best known in the form of chatbot tools like ChatGPT, Claude, and Google's Gemini that take English-language prompts from users and generate English-language responses. But LLMs can also do the same thing with the 'language' of software code, taking instructions from a user and outputting the code that its training model predicts will fulfill the requested function.
This has given rise to a number of AI "vibe coding" tools like Replit, which can take plain-English instructions from users and turn them into software apps without the need for any programming or development expertise. The upshot of which is that, at least for relatively basic software, it's no longer necessary to hire a developer who can translate an idea for a software tool into concrete code: Where it once might have cost a thousand dollars or more to develop and launch even a fairly basic calculator app, this can now be done with a basic Replit subscription for under $20 per month. And even for more complex software that satisfies the stricter data security and integration needs of financial advisory firms – where it's still generally a better idea to hire a human developer who can ensure those needs are met – vibe-coding tools can still dramatically reduce the cost by allowing human developers to get through projects more quickly and on a smaller budget.
As a result, building software in-house via AI has become theoretically practical for a much bigger swath of advisory firms than was the case in the past. Where it once may have really only made sense to build if a firm had 20+ advisors (which, assuming $1 million of revenue per advisor and an annual technology budget of 5% of revenue, equates to $1 million to spend each year), building might now be feasible for firms with just a handful of advisors or even some solo RIAs with technology budgets 'just' in the thousands or low tens of thousands. Again in theory, this opens up a world where RIA firms can build and develop software that conforms to the specific individual needs of those firms and their clients rather than relying solely on off-the-shelf tools whose features tend to cater towards the masses of advisory firms.
As in many cases where a previously specialized service or product has been "democratized" to become accessible to the mass market, the AI vibe coding movement has led to predictions of mass disruption in the world of third-party software providers (a.k.a., the "SaaSpocalypse"). After all, why spend 4%–6% of revenue each year (which is what our Kitces Research on AdvisorTech shows to be the average annual technology spend) on third-party solutions when, for the nominal upfront cost of a vibe coding tool – or the more expensive but still manageable cost of hiring a developer – you can build your own software that's actually designed for the specific needs of your firm?
Why Third-Party AdvisorTech Tools Won't Go Away
Some advisors have been eager to stay on the leading edge of the AI revolution, particularly when it comes to building their own tools through vibe coding. They've developed customized chatbots to pull key information from meeting transcripts into a format that's ready to enter into the advisor's CRM or financial planning software. They've dived into DIY tools like Replit to find new and better ways to serve their clients in planning areas that off-the-shelf software doesn't cover. They've built tools to make it easier to preserve institutional knowledge like planning philosophy and firm policies for junior advisors to access. For someone willing to take the time to scale the learning curve of LLM tools – which, daunting as it may occasionally seem, is a much shallower curve than traditional coding and software development – the possibilities are nearly endless for tools that can supplement (or replace) the third-party tools in the advisory tech stack.
But the fact that some advisors are embracing the possibilities of a build-your-own approach to technology doesn't necessarily mean that the third-party software providers are under threat. Because in reality, most advisors are not DIY technologists. Their main job is to work with their clients, and while they may occasionally be on the lookout for tools that can help them do that better – often when those tools get so popular that they become hard to ignore – they aren't predisposed to go down the rabbit hole with an AI solution like Claude to build their own tools just because they can.
That's especially true because in general, advisors like the off-the-shelf technology that they use. In the most recent Kitces Research on Advisor Technology, the median advisor rated their overall tech stacks at a 7.3 out of 10 in satisfaction – certainly leaving room for improvement, but not so low that most advisors are willing to abandon their existing tools and go through the pain of transferring client data to a brand-new set of custom-built software. Off-the-shelf tools are built to have the most functionality for the greatest number of users, and so they tend to be at the very least good enough for a wide range of advisors – and the intense competition in the space often gives them incentive to go beyond 'just' good enough in order to stand out from the rest.
And so the "AI will kill off the AdvisorTech Map" narrative rings hollow not because AI can't necessarily build replacement tools for most of the technology that advisors use today, but because there's no particular reason for advisors to switch from what they're already using and are fairly happy with. Especially because the act of changing from one piece of technology to another is itself very disruptive: client data needs to be moved from the old tool to the new one, users need to get used to new and different interfaces and workflows for using the tech, and integrations need to be re-established and tested before the new software really feels like a seamless part of the firm's operations. In a world where advisors might change a core piece of technology once every 10 years, it's a stretch to expect thousands of busy advisors to drop their software subscriptions en masse in favor of homebuilt solutions simply because an AI-powered coding tool allows them to do so.
What Advisors Actually Build With AI
Although the advisor tech stack as a whole – particularly the core components like financial planning, CRM, and portfolio management systems – isn't likely to disappear as a result of vibe coded alternatives, there are some practical areas where advisors have found it worth building their own solutions using AI.
Some of the best evidence of this comes from Builder FP, a community of financial advisors who are interested in building tools for their own practices. Builder FP was started by Andy Baxley, the founder of Two Trails Financial Planning and someone who has built (and publicly shared) many tools for his firm using Claude and Altruist's Hazel AI tool. It hosts regular "Builders Day" workshops where like-minded advisors work to build and "ship" their own DIY software while relying on each other to share knowledge, test features, and generally stay accountable for finishing the whole thing in one day.
According to Baxley, a number of themes tend to consistently recur in the types of software advisors are interesting in building. While a few do have very ambitious plans in mind like creating a new financial planning software from scratch, the majority have more modest goals of creating tools that fill in the gaps left by their existing software – not replacing that software entirely.
For example, one of advisors' most common goals is to create cleaner firm-branded client-facing tools and deliverables. This includes simple calculators (e.g., 401(k) contributions, backdoor Roth analysis, and portfolio transitions) that might have previously lived in Excel, charts and data visualizations that weren't available from the tools where the actual data lived, and holistic client reports combining information from multiple tools (e.g., life events and goals from CRM, net worth from financial planning software, and asset allocation from portfolio management software) rolling up into a single clean deliverable rather than an amalgamation of differently formatted reports from various software tools.
Additionally, many of Builder FP's advisors are interested in creating highly tailored planning tools for the specific client niche that they serve. For instance, advisors with clients who work in a particular career field, or own certain types of real estate, or live in states with their own income or estate tax complications, might find it useful to have calculators or scenario planning tools for those clients – but such tools are almost never going to be available through most general-purpose advisor technology. For an advisor willing to do so, an afternoon spent building one of these tools in Claude can take the whole process out of the spreadsheets where they may have once lived and into a cleaner and advisor-branded format (that isn't at risk of breaking from one mistakenly altered formula in a spreadsheet cell).
What's striking to see in the context of Builder FP is that even with a group of advisors that are by definition on the leading edge of AI use for their firms, the goal is largely not to use AI to replace their entire tech stack with custom tools. Instead, they're just looking to supplement their existing technology to better meet the needs of themselves and their clients, whether that's by improving on the reporting and presentation capabilities of core software (most notably to combine the reports from multiple tools into one consistent format) or by adding niche-specific planning capabilities that would never be commercially viable enough to include within an off-the-shelf tool.
Which makes sense when considering the key point that most advisors are really too busy to spend a significant chunk of time diving into technology: If your existing third-party technology fulfills 90% of the functionality that your advisory firm needs, and you're fairly happy with how they do it, it's a waste of time and resources to create a homebuilt alternative just to replicate those tools, even if AI reduces the cost of doing so. It's much more practical to use AI just to build tools that cover just the last 10% of functionality that isn't fulfilled by third-party providers, and is specific to your own firm and client niche, since that's where firms have traditionally found it cost-prohibitive to hire human developers to build their own custom solutions.
Or put differently, based on what we've seen so far, advisors are content to let the third-party providers that cover most of their technology needs continue to do so – and the relatively few who dive into DIY builds tend to only do so for the small-scale, hyperspecific projects that fall between the cracks of the legacy providers.
Why AI Vibe Coding Will Lead To More (Not Less) Technology
There are a couple of takeaways from the rise of AI vibe coding – neither of which conform to the common narrative that most standalone providers will be wiped out by the emergence of self-built DIY tools.
The first is that, similar to the fact that the bar is now lower for advisors to build their own vibe coded software tools to serve their own niche needs, the same is true for standalone providers. If their in-house or outsourced developers no longer need to manually code each new feature into the platform, it makes it possible for the provider to roll out features at a much quicker pace, and to add functionality for narrower use cases that may not have previously been commercially viable. And as bigger technology providers increasingly start to build AI into their platforms, it could become possible for advisors to start molding the software to their own specific use cases: We're already seeing that with tools like Altruist's Hazel, which advisors can use to develop their own recurring reports or tasks. In other words, rather than needing to go out and build their own niche tools to make up for what isn't included in the existing technology, existing providers may make it possible for advisors to build those tools within their platforms.
The second takeaway is that, rather than shrinking the AdvisorTech landscape by swallowing up many of the existing providers, the emergence of AI vibe coding is more likely to increase the number of technology solutions serving advisors. With the much lower bar to build, test, and launch new software, the pace of new solutions could very well increase – coming both from full-time software entrepreneurs as well as advisors who decide after building a solution to meet their own needs that other advisors (who aren't as enthusiastic about building) might be interested in as well.
On the one hand, this creates the potential to create more technology options for advisors, particularly in specialized planning areas which might not have been feasible as a standalone solution in the pre-AI era (and perhaps means that, for those advisors who aren't interested in building their own technology, they might be able to simply wait a few months or years before an off-the-shelf solution comes along). For example, after many years during which Holistiplan had little competition as an advisor-focused tax planning software, multiple new solutions have come out in the last 12–18 months, including Hive Tax AI, April, Worthy, Wealth.com's Tax Planning module, and Altruist's Hazel tax planning agent. And the equity compensation planning software category, which was long dominated by StockOpter and myStockOptions.com, has expanded over the last year to include EquityNav, Gemifi, Trayecto, and Grantd (the latter of which has already acquired the legacy provider StockOpter). New providers have further popped up in even more niche categories, including Waterlily in long-term care planning, RISR and Capitaliz in planning for business owners, Leveridge and RE Wealth for real estate planning, and Knomee and Shaping Wealth's Lydia in client behavior and psychology.
But on the other hand, the AI-driven explosion in advisor technology also makes the already crowded tech landscape that much more crowded. Advisors with more technology to choose from will ironically need to put more time and effort into deciding which solutions to adopt for their firm, and will likely end up with more technology tools overall – a variation on the "Jevons Paradox" where technology that increases the efficiency of how a resource is used tends to lead to greater (rather than less) consumption of the resource.
From the tech providers' perspective, an even more crowded technology landscape means that much of the resources that AI has saved them in building and developing their software will need to be reinvested into marketing and distribution for them to stand out from the field. Which means that, despite AI making new technology tools easier and cheaper to build, the cost of third-party tools isn't necessarily going to go down as a result. And even though most advisors might not want to replace all of their existing software with self-built tools, the existence of new alternatives might lead them to replace some of their current tools with newer, AI-native ones – in other words, although third-party advisor technology as a whole isn't likely to get replaced by advisor-vibe-coded tools, individual third-party solutions could very well be disrupted due to the emergence of new competition in the AI era.
The bottom line, though, is that counter to the narrative that advisor-built AI tools will consume or eliminate most of the AdvisorTech solutions on the market today, the evidence so far shows that few advisors are really that interested in replacing their tech stack with DIY solutions – and even the more AI-curious advisors are focusing more on augmenting their existing software with niche tools than on creating a single AI-built tool to do everything. And as legacy software providers continue to build AI into their own platforms, we may see those niches increasingly filled by the third-party providers themselves, further reducing the need for advisors to build their own tools. Which ultimately means that, if anything, the upshot of the AI vibe coding era will be to give advisors even more options for how to assemble their tech stack – not less.
