How To: Build an Engineering SaaS Stack

Name Katie Mulligan Director of Platform at Pillar VC

So, you have a business idea. Before you can start writing any code, you’ll first need to figure out what software tools and programming languages you’ll use to power your business.

We caught up with Eli Daniel from Jellyfish,  a platform to help engineering teams leverage insights from Jira and GitHub to maintain high performing engineering teams, to chat about how to build your engineering SaaS stack. 

Get Your Team in Place

For many businesses, you will already have a technical co-founder. But if you don’t, or are just starting to toy around with business ideas, consider hiring a dev shop or consultancy to help build a V1 prototype of your product. While not the durable answer, it can help you start to wrap your head around the major engineering considerations that will need to be made down the line. 

It’s important to have someone on the team that understands how to think about the engineering tradeoffs. Differences that seem small on the outside, might be tremendous from the inside. Making sloppy decisions now could equal big consequences down the line. 

A good balance between a business and technical mind can help make sure you have the right tech to support your company vision. 

Getting Started

Before you start signing up for engineering tools, make sure your team is aligned on two things: 


The product you are building today


Where you might want your product to expand in the future

Use some of the following questions to help guide your thinking:

  • What are you building?
    • Where is your program going to run? Is it a single, centralized piece of software? Is it an app that you are distributing to people? Are you deploying software on hardware devices?
  • How many people does your product need to support?
    • What is the scale? A few hundred people in an organization? Hundreds of thousands on a website?
  • How often are you releasing changes to your product?
    • Do you have full control? If you’re distributing your software, do people only update when they want to?
  • How is the regulatory environment for your product?
    • Does your software have to pass approval and get certified?
  • Are there any technology constraints?
    • Is your software deployed to a physical device? A Website?

While seemingly simple, the answers to these questions will greatly impact some of your tech stack decisions — you want to make sure that your product can be properly supported as it scales. 

The SaaS Stack Decisions

Once you’ve aligned on the key tenets of your software, you’ll need to begin building your tech stack.

1. Hosting

One of the most important SaaS stack decisions you will make is also one of the first. Where will your software be hosted and run? While many companies might jump directly to AWS, it is worth putting some additional thought into your decision. 

The key variable that determines what hosting environment will be best for you depends on how many moving parts your software will have. If your software will have many moving parts, AWS may be a great answer. AWS offers a wide range of services, and can get more sophisticated as your company scales. Google Cloud and Azure also fall into this category.

If you’re building a prototype with less moving parts, want to get something up quickly, or are keeping cost in mind, a system like Heroku may be the better answer

2. Programming Languages

Determining a programming language is next. Python is one of the more popular options for B2B companies, as the ecosystem is strong, and it has good support for everything from web applications to deep machine learning. 

Python isn’t the only answer, and it will really depend on what you’re building. If you’re trying to build a B2C business, for example, you’ll have harder choices to make. The high volume of users means there is a lot more engineering needed to make sure set-up, tuning and configuration are all running smoothly.

Most importantly, though, don’t over-engineer it. Start by using whatever language you are familiar with, and use that as a jumping off point. It is much easier to create a well-built system using a language you know vs. one you are trying to learn! 

3. Storing Your Code

It may seem like overkill in the early days, but make sure to invest in your code deploying process early. Rapid experimentation is key for many engineering teams, so make it easy for yourself to push out software effortlessly. 

The two key questions to answer in this section are 1) where does the code live, and 2) then, where does it go?

GitHub is one of the more popular code storage tools, and the market leader in the category. Another up-and-coming tool for code storage is GitLab. GitLab is specifically great for it’s built in continuous integration feature (see #4). 

Once the code is written and in storage, it needs somewhere to go. Docker is a tool that allows you to build software that can run in different places. Meaning you only have to build your product once, and it can run the same way everywhere, making it much easier to push out. 

Amazon Fargate is another tool that allows you to run a docker container without having to manage physical instances and machines.  

4. Continuous Integration / Continuous Deployment (CI/CD)

Once your initial code is deployed, you’ll likely want to make continuous updates to your product. 

Tools such as CircleCI integrate into your code storage tools (GitHub, GitLab, BitBucket, etc.) to automate code deployments for you. Once you commit code, CircleCI will test the software for you, and automatically push the changes through to production.

If you chose GitLab in step number 3, this process is automatically built into your code storage. 

This creates an easy and repeatable process for deploying code, allowing your team to work faster.

5. Monitoring & Analytics

Once your product is up and running, you’ll want to keep an eye on it. Not only will you want to make sure there are no bugs, but you’ll also want to be able to relay back to your team where users are interacting with your software. 

Check out our list of approved software tools for some of the following use cases:

  • Monitoring: Is my app up?
  • Error monitoring: Find out when users hit problems with your software
  • APM: Find what parts of your app have performance problems and diagnose why
  • Alerting: There’s a problem, alert someone!
  • User analytics: Find out who’s doing what with your software
  • Feature Flagging: Live configuration of which users get which features, staged rollout, kill switches if something breaks

A Word to the Wise

You won’t get your software right on the first try, so don’t expect to. It’s going to be a wavy path, and you will make lots of wrong turns. Don’t be afraid to experiment, move fast and break things! Iteration is part of the process. And luckily, many of the tools in an engineering SaaS stack are not terribly painful to switch if you find you chose the wrong one. Just make sure you have your hosting and programming language set in stone from Day 1, and you’ll be good to go. 

Ready to start building your engineering SaaS stack? Check out our list of approved software.