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
DevOps
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.
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.
Backend
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.
