B2B SaaS: How not to build

Launching a B2B SaaS platform to streamline complex & traditionally manual workflows is no small feat. Over the course of developing Accelerate — an end-to-end business management solution for the landscaping industry, we’ve encountered pivotal lessons that shaped our approach to building and refining the product.

In this blog, we’ll delve into our experiences, highlighting effective strategies and cautionary tales to guide fellow developers navigating similar paths.

Note: Many of the lessons shared here are particularly relevant for startups embarking on developing a new product with two or more engineering product teams operating concurrently.

Strategies for Success in B2B SaaS Development

Dive into proven methods and techniques, ensuring clarity and efficiency, that have effectively driven our project forward.

Keep Processes Clear and Simple

Git Workflows

It might seem trivial, but when you have a lot of people working together, a well-defined git workflow is a must. You can think of different workflows for regular releases, hotfixes, long-standing features, and multi-service impacting code changes.

It is in everyone’s interest not to spend significant time just debugging through the mess of merge conflicts.

Collaboration Guidelines

When you have multiple independent teams working on the same product, you will often find that you have cross-service features. All of your regular processes on sprint releases or testing will go haywire because Team 1 and Team 2 may not be on the same page about everything.

To streamline this:

• Clarify roles: Define clear responsibilities and ownership for each team for every large cross-service feature. Designate one senior engineer to oversee this launch regardless of which team they work in
• Sync regularly: Implement synchronized sprints and testing schedules to keep all teams aligned.
• Set intermediate checkpoints: Establish regular checkpoints like internal releases to ensure teams are on track and cohesive.

Code Writing Patterns and Styles

A consistent writing style will make your life easier by saving a lot of time in code reviews, bug fixes, and enhancements. More importantly, when new members join the team — they will find it simple to understand different parts of your codebase.

Identify Central Components Early On

UI Design Library

Adopting a common UI library is going to save a huge amount of time, especially if you are working in a monorepo. You may even choose to develop one for your organization — that is also a justified investment if you’re not using any available libraries.

One thing to ensure here would be that your product and design folks are also using the same language and are aligned with your decision.

Common Services & Utility SDKs

Similar to the UI design, you will also run into many ‘common & solved problems’ in your product development. Set up single/multiple services for commonly required stuff such as notifications, authentication, error tracking, and boilerplate code.

You may even find open-source projects that fulfill these needs for you.

Set Non-functional Goals Correctly

Flexibility

When you begin developing a new product from scratch, it is not going to be immediately clear what ‘exactly needs to be built.’ While it is easy to just blame it on bad product management, you must understand that this is the nature of the game. It is going to take a while (from months to years) to achieve full clarity.

Encourage your team members to actively learn and apply design patterns that promote extensibility — -this goes from class/functional programming to database design.

Performance and Scaling

As you start getting real customers (and real data), you will get the true data sizes on which the system is supposed to work. Closer to this date, you can switch your extensibility mode to performance and scaling.

Navigating Common Pitfalls

Too Many Microservices

Difficulty in Delivery

When you have multiple services in orchestration to deliver a single product — they are bound to have some coupling in the beginning. There would be many cross-service features that lead to services being dependent on each other.

You may slowly iron out these things by introducing interfaces or mocks for local development, but till the time you do this — it is going to be painful to manage many things together. Start with as minimal as possible and slowly split your codebase to individual services — do not fall into the trap of microservices in the early stage.

Team Boundaries

As you are on the journey of discovering PMF — you will find that your backend services and their boundaries keep evolving. You will have to accommodate that by also evolving your team structures.

Automated environment setup

With many services and team members — manually setting up environments whether for local development or testing a UAT platform, is very painful. Find out the effort estimate for automating it, and you will realize that it pays off very quickly.

Experimentation

Reduced Velocity

Running around multiple technical stacks in the early stages can lead to slowdowns. Moreover, teams will not be able to benefit from learning and patterns used by each other.

Release on Schedule

Working in a fast-paced workplace means there will be times when things don’t go according to plan. Despite the possibility that the scope will need to change, make an effort to guarantee that releases occur on the scheduled date.

Although it may seem paradoxical, putting this approach into practice helps the team in better feature planning and selection between “must haves” and “good to haves.”

Additionally, it maintains the team’s momentum and high level of motivation.

Conclusion

A combination of strategic insight, rigorous execution, and adaptive resilience is needed to navigate the challenging terrain of B2B SaaS development. By adopting best practices and learning from our mistakes, we keep improving the way we’re developing Accelerate.

We invite other developers and business owners to use these insights to further their pursuit of product-market fit, which will guarantee long-term development and innovation in the ever-evolving field of enterprise software.