MVP Development

Developer sitting behind a laptop, writing code

What is a MVP?

A minimum viable product (MVP) has just enough core features to effectively deploy the product, and no more. Developers typically deploy the product to a subset of possible customers, such as early adopters who are thought to be more forgiving, more likely to give feedback, and able to grasp a product vision from an early prototype or marketing information. This strategy aims to avoid building products that customers do not want and seeks to maximize information about the customer with the least money spent. (Wikipedia)

How we build MVP's

When building an MVP it's not only important to keep thins as simple as possible, but also to build the application in such a way that it can be easily expanded as needed without significant refactoring. The last thing that early stage startups need is having to burn through much needed funds debugging and rewriting a tightly coupled codebase or spending a lot of time writing custom authentication logic. It's critical for early stage startups to devote the bulk of their available resources to implementing one or two core features that are bug free.

It's also very important to write an MVP codebase in such a way that it will be extensible so that new features can be added or old ones removed with minimal effort as it's a 100% guaranteed fact that requirements will change, especially at the early stages. At Terabyte Labs we've developed a MVP blueprint that can be applied to almost any kind of startup imaginable using three core technologies; Nuxt, PocketBase and Golang


After finalizing the specifications and establishing the an application architecture, the first work that we do is to set up staging and production environments along with CI/CD pipelines for the application. This allows us to make continuous changes that will automatically be deployed to the relavant environment. This is a critical step and once it's been setup, will allow us to rapidly deploy any new features or improvements as required.

CI/CD pipeline
Nuxt frontend


The frontend is what users will see when they interact with your application. There are a large number of frontend frameworks available today and at Terabyte Labs we've chosen the Nuxt framework for Vue. Nuxt allows us to build any type of application and most importantly, it's easy to adopt and maintain for new developers that may join the team at a later stage.


We've chosen PocketBase as backend solution for our MVP blueprint. PocketBase is an extendable open sourse backend solution written in Golang with the following built-in features as a starting point:

  • Realtime database
  • Authentication
  • File storage
  • Admin dashboard

Having these features already in place allows us to immediately save several weeks of development time and most importantly, avoids re-implementing the sabe abblication building blocs over and over again for each MVP that we build and we can optimise our development time to focus on the most important part of your MVP; implementing features!

PocketBase can either be used as is for simple use cases OR as a Golang framework for MVP's that will focus on a niche market requiring custom functionality. Doing this allows us to rapidly build almost any type application imaginable.

What type applications do we build?

When we build an MVP we technically start out with a blank sheet and can therefore build virtually any type of application ranging from very simple to complex systems.

The fact that we are able to make advanced use of PocketBase and use it as a framework means that we have very few limitations with regards to what we can build.

  • SaaS Applications
  • Online booking systems
  • Data extraction and transformation (ETL software)
  • Logistics software
  • Online directories
  • IoT Software (and hardware)
  • Manufacturing and inventory systems
  • etc...