Take first look at PocketBase, a new backend platform using the Go programming language and SQLite database that compiles to a single executable. It is a lightweight alternative to tools like Firebase and Supabase for easy backend development.

#programming #firstlook #TheCodeReport

🔗 Resources

- PocketBase Github https://github.com/pocketbase/pocketbase
- Pocketbase HomePage https://pocketbase.io/
- Firebase Alt Video https://youtu.be/SXmYUalHyYk
- Edge Functions Video https://youtu.be/yOP5-3_WFus

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- What is PocketBase?
- Pocketbase vs Supabase
- Pocketbase vs Firebase
- Is PocketBase production ready?
- How to choose a backend for an app?
2024-02-04T13:32:24.790Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
c4d994dc-bfbc-46f5-9459-c11392ce7663
b926fcaa255a305b025927eb5c3b4892e8159fe4e5c0ecdcdcf56c9803ccc3ca
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
It is September 13, 2022, and you're watching the code report.
Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base.
Well, I tried it out and it kinda blew my mind.
As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it.
At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software.
Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood.
And I think it has the potential to be the ultimate side project back end.
Let's go ahead and compare it to something like Supabase.
The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase.
That's mostly superficial, but things in Go do tend to be faster.
It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular.
That's totally meaningless, but just kind of interesting.
For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile.
What's really interesting about Pocketbase though is the database.
Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging.
My initial thought was you can't use SQLite in production, but actually That's a misconception.
SQLite is an underappreciated option for small to medium sized projects.
Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app.
And I'm sure it'll work perfectly fine for your side project that's destined to fail.
But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale?
Because the database is embedded into the runtime itself, it can only scale vertically.
This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines.
When scaling vertically, the only way to handle more traffic is to use a bigger uter.
As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long.
Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment.
In any case, scaling Vertically, it will work for 99% of apps out there.
Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point.
Pocketbase is entirely self hostable.
In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service.
And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose.
If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you.
What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy.
Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database.
In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions.
In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science.
I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch.
This has been the code report.
Thanks for watching, and I will see you in the next one.

Speaker 0: It is September 13, 2022, and you're watching the code report. Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base. Well, I tried it out and it kinda blew my mind. As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it. At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software.

Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood. And I think it has the potential to be the ultimate side project back end. Let's go ahead and compare it to something like Supabase. The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase. That's mostly superficial, but things in Go do tend to be faster.

It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular. That's totally meaningless, but just kind of interesting. For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile. What's really interesting about Pocketbase though is the database. Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging.

My initial thought was you can't use SQLite in production, but actually That's a misconception. SQLite is an underappreciated option for small to medium sized projects. Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app. And I'm sure it'll work perfectly fine for your side project that's destined to fail. But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale?

Because the database is embedded into the runtime itself, it can only scale vertically. This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines. When scaling vertically, the only way to handle more traffic is to use a bigger uter. As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long. Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment.

In any case, scaling Vertically, it will work for 99% of apps out there. Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point. Pocketbase is entirely self hostable. In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service. And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose.

If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you. What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy. Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database. In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions. In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science.

I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch. This has been the code report. Thanks for watching, and I will see you in the next one.
It is September 13, 2022, and you're watching the code report. Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base. Well, I tried it out and it kinda blew my mind. As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it. At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software. Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood.
And I think it has the potential to be the ultimate side project back end. Let's go ahead and compare it to something like Supabase. The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase. That's mostly superficial, but things in Go do tend to be faster.
software
software development
It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular. That's totally meaningless, but just kind of interesting. For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile.
What's really interesting about Pocketbase though is the database. Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging. My initial thought was you can't use SQLite in production, but actually That's a misconception. SQLite is an underappreciated option for small to medium sized projects. Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app. And I'm sure it'll work perfectly fine for your side project that's destined to fail. But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale? Because the database is embedded into the runtime itself, it can only scale vertically.
databases
This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines. When scaling vertically, the only way to handle more traffic is to use a bigger uter. As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long. Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment. In any case, scaling Vertically, it will work for 99% of apps out there. Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point. Pocketbase is entirely self hostable. In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service. And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose. If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you. What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy. Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database.
In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions. In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science.
architecture
infrastructure
computer science
I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch. This has been the code report. Thanks for watching, and I will see you in the next one.
It is September 13, 2022, and you're watching the code report. Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base. Well, I tried it out and it kinda blew my mind. As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it. At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software. Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood. And I think it has the potential to be the ultimate side project back end. Let's go ahead and compare it to something like Supabase. The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase. That's mostly superficial, but things in Go do tend to be faster. It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular. That's totally meaningless, but just kind of interesting. For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile. What's really interesting about Pocketbase though is the database. Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging. My initial thought was you can't use SQLite in production, but actually That's a misconception. SQLite is an underappreciated option for small to medium sized projects. Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app. And I'm sure it'll work perfectly fine for your side project that's destined to fail. But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale? Because the database is embedded into the runtime itself, it can only scale vertically. This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines. When scaling vertically, the only way to handle more traffic is to use a bigger uter. As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long. Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment. In any case, scaling Vertically, it will work for 99% of apps out there. Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point. Pocketbase is entirely self hostable. In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service. And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose. If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you. What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy. Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database. In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions. In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science. I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch. This has been the code report. Thanks for watching, and I will see you in the next one.
It
it
is
is
September
september
13,
13
2022,
2022
and
and
you're
you're
watching
watching
the
the
code
code
report.
report
Last
last
Friday,
friday
I
i
made
made
a
a
video
video
about
about
Firebase
firebase
alternatives,
alternatives
and
and
you
you
guys
guys
were
were
quick
quick
to
to
let
let
me
me
know
know
that
that
I
i
left
left
out
out
a
a
very
very
important
important
project
project
called
called
Pocket
pocket
Base.
base
Well,
well
I
i
tried
tried
it
it
out
out
and
and
it
it
kinda
kinda
blew
blew
my
my
mind.
mind
As
as
soon
soon
as
as
I
i
landed
landed
on
on
the
the
home
home
page
page
and
and
saw
saw
this
this
cool
cool
proximity
proximity
hover
hover
effect
effect
where
where
the
the
eyes
eyes
follow
follow
your
your
cursor,
cursor
I
i
was
was
sold
sold
on
on
it.
it
At
at
first
first
glance,
glance
it
it
looks
looks
very
very
similar
similar
to
to
Supabase,
supabase
something
something
with
with
a
a
real
real
time
time
relational
relational
database,
database
authentication,
authentication
file
file
storage,
storage
and
and
so
so
on
on
that's
that's
built
built
entirely
entirely
with
with
open
open
source
source
software.
software
Unlike
unlike
the
the
godfather
godfather
Firebase,
firebase
which
which
requires
requires
proprietary
proprietary
Google
google
software,
software
it
it
looks
looks
like
like
other
other
bases
bases
at
at
first
first
glance,
glance
but
but
it's
it's
actually
actually
very
very
different
different
under
under
the
the
hood.
hood
And
and
I
i
think
think
it
it
has
has
the
the
potential
potential
to
to
be
be
the
the
ultimate
ultimate
side
side
project
project
back
back
end.
end
Let's
let's
go
go
ahead
ahead
and
and
compare
compare
it
it
to
to
something
something
like
like
Supabase.
supabase
The
the
first
first
thing
thing
you'll
you'll
notice
notice
is
is
that
that
it's
it's
written
written
in
in
the
the
Go
go
programming
programming
language
language
as
as
opposed
opposed
to
to
TypeScript
typescript
for
for
Supabase.
supabase
That's
that's
mostly
mostly
superficial,
superficial
but
but
things
things
in
in
Go
go
do
do
tend
tend
to
to
be
be
faster.
faster
It
it
also
also
uses
uses
Svelte
svelte
for
for
its
its
admin
admin
UI,
ui
while
while
Supabase
supabase
uses
uses
React
react
and
and
Firebase
firebase
uses
uses
Angular.
angular
That's
that's
totally
totally
meaningless,
meaningless
but
but
just
just
kind
kind
of
of
interesting.
interesting
For
for
client
client
side
side
SDKs,
sdks
it
it
supports
supports
JavaScript
javascript
and
and
Dart,
dart
which
which
means
means
it's
it's
usable
usable
on
on
web,
web
desktop
desktop
and
and
mobile.
mobile
What's
what's
really
really
interesting
interesting
about
about
Pocketbase
pocketbase
though
though
is
is
the
the
database.
database
Instead
instead
of
of
something
something
like
like
Postgres
postgres
or
or
MySQL,
mysql
it
it
directly
directly
embeds
embeds
SQLite
sqlite
into
into
the
the
executable
executable
able
able
and
and
runs
runs
it
it
in
in
wall
wall
mode,
mode
which
which
stands
stands
for
for
right
right
ahead
ahead
logging.
logging
My
my
initial
initial
thought
thought
was
was
you
you
can't
can't
use
use
SQLite
sqlite
in
in
production,
production
but
but
actually
actually
That's
that's
a
a
misconception.
misconception
SQLite
sqlite
is
is
an
an
underappreciated
underappreciated
option
option
for
for
small
small
to
to
medium
medium
sized
sized
projects.
projects
Surprisingly,
surprisingly
in
in
wall
wall
mode,
mode
it
it
actually
actually
outperforms
outperforms
other
other
relational
relational
databases,
databases
especially
especially
in
in
a
a
read
read
heavy
heavy
app.
app
And
and
I'm
i'm
sure
sure
it'll
it'll
work
work
perfectly
perfectly
fine
fine
for
for
your
your
side
side
project
project
that's
that's
destined
destined
to
to
fail.
fail
But
but
in
in
the
the
off
off
chance
chance
it
it
doesn't
doesn't
fail,
fail
you
you
might
might
be
be
wondering,
wondering
does
does
Pocket
pocket
Base
base
scale?
scale
Because
because
the
the
database
database
is
is
embedded
embedded
into
into
the
the
runtime
runtime
itself,
itself
it
it
can
can
only
only
scale
scale
vertically.
vertically
This
this
differs
differs
from
from
NoSQL
nosql
databases
databases
like
like
Firestore
firestore
that
that
use
use
sharding
sharding
in
in
to
to
scale
scale
horizontally
horizontally
to
to
an
an
infinite
infinite
number
number
of
of
machines.
machines
When
when
scaling
scaling
vertically,
vertically
the
the
only
only
way
way
to
to
handle
handle
more
more
traffic
traffic
is
is
to
to
use
use
a
a
bigger
bigger
uter.
uter
As
as
the
the
app
app
grows,
grows
you'll
you'll
need
need
to
to
add
add
more
more
CPU
cpu
and
and
more
more
RAM,
ram
but
but
you
you
can
can
only
only
do
do
that
that
for
for
so
so
long.
long
Like,
like
the
the
biggest
biggest
computer
computer
you
you
can
can
rent
rent
on
on
Ass
ass
has
has
a
a
128
128
CPU
cpu
cores
cores
and
and
about
about
2
2
terabytes
terabytes
of
of
RAM,
ram
and
and
the
the
rent
rent
is
is
about
about
the
the
same
same
as
as
a
a
Bay
bay
Area
area
studio
studio
apartment.
apartment
In
in
any
any
case,
case
scaling
scaling
Vertically,
vertically
it
it
will
will
work
work
for
for
99%
99%
of
of
apps
apps
out
out
there.
there
Pocketbase
pocketbase
can
can
easily
easily
handle
handle
tens
tens
of
of
thousands
thousands
of
of
concurrent
concurrent
real
real
time
time
connections
connections
on
on
a
a
single
single
$5
$5
VM
vm
on
on
Digital
digital
ocean
ocean
or
or
something
something
like
like
that,
that
which
which
brings
brings
me
me
to
to
the
the
next
next
point.
point
Pocketbase
pocketbase
is
is
entirely
entirely
self
self
hostable.
hostable
In
in
fact,
fact
you
you
have
have
to
to
self
self
host
host
it,
it
whereas
whereas
most
most
people
people
using
using
Supabase
supabase
are
are
using
using
its
its
fully
fully
managed,
managed
$25
$25
a
a
month
month
service.
service
And
and
it's
it's
also
also
been
been
criticized
criticized
for
for
being
being
extremely
extremely
difficult
difficult
to
to
self
self
host,
host
like
like
you've
you've
got
got
8
8
different
different
services
services
to
to
think
think
about
about
here
here
in
in
the
the
Docker
docker
Compose.
compose
If
if
anybody
anybody
here
here
is
is
self
self
hosting
hosting
Supabase
supabase
in
in
production,
production
please
please
leave
leave
a
a
comment
comment
and
and
let
let
me
me
know
know
how
how
it
it
went
went
for
for
you.
you
What's
what's
really
really
unique
unique
about
about
Pocket
pocket
Base
base
is
is
that
that
it
it
results
results
in
in
a
a
single
single
executable,
executable
which
which
makes
makes
it
it
very
very
simple
simple
to
to
deploy.
deploy
Another
another
important
important
difference
difference
is
is
that
that
when
when
it
it
comes
comes
to
to
back
back
end
end
code,
code
you
you
can
can
just
just
extend
extend
the
the
framework
framework
directly
directly
with
with
Go,
go
then
then
that
that
code
code
will
will
right
right
there
there
in
in
the
the
executable
executable
right
right
next
next
to
to
your
your
database.
database
In
in
other
other
words,
words
you
you
build
build
a
a
monolith
monolith
as
as
opposed
opposed
to
to
a
a
bunch
bunch
of
of
different
different
microservices
microservices
that
that
run
run
on
on
fancy
fancy
edge
edge
functions.
functions
In
in
fact,
fact
an
an
architecture
architecture
like
like
this
this
This
this
tends
tends
to
to
be
be
faster
faster
than
than
the
the
edge
edge
when
when
data
data
fetching
fetching
is
is
involved,
involved
as
as
I
i
proved
proved
in
in
this
this
video
video
with
with
Flat
flat
Earth
earth
Science.
science
I
i
think
think
the
the
bottom
bottom
line
line
here
here
is
is
that
that
Pocket
pocket
Base
base
is
is
like
like
a
a
lightweight
lightweight
Supabase
supabase
alternative,
alternative
which
which
itself
itself
is
is
the
the
open
open
source
source
Firebase
firebase
alternative,
alternative
which
which
itself
itself
is
is
the
the
alternative
alternative
to
to
building
building
your
your
own
own
back
back
end
end
from
from
scratch.
scratch
This
this
has
has
been
been
the
the
code
code
report.
report
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker discusses their experience with the popular popular popular hardware-based back end, called Pocket Base. The back end is written in Go programming and is faster, scalable, and has a single executable. The speaker also explains that Cloudflake is a lightweight version of Pocket Base, and that it is a more affordable choice for developers.
PocketBase... The Ultimate Side-Hustle Backend?
It is September 13, 2022, and you're watching the code report. Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base. Well, I tried it out and it kinda blew my mind. As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it. At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software. Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood. And I think it has the potential to be the ultimate side project back end. Let's go ahead and compare it to something like Supabase. The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase. That's mostly superficial, but things in Go do tend to be faster. It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular. That's totally meaningless, but just kind of interesting. For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile. What's really interesting about Pocketbase though is the database. Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging. My initial thought was you can't use SQLite in production, but actually That's a misconception. SQLite is an underappreciated option for small to medium sized projects. Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app. And I'm sure it'll work perfectly fine for your side project that's destined to fail. But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale? Because the database is embedded into the runtime itself, it can only scale vertically. This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines. When scaling vertically, the only way to handle more traffic is to use a bigger uter. As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long. Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment. In any case, scaling Vertically, it will work for 99% of apps out there. Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point. Pocketbase is entirely self hostable. In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service. And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose. If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you. What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy. Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database. In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions. In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science. I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch. This has been the code report. Thanks for watching, and I will see you in the next one.
The speaker discusses their experience with the popular popular popular hardware-based back end, called Pocket Base. The back end is written in Go programming and is faster, scalable, and has a single executable. The speaker also explains that Cloudflake is a lightweight version of Pocket Base, and that it is a more affordable choice for developers.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : PocketBase... The Ultimate Side-Hustle Backend? 
        and a small summary : The speaker discusses their experience with the popular popular popular hardware-based back end, called Pocket Base. The back end is written in Go programming and is faster, scalable, and has a single executable. The speaker also explains that Cloudflake is a lightweight version of Pocket Base, and that it is a more affordable choice for developers.
        [/INST]
        
        Generate the video : It is September 13, 2022, and you're watching the code report. Last Friday, I made a video about Firebase alternatives, and you guys were quick to let me know that I left out a very important project called Pocket Base. Well, I tried it out and it kinda blew my mind. As soon as I landed on the home page and saw this cool proximity hover effect where the eyes follow your cursor, I was sold on it. At first glance, it looks very similar to Supabase, something with a real time relational database, authentication, file storage, and so on that's built entirely with open source software. Unlike the godfather Firebase, which requires proprietary Google software, it looks like other bases at first glance, but it's actually very different under the hood. And I think it has the potential to be the ultimate side project back end. Let's go ahead and compare it to something like Supabase. The first thing you'll notice is that it's written in the Go programming language as opposed to TypeScript for Supabase. That's mostly superficial, but things in Go do tend to be faster. It also uses Svelte for its admin UI, while Supabase uses React and Firebase uses Angular. That's totally meaningless, but just kind of interesting. For client side SDKs, it supports JavaScript and Dart, which means it's usable on web, desktop and mobile. What's really interesting about Pocketbase though is the database. Instead of something like Postgres or MySQL, it directly embeds SQLite into the executable able and runs it in wall mode, which stands for right ahead logging. My initial thought was you can't use SQLite in production, but actually That's a misconception. SQLite is an underappreciated option for small to medium sized projects. Surprisingly, in wall mode, it actually outperforms other relational databases, especially in a read heavy app. And I'm sure it'll work perfectly fine for your side project that's destined to fail. But in the off chance it doesn't fail, you might be wondering, does Pocket Base scale? Because the database is embedded into the runtime itself, it can only scale vertically. This differs from NoSQL databases like Firestore that use sharding in to scale horizontally to an infinite number of machines. When scaling vertically, the only way to handle more traffic is to use a bigger uter. As the app grows, you'll need to add more CPU and more RAM, but you can only do that for so long. Like, the biggest computer you can rent on Ass has a 128 CPU cores and about 2 terabytes of RAM, and the rent is about the same as a Bay Area studio apartment. In any case, scaling Vertically, it will work for 99% of apps out there. Pocketbase can easily handle tens of thousands of concurrent real time connections on a single $5 VM on Digital ocean or something like that, which brings me to the next point. Pocketbase is entirely self hostable. In fact, you have to self host it, whereas most people using Supabase are using its fully managed, $25 a month service. And it's also been criticized for being extremely difficult to self host, like you've got 8 different services to think about here in the Docker Compose. If anybody here is self hosting Supabase in production, please leave a comment and let me know how it went for you. What's really unique about Pocket Base is that it results in a single executable, which makes it very simple to deploy. Another important difference is that when it comes to back end code, you can just extend the framework directly with Go, then that code will right there in the executable right next to your database. In other words, you build a monolith as opposed to a bunch of different microservices that run on fancy edge functions. In fact, an architecture like this This tends to be faster than the edge when data fetching is involved, as I proved in this video with Flat Earth Science. I think the bottom line here is that Pocket Base is like a lightweight Supabase alternative, which itself is the open source Firebase alternative, which itself is the alternative to building your own back end from scratch. This has been the code report. Thanks for watching, and I will see you in the next one.
        