The SaaS Industry Has a Problem
The Software-as-a-Service (SaaS) industry is worth over $300 billion. Analysts expect it to hit $1.25 trillion by 2034.
I think they're wrong.
The Premise That Built SaaS
SaaS exists because building software was hard. You needed developers, infrastructure expertise, security knowledge, ongoing maintenance. Easier to pay $50/user/month and let someone else handle it.
That made sense for a long time. It's starting not to.
Low-Code Was Already a Threat
Low-code and no-code platforms—Power Platform, Airtable, Notion, Retool—already chipped away at the edges. Need a simple CRM? A project tracker? An approval workflow? You didn't need Salesforce or Monday.com anymore. You could build it yourself in an afternoon.
The SaaS response was predictable: move upmarket, add complexity, sell "enterprise features" that justify the price tag. That worked because low-code had limits. You could build simple stuff, but anything sophisticated still required real development.
AI Removes the Limits
Here's what changed: AI doesn't just make low-code faster. It makes it capable.
Power Automate can now call the Claude API (Anthropic's large language model). The connector? Built by AI. The workflow logic? Designed by AI. The error handling? AI figured that out too.
I'm not talking about AI writing code for developers. I'm talking about AI enabling the right people to build things that previously required a dev team.
Enter the Technalyst
There's a role emerging that doesn't have a name yet. It sits between traditional developer and business analyst. We're calling it the Technalyst.
A Technalyst isn't a developer—they're not writing production code or managing git repos. But they're not just an analyst making slide decks either.
A Technalyst:
- Thrives in no-code and low-code environments (Power Platform, Airtable, Retool)
- Understands infrastructure basics—can navigate Azure, set up authentication, configure a database when needed
- Thinks in business processes and practical automation, not theoretical frameworks
- Uses AI tools to extend their reach—building connectors, generating logic, solving problems that used to require a developer
The Technalyst is what happens when low-code and AI converge. They can build real solutions—not toys, not prototypes—because the tools finally caught up to their business knowledge.
Where Technalysts Come From
You don't find Technalysts on senior developer job boards. You grow them.
The Technalyst isn't a $180K senior engineer willing to work in low-code. They're a new kind of hire: someone with business aptitude, technical curiosity, and AI fluency. Often a recent college grad.
For decades, companies offshored development to save money. It worked—until communication overhead, timezone gaps, and quality variance ate the savings. The Technalyst model brings that work back onshore.
A college grad earning $60-80K, equipped with Power Platform and AI tools, can deliver what used to require a $150K developer or a $40/hour offshore team. They're in your timezone. They understand your business context. They grow with you.
The talent pool isn't scarce—it's untapped. Every business school is graduating people who understand processes and can learn tools. Every CS program has students who'd rather solve business problems than optimize algorithms. The Technalyst role gives them a path.
The Convergence
Low-code and AI are converging. Fast.
Power Platform already has Copilot embedded. You can describe what you want in plain English and it builds the flow. Azure has AI services you can drop into any application. The gap between "I have an idea" and "I have a working tool" is collapsing.
This convergence is what creates the Technalyst. Five years ago, the gap between "understands the business" and "can build the solution" was too wide. You needed developers to bridge it. Now, someone with business knowledge, infrastructure basics, and AI fluency can cross that gap themselves.
Every month, the ceiling on what a Technalyst can build gets higher. Every month, the floor on what justifies paying for SaaS rises with it.
The Return of Homegrown
This isn't a new idea. It's an old one coming back.
Before SaaS, companies built homegrown tools. Access databases. Excel macros. Custom applications written by that one IT person who understood the business. It worked—until it didn't. Those tools were fragile, undocumented, and died when the person who built them left.
SaaS won because it professionalized what homegrown couldn't: reliability, security, updates, support. The trade-off was flexibility. You got a polished product, but it was built for everyone, not for you.
Low-code started changing this. Power Platform, Airtable, Retool—they let business-minded people build real tools without writing code. The homegrown mentality started coming back. But it hadn't hit critical mass. The tools were good for simple stuff, but anything sophisticated still required developers. Most companies stayed on SaaS.
AI is what pushes it to critical mass.
The homegrown tools of the 2020s aren't Access databases held together with hope. They're Power Apps backed by Dataverse, automated by Power Automate, secured by Azure AD, and enhanced by AI. They have version control. They have documentation (AI can generate it). They have the reliability of enterprise infrastructure with the flexibility of custom-built.
What took a developer a week now takes a Technalyst a day. What took a Technalyst a day now takes an afternoon. The ceiling keeps rising. And every time it rises, another SaaS category becomes replaceable.
Low-code cracked the door. AI kicked it open.
Homegrown is back—and this time, it's enterprise-grade.
The Hidden Tax of SaaS Sprawl
Here's the dirty secret about SaaS: the subscription fee is just the beginning.
The average company runs 100+ SaaS applications. Small businesses average 42. Enterprises with 10,000+ employees? Around 447. And 53% of those licenses go unused within 30 days.
But the real cost isn't the licenses. It's everything else.
Feature bloat. Every feature in Salesforce exists because some customer asked for it. You're paying for a thousand features to get the twelve you actually use. How much time does your team spend navigating menus they don't need? How many clicks to do something that should be one step?
Redundant functionality. Your CRM has reporting—but you don't use it because you have a separate BI tool. Your project tool has time tracking—but you don't use it because you have another app for that. You're licensing the same capability five times across five different vendors.
Data silos. 70 apps means 70 places your data lives. Customer info in the CRM, project data in the PM tool, financials in the accounting system, employee data in HR. Moving data between them? Export, reformat, import, reconcile, repeat. Manual data entry that adds zero value.
Integration nightmare. Connecting all these apps requires Zapier or Make.com (more SaaS subscriptions), custom middleware, or integration consultants. And when vendors update their APIs? Broken syncs. More consultant fees. More workarounds.
Training overhead. Every new employee has to learn 70 different interfaces, 70 different workflows, 70 different logins. The tool almost does what you need—but not quite. So you build workarounds. Document the workarounds. Train people on the workarounds.
This is the hidden tax of SaaS sprawl. The subscription cost shows up on a line item. The human cost—time wasted, data re-entered, workarounds maintained—disappears into overhead.
The Technalyst alternative:
On Power Platform, everything shares one data layer—Dataverse. Build a Power App, and Power Automate can trigger from it. Power BI can report on it. No integration needed. No data movement. No redundant features across apps.
One platform. One data layer. Zero sprawl tax.
The Economic Case
Let's put numbers to this.
The average SaaS spend per employee is $4,830 to $9,000 per year—and that number jumped over 20% from 2024 to 2025. For a 100-person company, that's $500K to $900K annually just on software subscriptions.
Here's what it costs to equip a Technalyst:
| Component | Cost |
|---|---|
| Power Apps Premium | $20/user/month (unlimited apps) |
| Power BI Pro | $14/user/month |
| Power Automate | Included in M365 |
| AI APIs (Claude, GPT) | Pay-per-use, pennies per request |
Total platform cost: $34/user/month. That's 70% cheaper than a typical SaaS stack—and one bill instead of seventy.
Here's what that looks like over five years for a growing company:
| Year | Employees | SaaS Model | Technalyst Model | Annual Savings |
|---|---|---|---|---|
| 1 | 30 | $150K | $152K | -$2K |
| 2 | 45 | $225K | $193K | +$32K |
| 3 | 60 | $300K | $234K | +$66K |
| 4 | 80 | $400K | $288K | +$112K |
| 5 | 100 | $500K | $341K | +$159K |
| Total | $1.58M | $1.21M | +$367K |
SaaS Model: $5,000/employee (industry average). Technalyst Model: $2,000/employee essential SaaS + $34/user Power Platform + salary ($80K→$100K).
The Technalyst breaks even in Year 1 and pays dividends from Year 2 on.
But there's more: tax credits.
Building internal tools can qualify for R&D tax credits. In Canada, the SR&ED (Scientific Research and Experimental Development) program lets companies claim 15-35% of qualifying R&D expenditures. That includes salaries for employees doing development work.
Your Technalyst building a custom workflow automation system? SR&ED-eligible. Developing an AI-powered internal tool? SR&ED. Creating novel solutions to technical problems your business faces? SR&ED.
We claim this. It's not hypothetical.
Your SaaS subscriptions don't qualify for tax credits. Your Technalyst's salary does. Add ~$155K in SR&ED credits over five years and you're looking at $520K+ in total value.
Invest in Technalysts, Not Subscriptions
Here's the shift companies should be making: stop renting software, start building capability.
The SaaS model is a perpetual expense. Money flows out the door—forever. A Technalyst is an investment. The tools they build stay with you. Their knowledge compounds. And when your needs change, they adapt—instead of you waiting for a vendor's roadmap or migrating to yet another platform.
The Technalyst grows with you. They learn your business. The tools they build evolve as you evolve. There's no vendor to negotiate with, no contract renewals, no price hikes when you add users.
And five years later, when your competitors are spending $500K+ annually on SaaS and trying to figure out how to consolidate, you're running lean on custom tools that do exactly what you need.
When to Hire a Developer Instead
The Technalyst isn't the answer to everything. At some point, a traditional developer becomes the better investment.
Hire a developer when:
- You're building a product to sell, not internal tools
- You need performance at scale—millions of users, real-time processing, complex algorithms
- You're doing deep systems integration that goes beyond what connectors can handle
- You need custom mobile apps or highly specialized interfaces
- The business logic is genuinely complex—not just complicated workflows, but algorithmic complexity
Stick with the Technalyst when:
- You're solving internal operational problems
- You need dashboards, reports, and business intelligence
- You're automating workflows and approvals
- You're replacing SaaS tools with fit-for-purpose alternatives
- Speed matters more than perfection—you need something working this month, not this year
The breakpoint is usually about what you're building for. If it's internal capability and operational efficiency, the Technalyst wins on speed and cost. If it's a revenue-generating product or genuinely complex system, invest in developers.
Most companies need both eventually. But most companies are over-indexed on developers and under-indexed on Technalysts. The Technalyst handles 80% of what businesses actually need—and frees developers to focus on the 20% that genuinely requires custom code.
What This Means for SaaS
The $300 billion question: which SaaS categories survive?
Probably safe:
- Complex, regulated domains (healthcare, finance, legal)
- Products with massive network effects (Slack, Figma)
- Platforms that are genuinely best-in-class and evolving fast
SaaS still wins when complexity is high and total cost is low. Take something like FL3XX for charter aircraft management—integrations with every empty leg marketplace, real-time pricing feeds, regulatory compliance across jurisdictions. Replicating that ecosystem would cost more than the subscription. That's where SaaS earns its keep.
The smart move: prioritize replacing low-complexity, high-TCO apps first. Your project management tool charging $15/user/month across 100 employees? That's $18K/year for something a Technalyst builds in a week. Start there.
In trouble:
- Horizontal tools that solve generic problems (project management, simple CRMs, basic analytics)
- Products where the main value is "we built it so you don't have to"
- Anything charging per-seat for functionality that a Technalyst can replicate in Power Platform
The SaaS playbook—find a workflow, productize it, charge monthly forever—worked when building was hard. When a Technalyst can build the same thing in a week, that playbook breaks.
Microsoft Is Best Positioned
This isn't a neutral observation—I think Microsoft wins this transition.
They own the infrastructure layer (Azure). They own the low-code layer (Power Platform). They own the productivity layer where work actually happens (Microsoft 365). And they're embedding AI into all of it.
A Technalyst working in the Microsoft ecosystem can build custom tools using Power Apps, automate them with Power Automate, store data in Dataverse or Azure SQL, add AI capabilities through Azure OpenAI or external APIs—all within an ecosystem the business already manages.
Compare that to stitching together Zapier, Airtable, a separate AI subscription, and hoping the integrations hold. Microsoft's stack is vertically integrated in a way nobody else matches.
The Technalyst's playground is the Microsoft ecosystem. And Microsoft is making that playground more powerful every quarter.
The Counterargument
"But maintenance! Security! Updates!"
Fair. Building something is one thing. Keeping it running is another.
But here's the thing: Microsoft handles most of that. Azure manages the infrastructure. Power Platform is maintained by Microsoft. The AI APIs are someone else's problem. What's left is business logic—and that's exactly what the Technalyst understands best.
The DIY maintenance burden is lower than it's ever been. And it's getting lower every month.
"What if the Technalyst leaves?"
Valid concern. But it's the same concern you'd have with any key employee. The difference: tools built on Power Platform are documented, version-controlled, and built on a mainstream stack. The next Technalyst can pick them up. That's harder to say about the tribal knowledge locked inside SaaS configurations and Zapier workflows that nobody documented.
Where This Goes
I don't think SaaS disappears. But I think the market that analysts expect—$1.25 trillion by 2034—assumes the old dynamics hold.
They won't.
The businesses that hire Technalysts—people who can build fit-for-purpose tools using low-code, AI, and basic cloud infrastructure—will stop paying SaaS subscriptions for solved problems. The ones that don't will keep paying. But the ratio is going to shift.
The smart money isn't on more subscriptions. It's on building internal capability, reclaiming development costs through tax credits, and owning tools that actually fit how you work.
Now is the time to build that competitive advantage—while your competitors are still locked into SaaS contracts and haven't figured out what's changing. The companies that hire Technalysts today will be running lean, integrated, fit-for-purpose systems by the time everyone else realizes what happened.
The SaaS industry is built on a bet that building software stays hard. The Technalyst is proof that bet is breaking.
Ready to stop renting bloated software? We help companies build internal capability with Technalysts—onshore talent that grows with your business. Contact us to talk about investing in capability, not subscriptions.