Thronmax MDrill One Pro & USB Video:
Hey folks, and welcome to the small
tech podcast from Ephemere Creative.
Today we're going to be talking
about choosing a tech stack.
If you enjoy the work that we do, we'd
really appreciate it if you hit that like,
and subscribe button on YouTube, or if you
subscribe in your podcast app of choice.
We're a tiny team and
every little bit helps.
First let's ask the question.
What is a tech stack?
A lot of you might already know but
for people who haven't been involved
in this kind of stuff before, it's
normal to not know what that means.
Essentially, almost every
technical system has multiple
layers built on top of each other.
And you put those things together
to create like a functioning stack.
That is how all of your systems, how
your application, how your business
processes and other stuff work.
So a lot of the time, we'll talk
about a tech stack in the context of
what I'll call an application stack.
So specifically what you need to have
a functioning mobile app or a web app
or website or something like that.
But you'll also hear the term
used with reference to a marketing
stack or an operational stack.
And that's because even outside of the
strict bounds of building software, you're
still layering technologies on top of
each other to get your marketing work
done and to structure your operations.
But in the context of
a small tech business.
Those things, all meshed together.
You're going to build your application
in a way that it integrates with
your marketing tools and you
want your operations to be tied
into your application as well.
But today for simplicity sake, we're
going to focus on the application side.
So are we talking about choosing a
tech stack or building a tech stack?
There are some tech stacks
that are off the shelf.
you might've heard of things
like the LAMP stack or you
might've heard of MERN and MEAN.
But by and large one way or another,
even if you use a commonly referred
to stack like MERN, MEAN or LAMP,
you're going to be setting up each of
the components independently and you
will need to make other choices about
what goes into your stack and how you
get it up and running in production.
So you might ask yourself at this point,
does this question really makes sense?
Are we choosing a tech stack?
Well, just sort of our you're
choosing the components.
You are building it, but I think the
questions that you have to ask yourself
when you choose each of the components,
could be asked about the stack itself.
You don't want to just choose
your components in isolation.
You are choosing these as part of a whole.
So with that in mind, I want to
go over some of the questions
that we ask ourselves when we're
choosing components in a stack.
So my top priority personally
is who is going to work on this,
who is going to work with it.
And what are their needs
and their preferences.
I'm talking primarily from an engineering
perspective here, but you'll also want
to think about other people who interact
with the stack in different ways, not
just the people who are coding against it.
So you might want to choose a component
because it's easy for someone who's
non-technical to log in and interact
with it, maybe to download backups and
get some data off of it for example.
You also need to think about what
is your infrastructure budget?
There are certain things that
cost more than others to run
for a variety of reasons.
And you need to take that into account
when you're making that choice.
You also need to think about
what your maintenance budget is.
There are things that could be components
of your tech stack that require updates.
And with each update,
you'll need to make changes.
You'll need to make sure that
everything is working properly together.
Some things are more complex
to manage than others.
So you need to be aware of those
types of things, and you need to
be aware of the resources that
are available for maintenance
when you make that type of choice.
You also need to think about legal
requirements in some cases that might be
around licensing, but in other cases it
might be about things like data residency.
Are you able to deploy your stack to an
infrastructure provider that runs in the
country where your data needs to live.
If not, you can't use it.
A specific example of that, that I can
think of is a project where we were
considering using Firebase because
it would have been very easy for us
to get off the ground, but the data
had to stay in Canada and Firebase
doesn't run Canadian data centers
so we had to choose an alternative.
We ended up going with Supabase.
You should also think about
There are certain types of things that
you're going to build that require
really fast, high-performing tools.
But often things that are,
high-performing also require more
time and expertise to work with.
So you might need to hire a
much more expensive developer
to work on for example, a tool
that processes video on the fly.
I also find it really important to
consider your growth projections.
You don't want to, over-engineer
a system and choose tools that are
really complicated to mesh together
if you're probably only going to have
a hundred users on an app that won't
really need more than one server.
Conversely though, you also don't want
to find yourself in a situation where
you've used tools that limit your growth.
You want to understand that trajectory
and choose the tools that are going
to serve that trajectory best.
Ideally, of course you use
tools that can do both well.
That don't cost a lot to run at the
beginning and can serve your hundred
users on a single machine well, but
also can scale to hundreds of thousands.
Of course scaling is going to require
engineering one way or another.
But you can choose tools that
allow you to take on that
process more easily than others.
So we've talked about the different
questions that we like to ask when we
think about building a tech stack, and I'm
going to give you a practical example of
how we've done this in the past, sort of.
By plugging our very own
project, the Chewy Stack.
So we've been developing the Chewy Stack
over many years essentially by taking
our learnings from different projects
and finding commonalities and piecing
together a stack that made sense for
us to do our work and to work with
the types of clients that we take on.
We wanted to unify all these different
tools and processes into a single coherent
stack that we could reuse and optimize.
So I'll go over the different questions
and give you a quick breakdown of our
answers in the context of the Chewy Stack.
So who needs to work with it?
By and large, the focus was making sure
and node JS could hop into it pretty
easily, while giving them guardrails
to help them write good code.
The infrastructure budget for
our clients varies quite a bit.
But we wanted to use a baseline of around
$20 a month for the smallest projects.
Considering the maintenance
budget is also important.
We have some clients who have a longterm
maintenance budget, but others don't.
So they need to be able to run
the app until we work with them
next without having to make any
changes or run into any problems?
Like I mentioned before data, residency is
a thing we've worked with multiple clients
who need to keep their data in Canada.
And we know that this
exists all over the world.
There are plenty of reasons that
your data might need to stay in the
country that you're operating in.
So for us, it was important that
the Chewy Stack be able to do that.
You should be able to run it on
infrastructure that runs in your country.
Most of our clients don't actually have
any strict performance requirements.
Of course, there's a user
Things need to be snappy on the user
end, but we generally don't have
any projects that require heavy data
processing or anything along those lines.
We did build things so that you can take
care of that sort of task asynchronously.
And so that you could integrate with
other tooling if you wanted to, but
out of the box, it's not really a
concern that we've run into very often.
So what about growth projections?
I think everyone has a dream of
growing their app to serve hundreds
of thousands or millions of people.
But generally the clients
that we've worked with, the
projects that we've worked on.
I have a good understanding
of their initial scale and
how it'll move from there.
And while we've built things so
that it can grow significantly.
It also is easy to work with at a
small scale and deploy in that context.
So those are some of the things
you might want to think about.
You might choose a particular
database like my SQL or PostgreSQL.
Uh, because you have relational
data that makes a lot of sense
to put in a database like that.
Or you might use a no SQL database like
Mongo, because you need to scale to
huge numbers very quickly and Mongo
might make it easier to do that.
Or maybe you need to be able to handle
lots of things happening at the same time
and Go, or Erlang might make it a lot
easier to handle those types of processes.
Anyway, those are some
thoughts, I hope it helped.
If you enjoy this stuff, please
like, and subscribe on YouTube.
Subscribe to the podcast
in your app of choice.
And please leave us a review.
We'd love to hear what you think.
And also we'd love to
have you on the podcast.
If you're building a small tech
product, come chat with me.
Let's talk about your tech stack,
or maybe let's talk about how
you've approached different
hurdles as you build your company.
Also sign up for our newsletter.
We'll be sending out tons of great stuff
about how to build small tech products.
Everything from videos, blog posts,
podcast, episodes that you may have
missed and plenty of other stuff.
Go to smalltechpodcast.com and click
the newsletter button in the nav bar.
And that will take you to the right spot.
So that's it for this week's
episode, we all want to do
something good in the world.
So go out there and build
something good folks.