Building great software can be a difficult task. Scaling that software? Even more so. For every SaaS business that has scaled to $5 million, let alone over $50 million in revenue, there’s a long and complicated story of how they managed to do so. Unfortunately, many worthwhile products will never make it anywhere near that far.

A lot of the challenges with scaling software start right from the beginning, and are born out of how a business decides to build their MVP or V1 product. A business’s foundation is indicative of how well a product will eventually scale. You’d never consider building a skyscraper on a poorly set foundation, but with software today, that’s common practice.

In the race to bring cloud software to market, developers are often forced to hack together the core of their application with custom code that hobbles the business as it scales. It’s all too common to build an offering on a code base of stitched together products, just to find out you’ll have to refactor for future releases.

That’s what Chassi’s Founder & CEO, Brad Jannenga, struggled with as he built WebPT and his three previous software platforms. He witnessed first-hand how a stitched together foundation creates costly challenges at scale.

The challenges of scaling

In 2006, Brad started dating a Physical Therapist who asked for his help in finding software to help run her clinic. After looking at products on the market and not finding anything suitable, he decided to build one himself. While she treated patients and shaped user requirements, he built the product. Eventually, as she began to use the software, the other PTs in her clinic, and then her region, followed suit. WebPT was in business, and growing quickly!

Brad Jannenga

Brad Jannenga co-founded WebPT in 2006

What started in a coffee shop eventually filled a warehouse in downtown Phoenix; the business scaled faster than anyone would have expected. But that growth created its own set of challenges. As the business grew, so too did the complexity of creating new products and features to respond to evolving market requirements. In an effort to keep up with intense customer demands, the team experienced the pain brought by code rewrites and technical debt on the product roadmap. In true entrepreneurial fashion, despite the ongoing success of the company, Brad’s attention remained focused on how to improve the product, and he learned from these growing pains.

Eventually, after conducting a Series B financing round, Brad stepped away from the day-to-day operations of the business to explore the potential of building something new. While analyzing a variety of opportunities to bring SaaS solutions to new markets, he saw a common pain point for each potential software build that he evaluated. Specifically, Brad saw there would be a lot of redundant coding needed to build the same components over and over again for each piece of software.

He wasn’t alone in seeing the pain points that come with building and scaling software. Jeremy Wilson, employee #4 and the Director of Software Development at WebPT, spent years before WebPT building different software companies, all needing and using the same core components. Then, when WebPT got to the point where it needed to scale, he saw, yet again, the problems that come with scaling on an unstable, inflexible base. This is when Brad and Jeremy first discussed the idea in 2009 that ended up turning into Chassi.

Coming back to 2016, Brad knew that there had to be a better way to build out these SaaS solutions he wanted to work on. Brad and Jeremy came back together, put their heads together, and decided to work on this problem that they have dealt with for so long. Chassi was born.

Building a future-proof application core

As any developer knows, products change over time based on the evolution of customer needs and available technologies. It’s the responsibility of a business to adapt their product to match the needs of their customers; if they don’t, a competitor will. Due to the dynamic and competitive nature of SaaS markets, developers are often forced to write code that will likely be substantially refactored or even entirely rewritten in the not-so-distant future. But it doesn’t have to be this way.

Currently, there’s an aspect of every customer-facing SaaS product that has yet to be standardized, like a solid foundation should be. It isn’t infrastructure (that’s been addressed thanks to the cloud), and it isn’t the proprietary application logic (that’s unique to each respective business). What we’re talking about what comes right in the middle—the Application Core.

Diagram of the Application Core

Your energy should be focused on your IP

In order to meet the demands of dynamic markets, SaaS businesses need the ability to rapidly create plans, manage billing and user subscriptions, adjust and track customer journeys, and more. Many companies end up custom coding their entire application, or stitching together separate third party solutions that were never designed to work together. It’s this rigid code that creates an inflexible application, because the reality is, no requirements are ever fixed; the market will always change them!

For example, you want to introduce a new pricing plan? How about run a promotion to coincide with an upcoming major event? Would you like to build different product bundles, comprised of different features, based on new trends you’re seeing in your market? Any one of these endeavors could cost you a substantial amount of time and money because most companies hard code their application features to static plan definitions.

What if you need to rewrite your code base? That will take months (or years, with a mature product), all because the software wasn’t built on a scalable foundation. Not only is it resource intensive and time consuming for developers, but it slows your business’s ability to respond to market demands, leading to missed opportunities. On top of that, there’s the opportunity cost associated with allocating precious developer time to solving those problems, instead of focusing on creating value within your intellectual property.

Introducing Chassi

We’ve decided to take this issue head on. With our initial offering of five business-critical APIs, we’ll handle the code you don’t want to, allowing you to focus on your big idea. We all know that’s the fun part anyway. You’ll be able to code confidently, knowing that your software was built with a scalable foundation right from the start, eliminating an immense amount of work as you grow.

Launching with five business-critical APIs

Don’t lock your customers into your current plan versions or feature offerings. Rather, build a product that formulates and dynamically renders around each customer’s unique order, even when new features become available. Get full visibility into every journey your customers are engaged in, so you can experiment, learn, and respond to their needs. Build a better software business that focuses on customer success and postures you to address changing market conditions with true agility.

The core of your application should empower you, not hold you back! At Chassi, our mission is to help you build a better software business. We envision a world where software suffers less from technical debt, where you maintain full visibility of your customers, where you are better able to respond to customer and market needs, and where you focus more on your intellectual property, rather than on your application’s “plumbing”. Build agility into your core and scale seamlessly as your company grows.

Chassi exists to help SaaS businesses build better software and achieve their full potential. We hope you’ll join us.

Cheers,
The Chassi Team

PS: We’re super excited to get Chassi into the hands of builders like you. In the coming months we will be admitting people to the platform through our Early Access program. Sign up today to request early access before we release to the public.

Follow us on Twitter and Facebook.