002 - We Have a Name

Jonathan and Caleb decide on a name for the first product.

Show Notes

Jonathan and Caleb discuss ideas for a name for the product and some of the technical details of how it is built.

[00:48] We may have a name
[03:02] Update on progress so far
[04:34] How are we deploying this product
[07:31] Trying out some new tech and how much time did it take
[09:40] How much data can we share in the open
[11:36] We could always pivot to something else
[13:12] What's next
[18:17] What kind of music plays in our club

Newsletter: factory.twostoryrobot.com
Twitter: @twostoryrobot

Creators & Guests

Host

Caleb Sharp

Full-stack developer at Two Story Robot

Host

Jonathan Bowers (he/him)

Founder of Two Story Robot. Developer turned entrepreneur.

What is The Robot Factory?

Follow along as we attempt to build and sell a SaaS company. A build in public behind the scenes journey of a small software agency, Two Story Robot, trying something new.

Jonathan: So this morning I took
Zach to school and he likes me to

count down for him before I hand
him off to the daycare worker.

And, uh, but

Caleb: from what.

Jonathan: I usually count
up or sometimes count down,

so I started counting and then his
two little friends came over and I

normally count to five, but I kept
going and they were laughing at

me and I kept increasing pitch.

And so by the time I got to 20, it was
like as high as I could possibly squeal.

And they thought it was so funny,
they're all laughing, their butts off.

It was awesome.

Caleb: that's funny.

Jonathan: Welcome back to the
The Robot Factory podcast.

I am your host, Jonathan Bowers,
and with me as always, at the

immediate future is Caleb Sharp.

Caleb: Hi.

Yep.

Always here always will be.

Jonathan: You just stuck
in this little box.

So what's going on?

How did progress go this week on

real, realtor image thingy?

Caleb: realtor image thingy.

I can't remember.

So it's either realtor image, thingy,
real estate thing, real estate image.

Realtor image, gen

Jonathan: Oh,

Caleb: what I'm calling it.

So every time I need to remember
the name for like a Docker image or

like naming the project somewhere,
I'm using a different name.

So it's

getting

Jonathan: should probably, yeah,
we should come up with a name

that, needs to be somebody's job,
but I don't want it to be mine.

So I'm going to make it.

Caleb: Well, I was looking at, at domains.

I was like, oh, you know, be
cool OpenHouse.io, but that's

Jonathan: That's clearly
taken that has to be taken,

We could do something

like OpenHouse.Party,

Caleb: I think I looked and I
think, I think it was missing

most of the top level domains.

Jonathan: Can't be reached.

Let's see

Caleb: Well, that doesn't mean
that doesn't mean someone's

not squatting on it though.

Jonathan: Uh, it's premium.

Uh, all

right.

Caleb: OpenHouse.social
is $8 a year, apparently,

Jonathan: Oh, that's actually not bad.

Caleb: but then it's $35.

Jonathan: That's fine.

Okay.

OpenHouse.social Let's think about it.

We definitely have to think
about it before releasing

this episode before buying it.

So

Caleb: that's a

Jonathan: let's think about that.

OpenHouse.social

let's.

Uh, let's think on that.

I like it.

I like it.

I

like it.

Caleb: social.

Jonathan: Yup.

Caleb: The top level domains
that are longer than three

characters kind of scare me though.

I worry that people will
just immediately assume that

they're like some kind of scam.

Jonathan: It's some kind of scam,
I think as long as we put enough

flavorful conf like decorations
on the site, people will realize

Caleb: Confetti.

Where are you going to say confetti?

Yeah, they load up the
site in this confetti.

You want a free iPhone 10?

Jonathan: uh,

Caleb: that'll work.

Jonathan: but like real confetti,
like the confetti that is.

G GL powered like, web confetti, not, not

Caleb: accelerated,

Jonathan: not, not confetti.

That's just clearly an animated GIF

Caleb: right, right.

Jonathan: anyways.

Okay.

OpenHouse.Social.

Let's

think about that.

So what did you do?

How, how did, how did the week go?

Caleb: So I think I worked on it
yesterday and today a little bit.

I ran into a bunch of issues
with deploying it, so I kind of

had to switch up everything and
go a different direction, but

it seems to all be working now.

So there is, there's like
a live version of the site.

It still looks super ugly.

I didn't get around to doing that yet.

Cause I figured that was maybe not
as important as making sure I could

get it running somewhere, but.

Jonathan: Secondary.

I mean, because the way it, the way it is,
I haven't, I haven't clicked to look at

it cause he just literally deployed this
like a half an hour ago and we meeting.

I haven't had chance to look at it, but
I think it's probably enough that we can

go and chat with some of our friends who
maybe, maybe that, not that they don't

care about the way it looks, but can
look past that to give us some feedback.

Caleb: Yeah.

I, I think that UI could be
kept mostly as ugly as it is.

I still think some of the
core functional stuff...

I think so one of them is, I
think the image is outputting

is that like a fixed resolution.

It's like 2000 by 1000 or something,
which isn't, I mean, it makes the image.

That's also really ugly still.

I haven't updated that.

Jonathan: The image itself
that it outputs is ugly

Caleb: yes.

Jonathan: and styled.

Maybe we should say

Caleb: Yeah.

I mean, it is styled.

It's just styled in like the, I just
like quickly just to like position stuff.

Yeah.

But yeah, I don't know.

It might still get the core idea
or what it's going to do across,

Jonathan: You've got it running and live.

Without getting into too many
of the technical details.

Cause I don't know that
we want to bore everyone.

Why did we deploy it?

How are we doing this?

How is it, how is it being deployed
and why did we do it that way?

Caleb: I don't know how to explain that
without going into technical details.

That's a very technical

Jonathan: Descend into the
technical details a little bit.

Caleb: Okay.

Okay.

So originally it was deployed
on AWS Lambda, basically.

not super relevant, but the important part
is there's a hard limit on the size that

like the code you upload can be to lambda.

And because we're including Chrome,
which I talked about last episode on

the podcast the size of the code that
we were trying to deploy to Lambda was.

250 kilobytes, bigger than the size limit
on the function, the limit's 50 megabytes.

And it was 50.25 megabytes.

And I was like, maybe I could
optimize the size, but it just feels

like we're going to be so close
to that ceiling that there's not

going to be a lot of wiggle room.

So I just deployed it elsewhere
in a slightly different way.

And it seems to be working It
might end up being more expensive.

It might not have been less expensive
cause we might fit within a free tier.

I don't actually know.

Jonathan: Yeah.

The one, the one we're using
right now is called fly.io.

F L Y like fly on

the wall dot IO.

And they let us deploy much bigger things.

I guess a little bit more flexibility
in that way, because we can just

pack a bunch of more stuff in the,
in the thing that we're deploying.

Yeah, but it's also, it's also, I
think something that is a little bit

easier to transfer to someone else.

Not that the way we were doing
it previously was going to be

hard to transfer to someone else.

The restriction there was that size
limit, as you said, but our, because

our goal is to try and ideally have
this thing be acquired by someone.

We want to make it really easy.

Like not to have it too tangled up in our
existing infrastructure and other stuff.

So we're going to try and
build it in a way that.

Much more easily transfer it, transfer
ownership of it to someone else

Caleb: Yeah.

Jonathan: without like,
without disrupting anything.

I mean, hopefully it's massive
and there's so much traffic

that we have to worry about it.

But we don't want it to be a, like a

big, a big ordeal.

Caleb: yeah.

The way it is now is the whole is
packaged up into a Docker container, so

it can basically be deployed anywhere
and it's super easy to move around.

Jonathan: Do we have a database for
it yet at the back on the backend.

Caleb: Technically yes, it's using
a Postgres database to store user

information cause it has logins,
but it's not actually, it's not

storing anything other than that.

that's, that's all through Supabase,
which is, uh, which is another service.

Um, but supposedly they provide fairly.

Well, they actually, don't say they say,
if you need to transfer to send them

a message and they'll help you do it.

So I'm assuming it's
pretty straightforward.

But I think even if that doesn't work,
we can just like dump the database

and create a new project and just like
import the database and then it'll work.

And then just update API keys.

Jonathan: In some ways, this feels
like we are optimizing for a future

that feels very, very uncertain.

And maybe we shouldn't care that
much and we just need to figure

out if somebody wants this.

But it's not that hard.

And it's kind of fun to play around
with some of these new, some of

these new tools that we've never

tried.

Like Supabase is one

super fun

to say.

Caleb: Supabase

Jonathan: it's, it's

pretty cool.

Cause you, you, you.

You were able to work with
it really quickly, right?

Like it's, it's a pretty
slick set of technologies.

dabble around too much monkeying with
your own thing you could use, you could

do something that somebody else built.

Caleb: Yeah, it's pretty
similar to Firebase.

I think just less well less
Google and I think slightly

less proprietary kind of stuff.

It's all using Postgres.

But yeah, setting up
authentication was super quick.

They had like an example.

They even provide like an off the
shelf UI for like login and sign up

Jonathan: Oh, cool.

So we'd have

Caleb: buttons and texts and
puts, so just plop it in.

It's massive.

For some reason it's like 300 kilobytes,

Jonathan: Oh,

Caleb: it was, it was super
quick to set all that up.

I think the majority of that, that
the app took like a day to set up

Jonathan: Hm.

a data set up as in,
go from nothing to this

Caleb: It took like a day to do like
the whole front end and probably

a day to do the backend part.

And then the deployments
taken a little bit longer.

Cause maybe more exploratory.

Jonathan: So all told, you think

you're in two and a half to
three days worth of effort.

Caleb: yeah, I think counting
the effort that I put into it,

that was actually productive.

Yeah.

Jonathan: Okay.

Well, well, I mean, I don't know,
like if some of this effort is

looking around and deciding, oh
shoot, that's not going to work.

It's not like it was directly, it directly
resulted moving us forward, but it

it's still something that we had to do.

Like you still had to do that, do
that work and evaluate something.

So I think it's worth counting that time.

I think we should count that time.

So are you tracking, are you tracking
the time in our time tracker?

Caleb: It doesn't have a special
tag because I actually don't know

how to do that, but they should
all have the word real in it.

So if I can search by that,

It's, it's either going to be way
higher than I think, or it's going

to be way lower than I think.

Jonathan: That's some metrics that I
think would be fun to share, right?

Like how much time, how much
time have we spent on this thing?

Especially if we're going to
share, share the journey a

little bit and tweet about it.

I'm seeing a lot more of us revenue charts
that people like to share when they're

doing you know, building the open startup.

Some of them are encouragingly
small, like somebody, I just hit

$41 in monthly recurring revenue.

And that's awesome.

Like that's super exciting.

Both for them because they were
excited about it and it's revenue,

but also it doesn't feel intimidating.

It doesn't feel like, oh my God, we got
to try and get to a thousand dollars

in monthly recurring revenue before we
can start sharing any of this stuff.

No, he's got like three customers.

It's so cool.

Yeah.

So I want to share some of that stuff.

And I think, I think also
understanding what's going into it.

Might be helpful.

I don't know.

We'll see.

It's to go and add.

It's hard to go and collect
data after the fact.

It's easier to just, you know, anticipate
it, but we don't want to spend too much

time thinking about that kind of stuff.

We want to actually see
if this is going to work.

Caleb: Whether anybody pays us for it?

Jonathan: Yeah, it's fairly low risk.

We're not, we're not sinking a bunch
of time, a bunch of effort, and

it's not costing us any, like we're
not having to, like, we're using

free tiers for a bunch of things.

But I'm not, I'm not totally convinced.

I mean, I'm, I'm, I feel
like there's something here.

I dunno.

We'll see.

But one thing that I've learned cause
I'm at one of our other projects

we've done, uh, we've had a great
week of talking with customers and.

Wow.

There's always some
wonderful stuff to learn.

When you talk with actual customers,
I should say, on this project,

they're potential customers.

They're not customers yet.

But still the conversations have
been really, really helpful.

I'm excited to have something that I
can show to one friend in particular.

And maybe some more.

We'll see.

And just like, Hey, if we
make this look less terrible.

Is there value here?

Like w would you use this?

Yeah, that's cool.

Caleb: Yeah, I also, I wonder
maybe there's some like pivot

from this, that the application
is still basically the same thing,

but it's for a different purpose.

Jonathan: Okay.

Like what.

Caleb: I don't know, specifics, but
I feel like this ability to enter

in some information and generate
an image for like, social media,

certain size, I think could, could
be useful for other types of things.

Jonathan: Like events,
like we just had an event.

We have, uh, a small community group that
we organize in Kamloops and we had, we had

an event, uh, just online zoom meeting.

But I didn't have an image for it.

Um, I use the one that
we had used previously.

But you know, something like
that might be kind of cool

to just here we go.

Here's the details.

Just give me the image.

I don't have to drop into.

Not that it's hard to

drop into Canva for that

kind of thing, but yeah.

I don't know the other thing.

So I mean, we, you and I were chatting
about this in the office the other

day with some of these cool AI tools
that you can just describe, describe

things and out comes an image.

That would be kind of.

If you could punch in
some of the data, right?

Like we've got property data.

Those feel like it would be hard
to generate images from, and I

think you'd want an actual image of

Caleb: Yeah.

I don't think you want to generate
an image of what the house looks

Jonathan: This is like, yeah,
we just give it an address.

And AI is like, eh, it

Caleb: Makes this like super mansion.

Jonathan: But I dunno something
like that where you can use.

Just type some words, get an image
and type some types of other words

to put over top of that image.

And here we go.

I don't know.

That's kind of neat.

So what's what's next?

What do we want to do next on this thing?

Caleb: One is probably making sure that
it actually does work and doesn't have

some crazy bugs that caused it to explode.

I did find that it was run out of memory.

If I uploaded an image that was too big.

So maybe some things like that,
some guard rails right now, it's

kinda kind of like driving along
the cliff's edge and it real close.

It works, but

Jonathan: we don't want to
put too much of that stuff in

Caleb: yeah.

Yeah.

I think I'm just like slapping a
component library in to make some

of this stuff look a little better.

And then just updating
that template to make the

images

Jonathan: And

Caleb: look snazzier.

Jonathan: slap in

a component library and you mean, we just
find some preexisting set of nice looking

buttons and things use those not doing in

Caleb: yeah.

yeah.

And making sure it's, I think
all the buttons and inputs are

all like on one line right now.

Maybe added some space.

It should be accessible
though, which is good.

I mean, it is just a form,
so it's not that hard to do.

Jonathan: Accessible, sorry, accessible.

As in anybody with potential
visual disabilities,

Caleb: Yeah, actually,

it's probably easier for someone to
use with a screen reader than someone

to use with their eyes right now.

I think it makes more structural
sense to a screen reader.

Jonathan: oh, that's funny.

Caleb: But yeah, it's, uh, it's
got good bones, you know, bones.

Jonathan: That's awesome.

Accessibility first.

Get it, get it working on a screen
reader before it works visually.

Caleb: Yeah.

Well, I mean part of our, like when we
write tests for front end stuff oftentimes

it's easier to write those tests if you've
made it accessible in the first place.

So it's kind of a, you help yourself too.

So.

Jonathan: Yep.

Is it do you have tests?

Are you writing

Caleb: Oh, yeah, actually I have, I
have a front end integration tests and

also an end to end test that actually
tests that it's generating an image.

It can't really test what the image looks
like it's supposed to, but, uh, it does

it, it makes sure that it's sending back
the stuff in and drawn the new image.

So,

Jonathan: You said two words,
integration tests, and end to end test.

are those?

I know what they are, but I
want you to define them for the.

Caleb: So integration tests are testing
kind of the front end components

without hitting like the back end
or really doing any kind of side

effects, I guess you could call them
trying to test them in isolation.

But, but not so contrived in a
way, like, like chopping into

little itty bitty pieces that don't
actually provide value to test.

So One of the tests for this is when you
like type in stuff, if you type it in

wrong, let's say you type in words for
the price, it tests to make sure that

there's validation, errors and stuff.

But it doesn't actually
send anything to the API.

Doesn't actually do anything.

Yeah.

And then the end to end test, actually
it launches like a headless instance

of Chrome and Firefox and safari,
and it goes through and clicks the

buttons and uploads it and it hits the
actual API and generates the image.

And then it tests all that.

Jonathan: Yeah.

Cool.

And you've got that working, did you?

Because I know we were talking about that.

How was that experience?

Caleb: Yeah.

That was, that was pretty good.

I ended up using Playwright
for the end to end test.

We've used Cyprus before, but uh
Playwright it seems to have a nicer API.

It seems a little bit
more modern, I guess.

Um, but it was pretty easy to set up it's
running in CI or I guess CD, I don't know.

Continuous.

No.

So yeah, continuous integration.

So every time we push up a
change, it, it runs the tests and,

Jonathan: Oh, cool.

Caleb: and it's like, this is
broken or this is working I guess.

I think even now there's more, there's
more test code than there is code code,

Jonathan: Ah,

Caleb: which is good.

Right.

Jonathan: is it?

I don't know.

Caleb: I mean, maybe it's
because it's unsettled at a

bunch of styling that counts

Jonathan: I mean, I'm curious how much
that's like, I don't think that that

adds a ton of value to the product.

If we try to sell it, I have no idea.

I mean, maybe, maybe somebody is
going to look at this and be like,

oh wow, it's got tests, extra, extra.

There's a premium for that.

Caleb: Maybe I mostly did it so that when
I go in and restyle it, if I'm adding in

components, I don't accidentally break it.

Jonathan: Yeah.

Yeah.

I think that's, and that's helpful
that I think it seems like it doesn't

make you move faster, but I really
think it does because like, it feels

like it's a lot of work upfront,

you get a lot of assurances when
you're and making a bunch of changes.

Caleb: Yeah.

You get some maintainability,
especially, cause this is gonna, I

think this will be something that we'll
kind of finish up and it'll be done.

And the next time that we make
changes might be a while from now.

So having those tests there,

Jonathan: Yeah.

Caleb: Make sure that we don't
actually break something.

Cause maybe you forgot
how something works.

Jonathan: Okay.

I'm going to see if I can
talk to somebody about it.

And we're going to
check back in next week.

Hopefully, actually
next week is a holiday.

maybe not next week, but soon what's him

Caleb: Soon actually.

Yeah.

Next week.

I'm yeah.

I might not even actually have
time to work on it next week,

Jonathan: Okay, perfect.

We

can

Caleb: yeah,

Jonathan: couple of

Caleb: yeah.

yeah.

And then we'll sell it.

Jonathan: Yeah,

Caleb: Yeah.

Jonathan: well, it's been great.

We will talk to you all next week.

I have been Jonathan Bowers.

Caleb: I am Caleb sharp.

Jonathan: See ya,

Caleb: bye.

Jonathan: I like it.

OpenHouse.Social

Caleb: OpenHouse.Social

sounds like a, an exclusive club.

The open house club,

Track 1: what kind of music is it?

Caleb: house music.