0:00
Today we're going to be talking about
0:01
how you can build anything with lovable
0:02
and naden. So we're going to be doing a
0:04
live build of spinning up a web page
0:06
with lovable and then also building the
0:08
backend on nadn. But first of all I
0:09
wanted to go over highle what this
0:11
architecture looks like. So right here
0:13
is lovable. This is what we're starting
0:14
off with and this is where we're going
0:15
to be creating the interface that the
0:17
user is interacting with. What we do
0:19
here is we type in a prompt in natural
0:21
language and lovable basically spins up
0:23
that app in seconds. And then we're able
0:25
to talk back and forth and have it make
0:26
minor fixes for us. So what we can do is
0:28
when the user inputs information into
0:30
our lovable website it can send that
0:32
data to naden the nadn workflow that
0:35
we're going to set up can you know use
0:37
an agent to take action in something
0:38
like gmail or slack air tableable or
0:40
quickbooks and then naden can send the
0:43
data back to lovable and display it to
0:45
the user and this is really just the tip
0:47
of the iceberg there's also some really
0:48
cool integrations with lovable and
0:50
superbase or stripe or resend so there's
0:53
a lot of ways you can really use lovable
0:55
to develop a full web app and so while
0:56
we're talking high We just wanted to
0:58
show you an example flow of what this
0:59
naden could look like where we're
1:01
capturing the information the user is
1:02
sending from lovable via web hook. We're
1:05
feeding that to a large language model
1:07
to create some sort of content for us
1:08
and then we're sending that back and it
1:10
will be displayed in the Lovable web
1:11
app. So let's head over to Lovable and
1:13
get started. So if you've never used
1:15
Lovable before, don't worry. I'm going
1:16
to show you guys how simple it is. You
1:18
can also sign up using the link in the
1:19
description for double the credits.
1:21
Okay, so this is all I'm going to start
1:22
with just to show you guys how simple
1:24
this is. I said, "Help me create a web
1:25
app called Get Me Out of This, where a
1:27
user can submit a problem they're
1:29
having." Then I said to use this image
1:30
as design inspiration. So, I Googled
1:32
landing page design inspiration, and I'm
1:34
just going to take a quick screenshot of
1:36
this landing page, copy that, and then
1:38
paste it into Lovable. And then we'll
1:40
fire this off. Cool. So, I just sent
1:41
that off. And on the right hand side,
1:43
we're seeing it's going to spin up a
1:44
preview. So, this is where we'll see the
1:46
actual web app that it's created and get
1:48
to interact with it. Right now, it's
1:49
going to come through and start creating
1:50
some code. And then on the lefth hand
1:52
side is where we're going to have that
1:53
back and forth chat window to talk to
1:55
lovable in order to make changes for us.
1:57
So right now, as you can see, it's going
1:58
to be creating some of this code. We
2:00
don't need to worry about this. Let's go
2:01
into nit real quick and get this
2:03
workflow ready to send data to. Okay, so
2:05
here we are in niten. If you also
2:07
haven't used this app before, there'll
2:08
be a link for it down in the
2:09
description. It's basically just going
2:10
to be a workflow builder and you can get
2:12
a free trial just to get started. So you
2:15
can see I have different workflows here.
2:16
We're going to come in and create a new
2:17
one. And what I'm going to do is we're
2:18
gonna add a first step that's basically
2:20
saying, okay, what actually triggers
2:22
this workflow. So I'm gonna grab a web
2:24
hook. And so all a web hook is is, you
2:26
know, it looks like this. And this is
2:28
basically just a trigger that's going to
2:29
be actively listening for something to
2:32
send data to it. And and data is
2:34
received at this URL. And so right now
2:36
there's a test URL and there's a
2:37
production URL. Don't worry about that.
2:38
We're going to click on this URL to copy
2:41
it to our clipboard. And basically, we
2:42
can give this to Lovable and say, "Okay,
2:44
whenever a user puts in a problem
2:46
they're having, you're going to send the
2:48
data to this web hook." Cool. So,
2:50
hopping over to Lovable. As you can see,
2:51
it's still coding away. And looks like
2:52
it's finishing up right now. And it's
2:54
saying, "I've created a modern
2:55
problem-solving web app with the hero
2:57
section, submission form, and feature
2:59
section in blue color." Um, looks like
3:01
there's an error. So, all we have to do
3:02
is click on try to fix, and it should go
3:04
back in there and continue to spin up
3:05
some more code. Okay. So, now it looks
3:07
like it finished that up. And as you can
3:08
see, we have the website filled up. And
3:10
so it created all of this with just uh
3:12
an image as inspiration as well as just
3:15
me telling it one sentence help me
3:16
create a web app called get me out of
3:18
this where a user can submit a problem
3:19
they're having. So hopefully this should
3:21
already open your eyes to how powerful
3:22
this is. But let's say for the sake of
3:23
this demo we don't want all this. We
3:26
just kind of want one simple landing
3:27
page where they send a problem in. So
3:29
all I'd have to do is on this lefth hand
3:30
side scroll down here and say make this
3:33
page more simple. We only need one
3:38
field which is what
3:41
problem can we help with. So we'll just
3:44
send that off. Very simple query as if
3:46
we were just kind of talking to a
3:48
developer who was building this website
3:49
for us and we'll see it modify the code
3:51
and then we'll see what happens. So down
3:53
here you can see it's modifying the code
3:54
and now we'll see what happens. It's
3:56
just one interface right here. So it's
3:58
created like a title. It has these
3:59
different buttons and we could easily
4:00
say like, okay, when someone clicks on
4:02
the home button, take them here. Or when
4:04
someone clicks on the contact button,
4:05
take them here. And so there's all this
4:07
different stuff we can do, but for the
4:08
sake of this video, we're just going to
4:09
be worrying about this interface right
4:11
here. And just to give it some more
4:12
personality, what we could do is add in
4:14
a logo. So I can go to Google and search
4:17
for a thumbs up logo PNG. And then I can
4:20
say add this logo in the top left. So
4:24
I'll just paste in that image. We'll
4:27
fire this off to lovable. And it should
4:28
put that either right up here or right
4:31
up here. We'll see what it does. But
4:32
either way, if it's not where we like
4:34
it, we can just tell it where to put it.
4:35
Cool. So, as you can see, now we have
4:37
that logo right up there. And let's say
4:38
we didn't like this, all we'd have to do
4:40
is come up to a previous version, hit on
4:42
these three dots, and hit restore. And
4:43
then it would just basically remove
4:45
those changes it just made. Okay. So,
4:46
let's test out the functionality over
4:47
here. Let's say a problem is we want to
4:50
get out of Oh, looks like the font is
4:52
coming through white. So, we need to
4:53
make sure this is changed.
5:05
And boom, we just told it to change the
5:07
text to black and now it's black and we
5:08
can see it. So anyways, I want to say
5:10
get me out of a boring meeting. So we'll
5:15
hit get me out of this and we'll see
5:17
what happens. It says submitting and
5:19
nothing really happens. Even though it
5:21
told us, you know, we'll get back to you
5:22
soon. Nothing really happened. So, what
5:24
we want to do is we want to make sure
5:25
that it knows when we hit this button,
5:27
it's going to send that data to our
5:29
Naden web hook. So, we've already copied
5:31
that web hook to our clipboard, but I'm
5:32
just going to go back into naden. We
5:33
have the web hook. We'll click on this
5:35
right here back into lovable. Basically,
5:37
just saying when I click get me out of
5:38
this, so this button right here, send
5:40
the data to this web hook. And also,
5:42
what we want to do is say as a
5:45
post request because it's going to be
5:48
sending data. So, we're going to send
5:49
that off. And while it's making that
5:51
change to the code, real quick, we want
5:53
to go into nitn and make sure that our
5:54
method for this web hook is indeed post.
5:57
So I don't want to dive into too much
5:58
what that means really, but lovable is
6:01
going to be sending a post request to
6:02
our web hook. Meaning there's going to
6:04
be stuff within this web hook like body
6:06
parameters and different things. And so
6:07
if this wasn't configured as a post
6:09
request, it might not work. So you'll
6:11
see once we actually get the data and we
6:13
catch it in any. But anyways, now when
6:15
the users click on get me out of this,
6:17
the form will send the problem
6:19
description to your web hook via a post
6:20
request. So let's test it out. So we're
6:22
going to say I forgot to prepare a brief
6:24
for my meeting. We're going to go back
6:25
and end it in real quick and make sure
6:27
we hit listen for test event. So now our
6:29
web hook is actively listening back in
6:30
lovable. We'll click get me out of this
6:32
and we will see what happens. We can
6:34
come and end it in and we can now see we
6:35
got this information. So here's the body
6:38
I was talking about where we're
6:39
capturing a problem which is I forgot to
6:41
prepare a brief for my meeting. So, we
6:43
now know that Lovable is able to send
6:45
data to NAND. And now it's on us to
6:47
configure what we want to happen in NAND
6:49
so we can send the data back to Lovable.
6:51
Cool. So, what I'm going to do is I'm
6:53
going to click on the plus that's coming
6:54
off of the web hook. And I'm going to
6:56
grab an AI agent. What this is going to
6:58
do is allow us to connect to a different
7:00
chat model and then the agent's going to
7:02
be able to take this problem and produce
7:03
a response. And I'm going to walk
7:05
through the step by step, but if you
7:07
don't really want to worry about this
7:08
and you just want to worry about the
7:09
lovable side of things, you can download
7:10
the finished template from my free
7:13
school community. I'll link that down in
7:14
the description. That way, you can just
7:15
plug in this workflow and just give
7:17
lovable your noden web hook and you'll
7:19
be set up. But anyways, if you join the
7:21
free school community, you'll click on
7:22
YouTube resources, click on the post
7:24
associated with this video, and you'll
7:26
be able to download the JSON right here.
7:27
And then when you have that JSON, you
7:29
can come into Nadn, open up a new
7:31
workflow, click these three dots in the
7:32
top, and then click import from file.
7:34
And when you open that up, it'll just
7:36
have the finished workflow for you right
7:37
here. But anyways, what I'm going to do
7:39
is click into the AI agent. And the
7:40
first thing is we have to configure what
7:43
information the agent is going to
7:44
actually read. So first of all, we're
7:46
going to set up that as a user prompt.
7:48
We're going to change this from
7:50
connected chat trigger node to define
7:52
below because we don't have a connected
7:53
chat trigger node. We're using a web
7:55
hook as we all know. So we're going to
7:56
click on define below and we are
7:58
basically just going to scroll down
8:00
within the web hook node where the
8:02
actual data we want to look at is which
8:04
is just the problem that was submitted
8:05
by the user. So down here in the body we
8:08
have a problem and we can just drag that
8:10
right in there and that's basically all
8:11
we have to do. And maybe we just want to
8:13
define to the agent what it's looking
8:14
at. So we'll just say like the problem
8:18
and then we'll put a colon. So now you
8:19
can see in the result panel this is what
8:20
the agent will be looking at. And next
8:22
we need to give it a system message to
8:24
understand what it's doing. So, I'm
8:26
going to click on add option, open up a
8:28
system message, and I am going to
8:30
basically tell it what to do. So, here's
8:32
a system message that I came up with
8:33
just for a demo. You are an AI excuse
8:35
generator. Your job is to create clever,
8:37
creative, and context appropriate
8:38
excuses that someone could use to avoid
8:40
or get out of a situation. And then we
8:43
told it to only return the excuse and
8:44
also to add a touch of humor to the
8:46
excuses. So now, before we can actually
8:48
run this to see how it's working, we
8:50
need to connect its brain, which is
8:51
going to be an AI chat model. So, what
8:53
I'm going to do is I'm going to click on
8:54
this plus under chat model. For this
8:56
demo, we'll do an open AI chat model.
8:58
And you have to connect a credential if
9:00
you haven't done so already. So, you
9:01
would basically come into here, click
9:03
create new credential, and you would
9:04
just have to insert your API key. So,
9:07
you can just Google OpenAI API. You'll
9:09
click on API platform. You can log in,
9:11
and once you're logged in, you just have
9:12
to go to your dashboard, and then in the
9:14
left, you'll have an API key section.
9:16
All you'll have to do is create a new
9:17
key. We can call this one um test
9:20
lovable. And then when you create that,
9:23
you just copy this value. Go back into
9:25
Nitn. Paste that right here. And then
9:26
when you hit save, you are now connected
9:28
to OpenAI's API. And we can finally run
9:31
this agent real quick. If I come in here
9:33
and hit test step, we will see that it's
9:34
going to create an excuse for I forgot
9:37
to prepare a brief for my meeting, which
9:38
is sorry, I was too busy trying to bond
9:40
with my coffee machine. Turns out it
9:42
doesn't have a prepare briefs setting.
9:44
So basically what we have is we're
9:46
capturing the problem that a user had.
9:48
We're using an AI agent to create a
9:50
excuse. And then we need to send the
9:52
data back to Lovable. So all we have to
9:54
do here is add the plus coming off of
9:55
the agent. We're going to call this a
9:57
respond to web hook node. And we're just
9:59
going to respond with the first incoming
10:01
item, which is going to be the actual
10:03
response from the agent. But all we have
10:04
to do also to configure this is back in
10:07
the web hook node, there's a section
10:08
right here that says respond. Instead of
10:10
responding immediately, we want to
10:12
respond using the respond to web hook
10:14
node. So now it will be looking over
10:16
here and that's how it's going to send
10:18
data back to lovable. So this is pretty
10:20
much configured the way we need it, but
10:21
we have to configure Lovable now to wait
10:24
for this response. Okay. So what I'm
10:26
telling Lovable is when the data gets
10:27
sent to the web hook, we wait for the
10:29
response from the web hook, then output
10:32
that in a field that says here is your
10:33
excuse. So we'll send this off to
10:35
Lovable and see what it comes up with.
10:37
Okay, so now it said that I've added a
10:38
new section that displays here is your
10:40
excuse along with the response message
10:42
from the web hook when it's received. So
10:44
let's test it out. First, I'm going to
10:45
go back and edit in and we're going to
10:46
hit test workflow. So the web hook is
10:48
now listening for us. So we'll come into
10:50
our lovable web app and say I want to
10:52
skip a boring meeting. We'll hit get me
10:55
out of this. So now that data should be
10:57
captured in Naden. It's running. And now
10:59
the output is I just realized my pet
11:02
goldfish has a lifealtering decision to
11:04
make regarding his tank decorations and
11:06
I simply cannot miss this important
11:07
family meeting. So it doesn't look
11:09
great, but it worked. And if we go into
11:11
NDN, we can see that this run did indeed
11:13
finish up. And the output over here was
11:15
I just realized my pet goldfish has a
11:16
lifealtering decision blah blah blah. So
11:18
basically what what's happening is the
11:20
web hook is returning JSON which is
11:22
coming through in a field called output
11:24
and then we have our actual response
11:25
which is exactly what lovable sent
11:28
through. So it's not very pretty and we
11:29
can basically just tell it to clean that
11:30
up. So what I just did is I said only
11:32
return the output fields value from the
11:35
web hook response not the raw JSON. So
11:37
we wanted to just output this right here
11:39
which is the actual excuse. And so some
11:41
of you guys may not even have had this
11:42
problem pop up. I did a demo of this
11:44
earlier just for testing and I basically
11:46
walked through these same steps and this
11:48
wasn't happening. But you know sometimes
11:50
it happens. Anyways, now it says the
11:52
form only displays the value from the
11:54
output field. So let's give it another
11:56
try. So back in we're going to hit test
11:58
workflow. So it's listening for us in
12:00
lovable. We're going to give it a
12:01
problem. So I'm saying I overslept and
12:03
I'm running late. I'm going to click get
12:04
me out of this. And we'll see the
12:05
workflow just finished up. And now we
12:07
have the response in a clean format
12:09
which is I accidentally hit the snooze
12:10
button until it filed for a restraining
12:12
order against me for harassment. Okay.
12:14
So now that we know that the
12:15
functionality within N is working. It's
12:17
sending data back. We want to customize
12:19
our actual interface a little bit. So
12:20
the first thing I want to do just for
12:22
fun is create a level system. So every
12:24
time someone submits a problem, they're
12:25
going to get a point. And if they get
12:26
five points, they'll level up. If they
12:28
get 20 total points, they'll level up
12:30
again. Okay. So I just sent off create a
12:32
dynamic level system. Every time a user
12:34
submits a problem, they get a point.
12:36
Everyone starts at level one and after
12:38
five points, they reach level two. Then
12:40
after 15 more points, they reach level
12:41
three. And obviously, we'd have to bake
12:42
in the rest of the the levels and how
12:44
many points you need. But this is just
12:46
to show you that this is going to
12:47
increase every time that we submit a
12:48
problem. And also, you'd want to have
12:50
some sort of element where people
12:51
actually log in and get authenticated.
12:53
And you can store that data in Superbase
12:55
or in um, you know, Firebase, whatever
12:57
it is, so that everyone's levels are
12:59
being saved and it's specific to that
13:02
person. Okay. Okay, so looks like it
13:03
just created a level system. It's
13:05
reloading up our preview so we can see
13:06
what that looks like now. Um, looks like
13:09
there may have been an error, but now,
13:10
as you can see right here, we have a
13:12
level system. So, let's give it another
13:13
try. I'm going to go into Nitn. We're
13:15
going to hit test workflow. So, it's
13:16
listening once again, and we're going to
13:18
describe a problem. So, I'm saying my
13:19
boss is mean. I don't want to talk to
13:20
him. We're going to hit submit. The end
13:22
workflow is running right now on the
13:23
back end. And we just got a message
13:25
back, which is, I'd love to chat, but
13:27
I've got a hot date with my couch and
13:28
binge watching the entire season of
13:29
Awkward Bosses. And you can see that we
13:31
got a point. So, four more points to
13:33
unlock level two. But before we continue
13:35
to throw more prompts so that we get up
13:36
to level two, let's add in one more cool
13:39
functionality. Okay, so I'm just firing
13:41
off this message that says add a drop
13:43
down after what problem can we help with
13:45
that gives the user the option to pick a
13:47
tone for the response. So the options
13:49
can be realistic, funny, ridiculous, or
13:52
outrageous. And this data of course
13:54
should be passed along in that web hook
13:56
to NADN because then we can tell the
13:58
agent to say okay here's the problem and
14:01
here's the tone of an excuse the user is
14:03
requesting and now it can make a request
14:05
or a response for us. So looks like it's
14:08
creating that change right now. So now
14:09
we can see our dropown menu that has
14:11
realistic, funny, ridiculous, and
14:12
outrageous. As you can see before you
14:14
click on it, it's maybe not super clear
14:15
that this is actually a drop down. So
14:17
let's make that more clear. And what I'm
14:18
going to do is I'm going to take a
14:19
screenshot of this section right here.
14:21
I'm going to copy this and I'm just
14:23
going to paste it in here and say make
14:25
this more clear that it is a drop-own
14:30
selection and we'll see what it does
14:31
here. Okay, perfect. So, it just added a
14:34
little arrow as well as a placeholder
14:35
text. So, that's way more clear. And now
14:37
what we want to do is test this out.
14:39
Okay, so now to test this out, we're
14:40
going to hit test workflow. But just
14:42
keep in mind that this agent isn't yet
14:43
configured to also look at the tone. So
14:46
this tone won't be accounted for yet.
14:47
But what we're going to do is we have I
14:49
overslept and the response is going to
14:50
be funny. We'll hit generate me a or
14:54
sorry get me out of this. So we have a
14:56
response and our level went up. We got
14:57
another point. But if we go into Nit, we
15:00
can see that it didn't actually account
15:01
for the tone yet. So all we have to do
15:03
is in the actual user message, we're
15:05
basically just going to open this up and
15:07
also add a tone. And we can scroll all
15:09
the way down here and we can grab the
15:11
tone from the body request. And now it's
15:13
getting the problem as well as the tone.
15:15
And now in the system prompt, which is
15:17
basically just defining to the agent its
15:19
role. We have to tell it how to account
15:21
for different tones. Okay, so here's
15:23
what I came up with. I gave it some more
15:24
instructions and I said, "You're going
15:25
to receive a problem as well as a tone.
15:27
And here are the possible tones, which
15:29
are realistic, funny, ridiculous, and
15:31
outrageous." And then I kind of said
15:33
what that means. And then I said, "Your
15:34
excuse should be 1 to three sentences
15:36
long, and match the selected tone." So
15:38
that's all we're going to do. We're
15:39
going to hit save. Okay. So now that
15:40
it's looking at everything, we're going
15:42
to hit test workflow. The web hook's
15:43
listening. We'll come back into here and
15:45
we're going to submit. I broke my
15:46
friend's iPhone and the response tone
15:48
should be outrageous. So, we're going to
15:49
send that off. And it's loading because
15:51
our end workflow is triggering. And now
15:53
we just got it. We also got a message
15:54
that says we earned a point. So, right
15:56
here, we now only need two more for
15:58
level two. But the excuse is I was
16:00
trying to summon a unicorn with my
16:01
telekinetic powers and accidentally
16:04
transformed your iPhone into a rogue
16:05
toaster that launched itself off the
16:07
counter. I swear it was just trying to
16:09
toast a bagel. Okay, so obviously that's
16:11
pretty outrageous and that's how we know
16:12
it's working. So, I'm sure you guys are
16:13
wondering what would you want to do if
16:15
you didn't want to come in here and
16:16
every single time make this thing, you
16:19
know, test workflow. What you would do
16:20
is you'd switch this to an active
16:22
workflow. Now, basically, we're not
16:24
going to see the executions live anymore
16:26
with all these green outlines. But
16:28
what's happening now is it's using the
16:30
production URL. So, we're going to have
16:32
to copy the production URL, come back
16:34
into Lovable, and just basically say I
16:36
switched the URL or sorry, let's call I
16:40
switched the web hook to this. And we'll
16:43
paste that in there, and it should just
16:44
change the data. The logic should be all
16:47
the exact same because we've already
16:49
built that into this app. But we're just
16:51
going to switch the web hook. So now we
16:52
don't have to go click test workflow
16:54
every time in NAN. And super excited. We
16:56
have two more problems to submit and
16:58
then we'll be level two. So now it says
17:00
the web hook URL has been updated. So
17:01
let's test it out. As you can see in
17:03
here, we have an active workflow. We're
17:05
not hitting test workflow. We're going
17:06
to come in here and submit a new
17:08
problem. So we are going to say um I
17:11
want to take four weeks off work, but my
17:16
boss won't let me. We are going to make
17:20
the response tone. Let's just do a
17:22
realistic one. And we'll click get me
17:23
out of this. It's now calling that
17:25
workflow that's active and it's
17:26
listening. So we got a point. We got our
17:28
response which is I've been dealing with
17:30
some unforeseen family matters that need
17:31
my attention. I believe taking four
17:33
weeks off will help me address them
17:34
properly. I plan this time to use this
17:36
time to ensure everything is in order so
17:38
I can return more focused and
17:39
productive. I would definitely say that
17:40
that's realistic. What we can do is come
17:42
into NAN. We can click up here on our
17:44
executions and we can see what just
17:46
happened. So this is our most recent
17:48
execution and if we click into here it
17:50
should have been getting the problem
17:52
which was I want to take four weeks off
17:53
work and the tone which was realistic.
17:56
Cool. Cool. So, now that we know that
17:57
our active new web hook is working,
17:59
let's just do one more query and let's
18:01
earn our level two status. I'm also
18:04
curious to see, you know, we haven't
18:05
worked in any logic of what happens when
18:06
you hit level two. Maybe there's some
18:08
confetti. Maybe it's just a little
18:09
notification. We're about to find out.
18:11
Okay, so I said I got invited on a
18:13
camping trip, but I hate nature. We're
18:14
going to go with ridiculous and we're
18:16
going to send this off. See what we get
18:18
and see what level two looks like. Okay,
18:21
so nothing crazy. We could have worked
18:22
in like, hey, you know, make some
18:23
confetti pop up. All we do is we get
18:25
promoted to level two up here. But, you
18:27
know, as you can see, the bar was
18:28
dynamic. It moved and it did promote us
18:30
to level two. But the excuse is, I'd
18:32
love to join, but unfortunately, I just
18:34
installed a new home system that detects
18:35
the presence of grass, trees, and
18:37
anything remotely outdoorsy. If I go
18:39
camping, my house might launch an
18:40
automated rescue mission to drag me back
18:42
indoors. So, that's pretty ridiculous.
18:44
And also, by the way, up in the preview,
18:46
you can make it mobile. So, we can see
18:47
what this would look like on mobile.
18:49
Obviously, it's not completely optimized
18:50
yet, so we'd have to work on that. But
18:52
that's the ability to do both desktop
18:54
and mobile. And then when you're finally
18:56
good with your app, up in the top right,
18:57
we can hit publish, which is just going
18:59
to show us that we can connect it to a
19:00
custom domain or we can publish it at
19:02
this domain that is made for us right
19:04
here. Anyways, that is going to be it
19:06
for today's video. This is really just
19:07
the tip of the iceberg with, you know,
19:09
nodn already has basically unlimited
19:11
capabilities. But when you connect that
19:13
to a custom front end when you don't
19:15
have to have any sort of coding
19:16
knowledge, as you can see, all of these
19:18
prompts that I use in here was just me
19:20
talking to it as if I was talking to a
19:22
developer. And it's really, really cool
19:23
how quick we spun this up. So, if you
19:25
guys are interested in seeing some more
19:26
in-depth videos with Lovable, like
19:28
connecting to Superbase or Firebase and
19:30
setting up some user authentication
19:31
stuff, definitely let me know. I'd love
19:33
to make some content on that for you
19:34
guys. If you kind of liked this live
19:36
build style, then definitely check out
19:37
my paid community. The link for that
19:38
will be down in the description. It's
19:39
going to be a pretty hands-on approach
19:40
to learning how to build out these
19:42
automations with any or lovable or
19:43
whatever it is you're working with. We
19:45
got a great community of members who are
19:46
always sharing resources and challenges
19:48
that they're running into, as well as a
19:49
classroom section with some deep dive
19:51
topics like building agents, vector
19:52
databases, APIs, and HTTP requests, as
19:55
well as step-by-step builds. And then we
19:57
have five live calls per week to make
19:59
sure you're never getting stuck and also
20:00
meeting other people in the space. So,
20:02
I'd love to see you guys in this
20:03
community on some of these live calls.
20:04
But, as always, appreciate you making it
20:06
to the end of the video. If you learned
20:08
something new or if you enjoyed, please
20:09
give it a like. Definitely helps me out
20:11
a ton. And I will see you guys in the
20:12
next video. Thanks.