Latest / Agentic Conversations (formally mlops.community) / The Creator of FastAPI’s Next Chapter // Sebastián Ramírez // #324

Transcript

The Creator of FastAPI’s Next Chapter // Sebastián Ramírez // #324 · Agentic Conversations (formally mlops.community)

• 0:00
  I am Sebastian Ramirez or Tiangolo.
• 0:03
  I am the creator of Fast API and now the founder of Fast API
• 0:07
  loves this new company. I drink my coffee as a
• 0:12
  cappuccino and I drink a lot of it.
• 0:15
  Welcome back to the ML OPS Community podcast.
• 0:17
  I'm your host Dimitrios, and today we've got the mustache man
• 0:21
  himself, Mr. Tiangolo, AKA the creator of Fast API, which I am
• 0:29
  sure a few of you use and love. We talked all about developer
• 0:34
  experience when building software.
• 0:36
  We also talked about how he thinks through abstractions.
• 0:41
  Let's just get right into this conversation because I had a
• 0:44
  blast with my amigo, Mr. Sebastian.
• 0:54
  You know what I want to tell the listeners?
• 0:57
  I want to start with the fact that we did a hackathon and the
• 1:04
  winners of that hackathon were from Columbia.
• 1:08
  Right, right. I forgot that that was so fun.
• 1:12
  We were the judges and the funniest part was you're from
• 1:16
  Columbia, The winners were from Columbia.
• 1:19
  Afterwards we're making all kinds of jokes like.
• 1:23
  Yeah. They paid off the judges.
• 1:26
  Yeah, yeah, yeah. What is this so very?
• 1:29
  Very because the, the, the, the thing that they came up with
• 1:32
  was, was quite cool. But I feel like I am Colombia.
• 1:35
  I cannot, I cannot vote on this. And they had just like, you
• 1:38
  know, like hands off, like the other two judges.
• 1:42
  You decide that I can't. You had too much honor.
• 1:45
  But I also remember that when we were just hanging out and
• 1:48
  everybody was hacking somebody, you were talking to somebody and
• 1:53
  for some reason pedantic came up and they didn't know what
• 1:58
  pedantic was. And you looked at him like you
• 2:00
  don't know what pedantic. Is.
• 2:02
  Oh, let me tell you all about it.
• 2:03
  So why do you love pedantic so much?
• 2:07
  Pedantic. I think Pedantic is so cool.
• 2:11
  Thing is, Pivantic made it super simple to validate data and to
• 2:17
  get out of completion and lean and errors for the data that
• 2:20
  you're handling in code. The funny thing is, before
• 2:24
  Pivantic was as widely known as it is right now, it was like,
• 2:28
  you know, like a library for doing data validation, but it
• 2:30
  was not as obvious. I will think that you need to do
• 2:35
  data validation, that you need to validate the data, you need
• 2:37
  to structure it properly, serialize it, converted,
• 2:41
  documented isn't it's not something that is obvious.
• 2:44
  And there's a lot of code that goes, you know, like just wasted
• 2:49
  on doing custom validations just because, you know, like, if you
• 2:53
  don't know that there's that option, you end up just like
• 2:55
  writing a lot of code just to check if it's actually an
• 2:58
  integer or not, or maybe this one is adjacent object or like,
• 3:01
  I don't know. So I thought that Piantic was,
• 3:04
  was amazing doing that. It was just not as obvious that
• 3:08
  you will get so much benefit from it for fast API.
• 3:11
  It was, it was like the key, you know, like the key component for
• 3:14
  doing all the data validation, serialization, parsing,
• 3:17
  documentation, all that stuff. And to make it super simple and
• 3:20
  super intuitive. And I guess that's also why it,
• 3:25
  it sort of helped David show, Hey, Piantic is here.
• 3:28
  Like you can use it for these types of things and then like I
• 3:31
  think people slowly got the hang of it and started using it for
• 3:35
  more things. But I think it actually took a
• 3:38
  bit for people to start exploring Paiantic in many other
• 3:41
  ways. I remember I was, I was like
• 3:44
  that at that moment, I was pitching Paiantic for everything
• 3:47
  because I was doing all the data processing with Pedantic.
• 3:50
  I have, I have a bunch of custom GitHub actions that are pretty
• 3:54
  much just a pedantic model that extracts the data from the
• 3:59
  environment variables and just like give me the right data.
• 4:01
  And then the code is super simple afterwards.
• 4:03
  And it actually doesn't even involve a fast API or anything.
• 4:06
  It's just like pure pedantic. So like, yeah, I think it's a
• 4:08
  great tool. You were super early on that
• 4:11
  trend and so it feels like you saw around the corner a bit and
• 4:17
  you incorporated into fast API, right?
• 4:19
  Yeah, yeah. So The thing is, I was, I was
• 4:23
  looking to build something that was similar to the other tools
• 4:26
  that I was using. But by that point I realized
• 4:29
  that I wanted to have the best developer experience possible
• 4:33
  and that will need to take advantage of type annotations.
• 4:36
  And type annotations were just super new.
• 4:39
  They were for a year or something.
• 4:40
  So there was no tool that was using type annotations, at least
• 4:44
  not properly. And pedantic was I think the
• 4:48
  only one that was using them at the time, apart from data
• 4:53
  classes that was in the standard library.
• 4:55
  But data classes doesn't do like any data validations,
• 4:57
  realization, transformation, but it's sort of the same, the same
• 5:01
  style. And I was looking for a tool
• 5:04
  that will do things like that. I was using by then.
• 5:07
  There was a previous tool called Marshmallow and Marshmallow was
• 5:12
  great. It's just that it was the same
• 5:14
  before. We have type annotations, so
• 5:16
  that didn't have a way to exploit them.
• 5:18
  I was trying to look for something like that that will be
• 5:20
  based on type annotations. So I was, I already had my mind
• 5:24
  set on what I needed and then I found Pedantic is like, OK, this
• 5:28
  is the right thing. But the Pedantic docs docs were
• 5:32
  mainly focused about managing settings and handling settings
• 5:37
  for applications. And we're like, OK, but is this?
• 5:39
  So I was like, you know, like, is this actually what I need or
• 5:42
  not? But then, like, I, I kept
• 5:44
  digging deeper and then I found out, yeah, this is exactly what
• 5:47
  I need. It's just that it's probably not
• 5:49
  obvious that it could be perfect for all these other use cases.
• 5:52
  So yeah, just like started just exploiting it and nagging
• 5:56
  somewhere with the hey, here's another PR.
• 6:01
  Yes, Emma, that's awesome. He's been so good and they're
• 6:05
  great shepherds for that whole community.
• 6:07
  It's cool to see by Dan Dick and and like you said how it had
• 6:11
  this lagging effect, but now it feels like it is very much at
• 6:16
  the forefront and people understand the value in it
• 6:20
  thanks to I think in part a lot of what you did with fast API.
• 6:25
  Nice. I'm I'm you know, like that's
• 6:26
  that's that's an order for me to think that I helped people to
• 6:30
  get to know Pedantic. And now Pedantic is also using
• 6:32
  like everywhere in, you know, like all the major Edelen
• 6:36
  providers or as the case or tools, they are all based built
• 6:40
  on top of pedantic. And that's amazing because I
• 6:42
  think it's like, yeah, it's an amazing building block for
• 6:45
  everything that we've built on top.
• 6:47
  So there's two things that I wanted to talk about from our
• 6:51
  last conversation, which was I think like 3 years ago till now,
• 6:55
  that I swore to myself if we end up talking again, I have to ask
• 7:00
  you about these things. The first one is I got a little
• 7:04
  bit of Flack back in the day because I didn't ask you about
• 7:08
  your stint in ML Folks were like, yeah, but Sebastian's done
• 7:14
  ML stuff and you guys didn't talk at all about that in the
• 7:17
  podcast. So can you break down the ML
• 7:20
  stuff that you did and give us a bit of, I think you're like an
• 7:24
  undercover ML/AI guy where you're masquerading with the
• 7:29
  FAST API. But was it was FAST API built
• 7:33
  for ML use case? Yeah, exactly.
• 7:38
  Do you? You got me.
• 7:40
  So I got into Python to do AI and ML.
• 7:45
  That's why I got into Python. It was a requisite in a in a in
• 7:49
  an AI course from edx from Berkeley like, I don't know,
• 7:54
  10-12 years ago. All of them, yeah, like.
• 7:56
  Yeah, that's how I got into Python.
• 7:59
  Then I started working and I was doing stuff with computer
• 8:02
  vision, and then it was computer vision without deep learning,
• 8:06
  without neural networks. It was just like, you know,
• 8:08
  like, oh, very complex algorithms and like SIFT and
• 8:13
  like then matching stuff and like call my filters and like a
• 8:16
  bunch of stuff that was, was super sophisticated, complicated
• 8:21
  and difficult to get. Like, you know, like great
• 8:23
  results with it. And then like, you know, now,
• 8:26
  now you can just like put deep neural networks on top and like
• 8:29
  get a lot of value without, you know, like without having to
• 8:33
  feel so much. It's amazing.
• 8:36
  But yeah, I got into that. Then I, I took a bunch of, I
• 8:38
  took a lot of online courses, but like I, I have like a, a big
• 8:42
  inclination towards machine learning and AI.
• 8:45
  And then fast API came from that.
• 8:47
  And then, yeah, so like I, I started working at the company,
• 8:50
  we were doing like machine learning stuff and it was things
• 8:54
  related to that, but we always had to build applications.
• 8:57
  I mean, in all the cases we needed to build an API on top of
• 9:01
  things. So I kept struggling we and kept
• 9:04
  like stumbling in like the issues of like building an API
• 9:07
  with the tools that I had on hand.
• 9:09
  And I figured that this was one of the things, one of the
• 9:12
  patterns that was just repeating over and over and one of the
• 9:15
  things that had to be solved over and over.
• 9:17
  And I didn't found a great solution and something that that
• 9:21
  will work well. And I found something that will
• 9:24
  sort of work and I figure out how to make it work.
• 9:27
  But it was so complicated and like, you know, like it was
• 9:32
  difficult. And then the team that I was
• 9:34
  working with that they were all struggling.
• 9:36
  And it was like, yeah, this is just copy paste whatever
• 9:39
  Sebastian did. And like, it's, it works.
• 9:42
  Yeah. It's not the best developer
• 9:44
  experience. So, you know, like continuing in
• 9:48
  that path. I, I was using that setup for
• 9:50
  quite a while, but like, you know, like I kept just like
• 9:53
  investigating and researching different framers and things
• 9:56
  until I ended up in fast API And then I just, I got stuck in AP
• 10:00
  is but like I, I got into Python because I was going to do AI and
• 10:04
  MMM. You missed the train on that
• 10:07
  one. You were super early and then
• 10:11
  you went down the API rabbit hole and ended up powering half
• 10:14
  the Internet. That's that's, that's a crazy,
• 10:18
  it's like, you know, like it's, it's something that makes me
• 10:22
  very what proud and humble and like everything at the same
• 10:26
  thing to see so many AI applications and like, you know,
• 10:29
  like many of the of the, you know, like top voices and like
• 10:36
  top opinion leaders in AI liking and using fast API.
• 10:40
  For me, that's, you know, that's mind blowing.
• 10:44
  Well, I remember you telling us that one of the bigger ones that
• 10:48
  you had heard was using, it was like NASA and they were powering
• 10:54
  spaceships or something along those lines.
• 10:56
  And I that blew my mind. Just like there are some really
• 11:02
  cool use cases, and of course there are because you use AP is
• 11:06
  for everything. Yeah, it's not like.
• 11:09
  It's not contained in that way. You can use APIs wherever.
• 11:14
  And like you said, your commitment to the developer
• 11:17
  experience has been, I think, what makes fast API shine.
• 11:22
  And so the second thing that I wanted to ask you about was what
• 11:27
  I also got Flack for in the last time that we had a conversation.
• 11:33
  And that was people saying, why didn't you ask him why there's
• 11:36
  so many damn emojis in the docks?
• 11:38
  And this is this is pre chachi PT.
• 11:42
  You were very early on that trend also.
• 11:46
  Yeah, that's, yeah, that's funny.
• 11:48
  Like, you know, at some point, I don't know how much you go into
• 11:53
  Reddit. I now try to avoid it because in
• 11:56
  many cases it's a dark place. It's a very dark place.
• 11:59
  Yeah, but at some point I remember there was some
• 12:01
  conversation in one of these ready to like, I don't know,
• 12:04
  fast API or Python or something, and someone was saying like, Oh
• 12:08
  no, couldn't trust Fast API. Like, you know, like, Oh no, can
• 12:11
  I trust? Like it's a, it's a single guy.
• 12:13
  Like how can you trust them? Like, you know, like people
• 12:15
  don't realize that most of the open source projects they use
• 12:18
  are built by a single guy or a couple of people.
• 12:21
  Even if they are big corporations, this is still
• 12:23
  mostly like one or two people for most of the open source
• 12:25
  projects. But anyway, they were saying
• 12:27
  like, no, no, how cool can you trust like a simple guy on
• 12:30
  bland? One of them said like, well, but
• 12:32
  wait, why? Why wouldn't you trust this guy?
• 12:35
  Or like, why, Why do you say he's a psychopath or something?
• 12:38
  Like I said, like he's clearly he, he clearly does very, what
• 12:43
  was he? He clearly does very hard drugs.
• 12:45
  Like what? How?
• 12:48
  How do you know? And it's because of the emojis.
• 12:53
  So the emojis, Yeah, yeah, yeah. That's what that tells that like
• 12:59
  I do very hard drugs. Like, well, I do very.
• 13:02
  I do lots of coffee, maybe that. Oh man, that is the best Reddit
• 13:10
  thread. We'll have to try and find that
• 13:12
  one to showcase to people because yeah, that that's the
• 13:16
  Internet for you. That's what you can expect when
• 13:20
  you gain a certain amount of notoriety.
• 13:22
  You're going to get that type of random speculation.
• 13:26
  But this one like, you know, like the point is, I guess well,
• 13:29
  after one, at first it's like, oh, that, you know, like you
• 13:32
  feel weird and like maybe like a title like did I do something
• 13:35
  wrong? Or it's like something bad or
• 13:37
  something. But then like after a while
• 13:38
  you'd realize that the the bigger the scope of the impact
• 13:43
  that you can have, the higher chance that you're going to have
• 13:47
  some random person just nagging about random stuff that doesn't
• 13:51
  really make that much sense. So I guess, yeah, trying to
• 13:56
  trying to take it as a compliment, I guess, you know,
• 13:58
  like when someone criticizes you so badly, like, how could we get
• 14:05
  to this point? You know, like I'm a random
• 14:07
  person in the other side of the world on the Internet.
• 14:10
  How could this person hate me so so much?
• 14:13
  For the emojis that you use in the dark.
• 14:16
  So yeah, I don't know. I have also had like a few
• 14:19
  reports, I think like it more than it's more than 123 of
• 14:24
  saying like, hey, the first API dogs have been hacked because
• 14:28
  he's so full of emojis. It's just that they put the URL
• 14:31
  run because there's a version. So Fast API is translated to a
• 14:35
  few languages and one of those languages is emoji.
• 14:39
  It was just an April Fool's joke and it just stuck and it's still
• 14:43
  there and you can find the whole documentation written in emojis.
• 14:47
  And it was, it was actually done by other people.
• 14:49
  It was not done by me. It was done by a few other
• 14:52
  people. And I think that's the PR with
• 14:54
  the most approvals I have have in Fast API.
• 14:59
  So when people get to like, you know, like Easter eggs and April
• 15:01
  Fool's jokes, like, they really go harder on that so that that's
• 15:06
  still there. But then occasionally people
• 15:09
  bump into a URL with the emoji prefix and they just see
• 15:14
  everything in emoji and like, oh, no, it was hacked.
• 15:16
  And then they tag me on Twitter. It's like, yeah, I know you're
• 15:19
  in their own language. Incredible.
• 15:22
  Dude, that is so funny to think about.
• 15:24
  Well, there's the other piece. I just can't stop thinking about
• 15:30
  the emojis part and how much controversy emojis cause for
• 15:36
  basically nothing. I also get that way when I play
• 15:41
  guitar in our virtual conferences or in our I used to
• 15:46
  do guitar intros for the virtual events and we threw them up on
• 15:51
  YouTube. And I'll tell you what, some
• 15:53
  people on YouTube, they've got some creative ways of talking
• 15:58
  shit. And I was the same way as you
• 16:01
  where I would just think, damn, I am honored in a way because
• 16:07
  they took the time out of their day to talk shit.
• 16:10
  And I guess I could feel a little bit ashamed here, but
• 16:15
  Nah, I'm going to take it as a compliment as opposed to a
• 16:20
  threat or just dissing me. So.
• 16:25
  So anyway, the, the thing that I wanted to talk to you about too,
• 16:31
  you have started a new company. You also got some funding from
• 16:37
  Sequoia, I heard or I saw and I know that for the last year or
• 16:42
  so you were doing something really cool that Sequoia was
• 16:46
  sponsoring, which was like they were, it was almost like this
• 16:51
  entrepreneur, entrepreneur in residence, but it wasn't.
• 16:55
  So maybe you can break down what you were doing and then why you
• 16:59
  finally landed on Fast API Cloud or the pro version of Fast API?
• 17:05
  Because I know that back in the day when we had a meet up and
• 17:08
  then we went out after the meet up in Berlin, people were like,
• 17:12
  oh, so you're going to start a company, you're going to do
• 17:14
  something around fast API and you're like, I don't think so.
• 17:17
  I don't know, maybe we'll see. I'm open.
• 17:20
  But that was also like 4 years ago.
• 17:21
  So obviously a lot's changed. Give me the breakdown and the
• 17:26
  lead up to this. You know, like I, I remember in
• 17:29
  that conversation after the meet up, one of the guys came and say
• 17:33
  like, OK, so I and are you going to work like full time on that
• 17:37
  or not? Because at that point I still
• 17:39
  wasn't working full time on Fast API.
• 17:40
  Yeah, you had a job. I.
• 17:42
  Think I had a like I I had a part time job and I asked them
• 17:45
  to do it part time because I wanted to spend more time on
• 17:47
  open source and he's I remember this guy said like, hey, are you
• 17:52
  working full time fast API? Like no, but like yeah, you know
• 17:55
  like I don't have a product or something like why don't you
• 17:57
  start the company? No, yeah.
• 17:59
  And I remember he said, like you should, you should start a
• 18:02
  company or do something and build something for, for open
• 18:05
  source because we all need it. Like, you know, like we all
• 18:10
  benefit from that. And it will be a shame if we
• 18:12
  cannot get like more of that, you know, like it was something
• 18:16
  around those lines and it was like, oh, that's shit.
• 18:19
  That's so, you know, makes you feel, well, on one hand, super
• 18:25
  appreciated. On the other hand, like sort of
• 18:27
  almost our responsibility of like, you know, like this is
• 18:29
  something that is being so useful to people and I get the
• 18:32
  chance and the power to help many more people by just
• 18:38
  improving. It was like something that you
• 18:41
  sort of got to do right. So yeah, it was.
• 18:45
  I remember, I remember that that point and that moment.
• 18:48
  And that guy, I think I remember who you're talking about.
• 18:51
  And that guy, 'cause I, I remember distinctly being at the
• 18:55
  bar when we were talking and he was telling me like, dude, yeah,
• 19:00
  like maybe you could start a course or maybe you could do
• 19:02
  something with this community, like certificates.
• 19:05
  And I looked at you and I was like, yeah, and maybe you could
• 19:08
  like start a course too, or like a newsletter.
• 19:11
  And he looked and he was like, this is Sebastian.
• 19:14
  He started Fast API. He's not starting a course.
• 19:17
  He's got a company. To go start and.
• 19:21
  I was like, OK, dude, thanks for like that packhanded cuff.
• 19:27
  I was, I was laughing so hard. I can't remember who what that
• 19:31
  guy's name was, but I'm going to go find him and, and we'll have
• 19:33
  some laughs together. But anyway, so then you had that
• 19:36
  pressure put on you. Yeah.
• 19:38
  But then after that it was, I don't know if it was like the
• 19:40
  next year or one year after I remember was probably 1.
• 19:44
  After that, it was in 2023 Sequoia started the open source
• 19:48
  fellowship. So it was like this sort of it
• 19:54
  was a steep end to cover my expenses.
• 19:55
  So I would just like work full time on open source.
• 19:59
  I think during that time is that we had the, the the hackathon
• 20:02
  that I was helping judge and like that stuff.
• 20:05
  But that was because that was after the previous event.
• 20:08
  And you weren't getting paid right?
• 20:10
  The I remember you telling me that you had the option to
• 20:15
  donate on the GitHub page, but the sponsors of Fast API.
• 20:21
  It wasn't like enough for you to live off of.
• 20:23
  Yeah, yeah. And you know, like this is, this
• 20:25
  is quite fun. Is that like people come and
• 20:28
  sometimes people come and sponsor and give like, you know,
• 20:30
  like a couple of bucks, 5 bucks a month tame something like
• 20:34
  that. And it's like super, you know,
• 20:35
  like I appreciate it a lot and it's like, it feels very
• 20:39
  encouraging. But with that, it's very
• 20:41
  difficult to make a, you know, like a sustainable income
• 20:44
  because you get like, you know, like you get 100 and 100 people
• 20:49
  putting 5 bucks a month is 500 bucks a month is not, is not
• 20:54
  enough to live off. Then the ones that put the most
• 20:58
  are the ones that get something in exchange, like a badge in the
• 21:01
  dogs or like consultancy time or things like that.
• 21:05
  But then in the end is, you know, like it's sort of a
• 21:08
  transaction that, you know, like you're giving something extra
• 21:12
  for them to give you something back.
• 21:15
  And sometimes, you know, like it's also difficult for
• 21:17
  companies to justify giving money to, to, I don't know, to,
• 21:21
  to sponsor open source stuff without having something in
• 21:24
  exchange to show finance and to show the investors.
• 21:28
  And like all the stuff it's yeah, it's, it's I guess it's
• 21:32
  like it's difficult to balance. There are some things like for
• 21:34
  example, the open source pledge. Now I think that's that's
• 21:37
  amazing from those started from the people from Century and also
• 21:41
  people from Astral and Pedantic join and like a few other
• 21:45
  companies join there that they are, you know, like committing
• 21:48
  to give, I don't know, a certain amount of open source employee.
• 21:53
  They have some certain amount of open source a year or something
• 21:56
  like that. But The thing is that, you know,
• 21:58
  like the open source sponsorships are normally not
• 22:01
  super, super meaningful necessarily, at least not for
• 22:07
  the majority of of projects. So it's like it's it's
• 22:10
  something, but in the end it's also sort of a service or a
• 22:14
  project or transaction that you have to give away something.
• 22:16
  It's like a budget or something like that.
• 22:19
  But yeah, with the, with the open source fellowship, they
• 22:21
  will cover like, you know, like cover my expenses and then I
• 22:23
  will be able to just like go full time on open source.
• 22:27
  The, the, you know, like they will ask every once in a while,
• 22:31
  hey, what do you think about this company?
• 22:32
  But that was like, I don't know, like 4 times in a year or
• 22:35
  something like that. So it's, it's very, it was very
• 22:37
  little. It was actually just mainly
• 22:38
  focus on your open source. And it was also not like, you
• 22:42
  know, like here's a project manager, you have to work on
• 22:44
  these issues or you have to do this or that.
• 22:46
  It was just like, you do your thing, we just trust you go and
• 22:50
  build your, your stuff. You know what to do, just go and
• 22:53
  do it. So it was, it was it was super
• 22:56
  useful because I was able to work and like tackle very
• 23:00
  difficult things that's required a lot of continuous focus time
• 23:05
  and that the results and the value will be seen only after it
• 23:09
  was completely done. So for example, a migrating or
• 23:12
  like supporting fast API supporting Pedantic version 2.
• 23:16
  FUS CPA currently supports both version 1 and version 2,
• 23:19
  depending on whichever is the one that you installed.
• 23:22
  FUS CPA supports that one. So people can like do the
• 23:25
  migration and that, but then like getting that, doing that,
• 23:29
  getting to a point of quite a lot of work.
• 23:31
  And it's something that will have been very difficult to do
• 23:33
  if you just like put one or two hours in the nights and then
• 23:38
  like a bit during the weekend. It's very difficult to keep the
• 23:41
  pace and keep the context. So that, that was amazing.
• 23:44
  You'd still. Be working on yeah.
• 23:46
  That was the open source fellow sheet.
• 23:47
  That was 2023. By the end of 2023, I was seeing
• 23:52
  there were like, you know, like companies trying to build a
• 23:55
  cloud for first API cloud for five and trying to get like that
• 23:58
  feature, trying to get that going.
• 23:59
  And I was like, why will, why will someone else build it?
• 24:03
  And why wouldn't I build it? Because on one hand I could make
• 24:07
  sure that it has like, you know, like the best developer
• 24:09
  experience for fast API, because I am the first user of fast API.
• 24:13
  I build fast API for myself to use it myself.
• 24:16
  And then like building a cloud and building it for myself.
• 24:18
  And just like it's just so satisfied that everyone gets
• 24:22
  doing. Yeah, but like I'm building it
• 24:24
  for myself as I wanted to exist. And then it's also like, you
• 24:29
  know, like the community is already there.
• 24:30
  And I can make it super simple to integrate it with fast API to
• 24:34
  make it easy to integrate with fast API.
• 24:36
  And I can also ensure that, you know, like fast API kids being,
• 24:39
  which is something that is super important to me, that fast API
• 24:42
  kids being open source, fully open source with all the
• 24:45
  features like you can deploy wherever you want, however you
• 24:48
  want. I'm just going to make sure that
• 24:49
  you have an amazing developer experience with Fast API Cloud.
• 24:52
  So you want to drive as the Pi Cloud and stay there, But like,
• 24:55
  you know, like it's still, you can, you can use it however you
• 24:58
  want to use it, it it makes sense.
• 25:02
  And it was also like, you know, like there's a chance also to if
• 25:05
  there's some fruits that could be taken out of like all the
• 25:08
  work I put over the years on the open source, I would like to
• 25:12
  take a piece of that at least. So like, yeah, that makes sense
• 25:16
  as well. And figuring out a way, a
• 25:18
  sustainable way to have a funding for the open source
• 25:22
  projects. That was that was something that
• 25:25
  I have been like, you know, like trying to figure out how to do
• 25:28
  for four years. And like the open source
• 25:30
  solution was great, but it's not something that I can feel like,
• 25:32
  oh, I'm going to just like stay here forever in the open source
• 25:35
  fellowship. Like they probably wouldn't want
• 25:38
  to just like, you know, like pay me forever just to stay there,
• 25:41
  you know, like they were willing to extend it.
• 25:43
  But but it was like, you know, I should probably make something
• 25:47
  that make sure that all this stuff keeps working and so that
• 25:51
  I can also work on A and I get people to work on the open
• 25:55
  source projects, fast API type air sequel mode async, like all
• 25:59
  the all the stuff that I built that is already there.
• 26:03
  So what like, you know, like just the balance of everything
• 26:05
  together. You can't.
• 26:06
  Rely on the goodwill indefinitely.
• 26:11
  You have to at some point figure out there what is a more
• 26:16
  sustainable way. And this feels like it was a
• 26:19
  great bridge from not you were you were moonlighting on this to
• 26:27
  then it became your full time thing and now you have this
• 26:33
  sustainable way of keeping it your full time thing.
• 26:37
  And so that makes a ton of sense.
• 26:39
  I want to go into the difference or what you get with Fast API
• 26:45
  Cloud and how you think about which features or what parts go
• 26:51
  towards the open source versus what parts now go towards the
• 26:54
  company and also everything around that decision making.
• 27:01
  Yeah. This is actually this is
• 27:03
  something that I gave a lot of thought to.
• 27:06
  Building a cloud was not like, you know, like I was not trying
• 27:11
  to build a cloud. That's that's felt like daunting
• 27:13
  and it was daunting. It's been like a lot of work
• 27:15
  that we have been doing and it was like, can't I make, you
• 27:19
  know, like a simple product or something?
• 27:21
  But every time I will came up with something, it will just
• 27:24
  make sense to make it open source type SQL model.
• 27:26
  I think it was like, yeah, well, this has to be open source.
• 27:30
  Building a cloud. It was daunting, was a lot of
• 27:33
  work and I required a team and I required resources.
• 27:37
  But it had these had these very nice detail, this characteristic
• 27:45
  that they overlap. And like the conflict of
• 27:48
  interest between the open source and the cloud are are minimal.
• 27:52
  You know, like you have the open source is this way and then the
• 27:55
  cloud goes this other way and it's just like they just cross
• 27:58
  each other. But the open source, it doesn't
• 28:01
  really affect that much. In fact, it actually aligns
• 28:05
  quite well. If fast API is even better, you
• 28:07
  get more features, you can do more stuff with fast API.
• 28:11
  There's a higher chance that you will want to just use fast API
• 28:14
  in general. And if you use fast API in
• 28:16
  general, there's a higher chance that you at some point will want
• 28:18
  to try fast API cloud and try other service.
• 28:22
  So, you know, like it just made sense to to do something that
• 28:26
  had the least friction possible with all the open source,
• 28:30
  because it also simplifies all that conflict and like that sort
• 28:35
  of process like what goes in the pro version and what is the core
• 28:38
  and what is it now? Fast API is all pro.
• 28:41
  You get the pro for free. And if you want to deploy in
• 28:44
  fast API cloud, they just could just deploy to fast API cloud.
• 28:47
  But the open source thing is just like you get all the
• 28:49
  features that that are there and all the new features that we
• 28:52
  will build, like all the new stuff that we will make sure the
• 28:56
  fast API is just as good as it can be.
• 28:58
  And we keep improving on that. Then like you will be able to
• 29:01
  just reap those benefits no matter how you deploy it.
• 29:05
  And then on the other side, we can make sure that the point of
• 29:08
  fast API cloud is just the best developer experience ever.
• 29:12
  It has like, you know, like the most robust and resilient way to
• 29:15
  apply things that you get something that is just instant
• 29:18
  there, like you don't have to think or figure out or like, you
• 29:21
  know, like tweak a bunch of configs and they work errors in
• 29:24
  other languages. And you know, like all that
• 29:26
  process is, it's a, it's a lot. You've been through it.
• 29:31
  Yeah, yeah. Which is also the other reason
• 29:34
  why I, I, I, I realized and I decided that it was a good idea
• 29:39
  to build a cloud project. Before that, I was very much on
• 29:43
  the side of just learn to build everything yourself.
• 29:45
  And just like, you know, like install the Linux machines
• 29:47
  yourselves and just like build and set up the cluster yourself
• 29:51
  and just like deploy your things there.
• 29:53
  And actually, I had one of the, the main, the most prominent
• 29:57
  websites for explaining how to use an alternative to docker
• 30:02
  that was created by, sorry, an alternative to Kubernetes that
• 30:06
  was created by Docker. It was called docker swam,
• 30:08
  docker swam mode. And it was, it was a great
• 30:11
  product. It was quite lean, but in the
• 30:15
  end it didn't work out for them and they sold it to another
• 30:17
  company that put that on their, their Kubernetes Umbreva.
• 30:21
  So like, you know, Kubernetes one one way or another, but then
• 30:26
  Kubernetes is just massive, just getting to learn Kubernetes,
• 30:31
  getting to use it, getting to manage it and you just do it.
• 30:35
  And then you're just scratching the surface.
• 30:36
  It's just a lot, a lot of work. So you know, like seeing that
• 30:40
  and seeing that I before that I could tell people that, hey,
• 30:43
  just go and start like this other thing.
• 30:45
  And then you you're good to go. Like, you know, like you have
• 30:47
  the first version that is working in like in a week, in a
• 30:50
  couple of days. But then if I tell them, well,
• 30:53
  you have your fast API app now, gold length Kubernetes for six
• 30:56
  months, or you know, like try one product or the other, like
• 31:00
  maybe this one will work. That was not the great story.
• 31:04
  So that also convinced me like it's probably probably makes
• 31:07
  sense to have something that is dedicated to this type of
• 31:10
  application and to make it super simple for people to deploy fast
• 31:14
  API application and be being able to just focus on the code
• 31:18
  and the product and not on all the nuances of deployments.
• 31:22
  Yeah. So everything fit together and
• 31:26
  match to that point to say like, yeah, well, this is probably the
• 31:29
  best way to go. This is the way that I can have
• 31:32
  the biggest impact in people's code and the things that they
• 31:36
  can achieve and the things that they can do and build to help
• 31:39
  others on the open source and also on the product and like
• 31:43
  everything together. So yeah, you remind.
• 31:46
  Me of the founder of that company called I think it's base
• 31:50
  10 or base camp. No base camp is what it is.
• 31:53
  And they I have heard a few podcast with him on it and he
• 31:59
  talks about how when he sees or uses poorly designed or just not
• 32:07
  the best thought out software it drives him crazy and so crazy
• 32:13
  that he has started a few different companies to combat
• 32:18
  poorly designed software. And I think 1.
• 32:22
  Of them was even a parking lot software that his HOA or his
• 32:29
  condominium complex used and he hated it so much he just went
• 32:33
  and created a new one. If I'm.
• 32:36
  And. It reminds me of you kind of.
• 32:38
  You go through and you say, wow, this developer experience is
• 32:44
  painful. And then I'm sure there is a
• 32:50
  long period of time where you sit with it being painful and it
• 32:54
  like continues to be painful, but it eats away at your soul in
• 32:58
  a, in a way that for some of us, we just put up with it.
• 33:02
  But for you, you're like, I'm going to have to go and create a
• 33:05
  product around this. Yeah.
• 33:08
  Maybe, maybe some, maybe it's a bit like that, like, yeah, I
• 33:11
  don't know. And like, you know, like there
• 33:13
  are many tools that are just great, but they are also super
• 33:18
  complex or like dealing with a lot of nuances.
• 33:21
  And it's just like some layer of abstraction.
• 33:24
  And then sometimes just just having to deal with that is
• 33:27
  like, oh, it's a complex. Like, you know, like if you had
• 33:29
  to go and buy the the motor and the tires and the doors to
• 33:34
  finally assemble your own car is like, that's, that's just too
• 33:37
  much. You just go and buy a car.
• 33:40
  So, yeah, in, I think in many cases, it doesn't really make
• 33:43
  sense to assemble your own cars when your business is not
• 33:47
  assembling cars, your business is doing something to ride them
• 33:50
  or maybe not even riding them. Maybe you just need them to be
• 33:53
  able to get something across, but you need a car to be able to
• 33:57
  do that. And like, yeah, like I feel for
• 33:59
  many, many use cases being able to just like get the car and
• 34:02
  like not having to deal with that makes makes total sense.
• 34:06
  Yeah, you don't. Even need to create an Uber or
• 34:09
  you're not even an Uber driver using your car everyday.
• 34:12
  It's just that you're getting in a car and it's taking you from
• 34:16
  point A to point BI. Feel like that metaphor because
• 34:19
  that you at the end of the day, everybody needs to use a car or
• 34:26
  use AAPI in their software that they're building.
• 34:30
  And so how can you make that the least friction or the easiest
• 34:40
  for getting that outcome that someone is looking for?
• 34:44
  Yeah. Exactly.
• 34:45
  And you know, like that was the spirit of fast API.
• 34:48
  How can you make it so that you just write the code in the way
• 34:52
  that will be the most intuitive to you and then it does the
• 34:56
  right thing and does all this stuff that you needed to do
• 34:59
  underneath. By default, data validation,
• 35:02
  documentation, everything is just done by default and it just
• 35:05
  gets out of the way. So you can like focus on your
• 35:08
  code. You know, like when you see a
• 35:10
  fast API application, the amount of fast API code is minimal is
• 35:16
  it mostly is just like the actual code of the business
• 35:19
  logic. That is the idea to try to make
• 35:21
  it super simple to use the tool and you know like to do not get
• 35:27
  in the way of building the thing that you need to build since we.
• 35:30
  Talked last two. I have been thinking a lot
• 35:33
  because I think in our first conversation we hit upon the
• 35:37
  point of how you look at what abstraction layer to play on and
• 35:43
  where that decision is made or how you think about making that
• 35:47
  decision. It's only become more relevant
• 35:50
  since the new LLM boom because of all these new tools that are
• 35:56
  coming out and trying to abstract away different pieces
• 35:59
  of the LLMAPI calls. Or maybe it's the orchestration,
• 36:05
  or maybe it is something around the system.
• 36:09
  When you're building with AI, have you thought not necessarily
• 36:13
  about the abstraction for the AI systems, but what is your way of
• 36:20
  going about these abstractions and thinking through what would
• 36:26
  be the best abstraction here? Do you sometimes create an
• 36:30
  abstraction and then roll it back and say, actually no, no,
• 36:33
  no? Is it something that you're
• 36:35
  working with and it it slowly is boiling in your mind and you
• 36:40
  then all of a sudden have a Eureka moment?
• 36:43
  What does that look like? That's actually a very
• 36:46
  interesting question because like, you know, I do think about
• 36:49
  that a lot, but I don't get asked about that oven.
• 36:54
  I think it's more of like, you know, like it's boiling in the
• 36:58
  background and I'm trying to figure out what is the right way
• 37:01
  and just like, struggling with it.
• 37:02
  And then at some point I realized and figured like, yeah,
• 37:04
  it makes sense. And it's fun that I think about
• 37:09
  that a lot for the stuff that I built.
• 37:11
  And the same, you know, like with fast API type or SQL model
• 37:16
  asyncher and also the fast API cloud product for all of them.
• 37:21
  I avoided building them for a long time.
• 37:24
  For Fast API, I was trying not to build something.
• 37:27
  I was looking for other tools and like what was already there
• 37:29
  that I that could do what I, what I, what I wanted for, for
• 37:32
  the company I was, you know, like I have been told like how
• 37:35
  you should start a company for years.
• 37:38
  Yeah. Like that there were like I had
• 37:41
  like, yeah, a few people that were interested in me building a
• 37:44
  company and like it was, yeah, no, I don't, I don't think so.
• 37:48
  I don't have like a right product.
• 37:49
  It's not, I don't have something that will be the right
• 37:53
  abstraction to build. But then, and this is, this is
• 37:56
  the key point, this is how I think about it.
• 37:58
  When you when the new abstraction that you could build
• 38:02
  learning and using that new abstraction for your users, for
• 38:05
  your final users when learning, that is much less effort than
• 38:12
  they will have to put to learn the underlying thing.
• 38:17
  So you know, like for them to use your, to use YouTube, for
• 38:20
  them to use fast API, the effort, they have to put some
• 38:23
  effort into reading the docs into learning how to write a
• 38:26
  code for fast API into learning how to do that.
• 38:28
  But if they didn't put that effort, they will have to put an
• 38:32
  order of magnitude more effort into learning how to do
• 38:35
  everything by hand or more, you know, like orders of magnitude.
• 38:39
  So when you hit that point where it's like, OK, if instead of
• 38:42
  learning all the underlying stuff, people could learn a
• 38:47
  small layer in between in the middle and by learning that they
• 38:51
  just save so much effort in learning and debugging and using
• 38:56
  whatever is that goes underneath, then that's the
• 38:59
  point when it makes sense. And it's also when there's no
• 39:03
  abstraction that is already doing that because in some cases
• 39:06
  people go and like build another tool or build another framework
• 39:10
  or something. But it's like this has been
• 39:12
  pretty much the same that this other thing is already doing.
• 39:14
  So it's not necessarily that that viable, but it's when it's
• 39:19
  when you see repeatedly that some level of abstraction is not
• 39:25
  managing to, to, to be met, you know, like having something that
• 39:29
  is super simple and intuitive to use that you just have to learn
• 39:33
  a very minimal thing to get a lot of value.
• 39:37
  And the yeah, that's the point when I say like, OK, it, it
• 39:39
  makes sense. That's the point with, with fast
• 39:42
  API, that's how it happened. Like I was actually going to
• 39:44
  start contributing to another framework and the authors say
• 39:47
  like, no, I cannot really keep working on this.
• 39:49
  I'm going to deprecate this. I'm going to focus on something
• 39:51
  else. This was Tom Christie, the
• 39:53
  author of Django REST Framework, the author of API Star, which
• 39:56
  was like sort of the spiritual predecessor of Fast API.
• 40:00
  And then he started Starlet, which is the building block for
• 40:02
  Fast API. I'm going to keep working on
• 40:05
  this other framework that was called API Star.
• 40:08
  Then I said like, OK, this is this is the last notch.
• 40:11
  I'm going to jump into it and try to build Fast API.
• 40:14
  Similar with the with the similar with SQL model.
• 40:17
  There were some more tools that were trying to build an ORM that
• 40:20
  was based on type annotations and pedantic, but none of them
• 40:25
  were managing to, you know, like heat the sweet spots that I
• 40:30
  wanted subjectively. But like, you know, like the
• 40:32
  things that I wanted it to do the way that I expected it to
• 40:35
  do. Taking, taking, you know, like
• 40:38
  having into account all the how type annotations work, how
• 40:42
  default values work, how to completion inline narrows how
• 40:45
  all these things that are just like very tightly coupled to the
• 40:48
  developer experience. And they were not really
• 40:52
  managing to get to that point. And it was like, OK, I have to
• 40:55
  build this new tool, the SQL model tool.
• 40:59
  And it was, I really don't want to do it because hardly
• 41:02
  databases and SQL is so difficult.
• 41:04
  But he was like, you know, like I just have to do it because I
• 41:07
  have these ideas that are there, they are going to be useful.
• 41:10
  I just have to go and you know, like buy the bullet and build
• 41:13
  it. The same with the cloud, you
• 41:17
  know, like learning all the Kubernetes stuff and learning
• 41:20
  all the cloud products from the big cloud providers and all that
• 41:23
  is just so much work. And it's just so there's so much
• 41:28
  impedance mismatch between different tools that you have to
• 41:32
  figure out some weird way to monkey patch things to make
• 41:36
  things work. And be always careful with how
• 41:41
  those things evolve so you can update the monkey patch like,
• 41:44
  you know, like that's how the cloud is built.
• 41:48
  It's not ours. It's everyone's cloud.
• 41:50
  That's how it's all built. Spoiler over there.
• 41:53
  Yeah, yeah. That's.
• 41:54
  How every cloud is built. It's just like a lot of a lot of
• 41:58
  things, just like, you know, it's just tape everywhere,
• 42:02
  putting everything together and then having to deal with that is
• 42:05
  just so much work and so much effort.
• 42:08
  And then when they, you know, like it was the point that like,
• 42:10
  yeah, I know like actually if you want to deploy something,
• 42:13
  you just should go and learn one of these giant products or
• 42:17
  Kubernetes or Kubernetes on top of them or some cold cloud
• 42:20
  provider. There are several call providers
• 42:22
  that are quite good. They are doing a job of
• 42:25
  abstracting things a layer a little bit above the, you know,
• 42:29
  like the raw stuff. And they are quite good, but
• 42:32
  they are still quite general or generic for trying to be like,
• 42:37
  you know, like generic for every framework and for every language
• 42:40
  for everything. So it's always like this little
• 42:42
  friction of like, how do you do this for fast API?
• 42:45
  How do you make this thing work? That was the thing that I felt
• 42:49
  like it. It makes sense to have something
• 42:51
  that just works. Yeah.
• 42:55
  It's. Part engineer, part taste.
• 43:01
  How I hear it, because when you're thinking through these
• 43:05
  problems, you're really stewing on them, but you're also looking
• 43:10
  at what's going to be the most efficient and then what is going
• 43:14
  to be the most tasteful way or that developer experience side
• 43:21
  of things really makes me realize that you're thinking
• 43:26
  through not only, hey, this is the best way of doing it.
• 43:32
  It is this is the most developer friendly way of doing it.
• 43:40
  And even if it may or may not be the best way, because they're
• 43:46
  probably are potentially better ways that you could do something
• 43:50
  throughout each step, but then that adds that extra complexity
• 43:54
  that you don't need in the mix. Yeah.
• 43:59
  Yeah, exactly, Exactly. And The funny thing is that it
• 44:02
  feels a lot like taste and like an art and not a science and
• 44:07
  like, feels like, oh, it's just like, you know, like very good
• 44:10
  taste or something. But it's actually a giant list
• 44:14
  of specific tips. But you know, just like knowing
• 44:17
  all that by heart just helps a lot to see like this doesn't
• 44:21
  make sense. But it's not, it doesn't make
• 44:23
  sense because it smells weird or like, you know, like I feel it
• 44:27
  doesn't have a good. No, yeah, it's it's it's
• 44:30
  normally a very specific thing. It's like if you define the
• 44:34
  imports in this way, people, you final users are going to have to
• 44:38
  import from very different places and they will know what
• 44:41
  they will need to import. So better to define them these
• 44:44
  other way. But saying all that long phrase
• 44:47
  is longer than saying like, it's probably better this way, you
• 44:51
  know, So, so it's it's, it's a lot of I think it's just a lot
• 44:55
  of that which is like, you know, it's a it's a funny thing.
• 44:58
  I feel it's quite funny that several of the automatic SDK
• 45:05
  providers, so that the people that generate the SDKS for the
• 45:09
  big LLM providers like Open AI and several others, well Open AI
• 45:14
  Entropic and like, I don't remember most of them, they are
• 45:17
  building the SDKS. The Python is the case and well,
• 45:19
  like the several languages as the case based on open API,
• 45:24
  which is the thing that fast API is based on, Many of these big
• 45:27
  providers are actually using fast API underneath and they get
• 45:29
  like a nice open API as a result.
• 45:33
  But then many of these the case they have like, OK, what is the
• 45:36
  right way to build this in Python?
• 45:37
  And I ended up having conversations with several of
• 45:40
  them. I think like the right way is
• 45:42
  like doing this. So for example, using, you know,
• 45:45
  like this is one of those things that is sounds like taste, which
• 45:48
  is actually a very specific set of things that work.
• 45:51
  If you define the parameters of your functions as typed Dicks,
• 45:56
  then instead of pedantic molds the parameters of the functions,
• 45:59
  the inputs parameters of the functions.
• 46:01
  If you are building an SDK as type dates, then the editor will
• 46:05
  be able to provide auto completion and in line errors
• 46:08
  for the parameters that the users are providing without the
• 46:11
  users having to import some additional model.
• 46:13
  Without them having to import anything, they just start
• 46:16
  cooling braces and they start getting out of completion.
• 46:18
  And then if the outputs of those functions are pedantic models,
• 46:24
  then users are going to have auto completion when they hit,
• 46:26
  when they try to get an attribute or things like that.
• 46:29
  Two for one deal. Yeah.
• 46:31
  So it's. Like, you know, like it's just
• 46:32
  like that specific combination of use this here, use that
• 46:35
  there, this works this way, this works the other way, like use
• 46:38
  this tool underneath and like that should get you going.
• 46:41
  That ends up helping a lot. And then in the end, most of
• 46:44
  these SDK providers are using exactly that recipe that they, I
• 46:48
  think I told them or something, at least a few of them, I told
• 46:50
  them like, hey, you can do it this way.
• 46:51
  I don't know if some of the others like came up with it on
• 46:55
  their own, but like, you know, it's just like just those those
• 46:58
  tips, those any ideas of just having explored a bunch of that
• 47:05
  and trying to get like that best developer experience after using
• 47:09
  it as a final user? I think that is the main point,
• 47:12
  just like using something as a final user and trying to improve
• 47:16
  that own experience constantly. But when you say.
• 47:19
  Explored. Do you mean that you've tried to
• 47:23
  put a certain rule in place and then you've played around with
• 47:27
  it and you've said maybe this isn't good or maybe it could be
• 47:32
  a little bit better if we also do this and so you're adding on
• 47:36
  top of it or you're adding something and then taking it
• 47:39
  back? Yes.
• 47:41
  So it's actually both me as a consumer of code and other
• 47:46
  libraries when I use them and I feel like I this this is not
• 47:50
  great. Like why don't I get out of
• 47:52
  completion here? Now by this point I know how
• 47:54
  auto completion works internally so I know what they are doing
• 47:58
  wrong in their code. And if I had infinite time, like
• 48:01
  I will go and like make pull requests to everything.
• 48:03
  But but like, you know, like in my case, I see something, it is
• 48:07
  like you're like, wait, wait. You're like a Batman for open
• 48:12
  source packages. You go and get the auto complete
• 48:16
  man. They submit the PRI.
• 48:20
  Could be. Auto complete Man that should be
• 48:22
  my Halloween day costume giving. The Gotham City of GitHub GitHub
• 48:30
  Gotham City that is classic cultural.
• 48:33
  Space, yeah. Keep going, though, yeah?
• 48:38
  So it's like 1 One thing is just like using different tools and
• 48:41
  figuring out like how it feels to use them and then trying to
• 48:44
  figure out what will feel better if I use them this way or the
• 48:47
  other way. That's one thing.
• 48:49
  And the other thing is when building a tool will building a
• 48:53
  library or a product or whatever.
• 48:55
  And this actually applies to anyone that is building
• 48:57
  anything. If you put yourself in the shoes
• 49:01
  of whoever is going to be the final user, is much easier to
• 49:06
  optimize that experience for the final user to optimize and to
• 49:11
  make sure that you are doing something that works well.
• 49:13
  But for that final user, if you are not the final user is much
• 49:17
  more difficult then you have to hire someone that is like, you
• 49:21
  know, like everything on your neck.
• 49:24
  Checking that you what you are building is, is actually useful
• 49:27
  because otherwise you end up building something that is not
• 49:29
  useful for, for the final user. And then no one uses it and it
• 49:32
  doesn't really solve an actual product.
• 49:35
  As an example, when I was building SQL model, this was fun
• 49:39
  because I didn't, I didn't start writing all the code and they're
• 49:44
  like, OK, now let's try documentation.
• 49:46
  I started with the documentation.
• 49:48
  So it was like sort of documentation driven development
• 49:50
  is. So I started writing
• 49:53
  documentation explaining how this should work and then trying
• 49:57
  to write the examples in a way that should be easy to
• 50:00
  understand and easy to to work with.
• 50:03
  And then figuring out what do I have to do in the code to make
• 50:07
  this work. And they like, you know, like
• 50:10
  going in in the opposite direction just from the what is
• 50:13
  the final result and how do I make this final result actually
• 50:16
  work? And in some cases, I remember
• 50:19
  there were like one or two points where I have a feature
• 50:22
  somewhere in SQL model that will let you do something and you
• 50:25
  will be able to do that same thing in three or four different
• 50:30
  ways. Like you could set this
• 50:31
  parameter here, or you could also set it here, or you could
• 50:34
  also set it in this other place or condition and in this and
• 50:37
  that. And it was like, you know, it
• 50:39
  was very easy to implement. But then I realized explaining
• 50:42
  this, it's just so complicated because this, if this happened
• 50:46
  and this if this other thing happens, then the other.
• 50:48
  But if you try this, so the priority of the parameter is
• 50:51
  this one, you know, like it was such a long piece of content
• 50:55
  that was going to be so difficult for people to
• 50:57
  understand and then it was going to be difficult to use.
• 50:59
  If it's something that is difficult to understand, it's
• 51:01
  going to be difficult to use, you know, like it just has to be
• 51:06
  simple and intuitive. And then that was the point.
• 51:08
  Like I figured like, OK, I'm going to forbid these other
• 51:12
  three options that are already there already implemented for
• 51:15
  free, but I'm going to forbid them because they just, they are
• 51:19
  just going to complicate things when I try to explain them.
• 51:23
  It's track. Yeah.
• 51:25
  So the it's like, I think it's a bit of that of trying to put the
• 51:30
  heart of the final user and that helps guiding so much whatever
• 51:37
  is the thing that you are building.
• 51:39
  Dogfooding, man, that is so good.
• 51:42
  And I really, again, go back to the foresight to be able to say
• 51:51
  we're going to start with the docs and work backwards.
• 51:54
  And then when you're creating the docs, you realize this is
• 51:59
  complex as hell. I am not going to allow people
• 52:03
  to do it these three ways, even though I know that when I create
• 52:07
  it, you're going to be able to do it these three or four
• 52:09
  different ways. We're just going to say this one
• 52:12
  way is the way that we choose. We're OK with being opinionated
• 52:16
  here because we feel like it is best.
• 52:18
  And so that's all you need to know.
• 52:21
  Yeah. Yeah, exactly, exactly.
• 52:24
  That's pretty much like that. And this is strange because
• 52:26
  like, you know, as a software developers and engineer, you're,
• 52:29
  you are used to, you know, like being able to build things and
• 52:32
  like, if you have more options and you can make them work, I
• 52:35
  have like, you know, like more features.
• 52:36
  It's like, this is great. I'm such an engineer.
• 52:40
  Then, you know, if if you're such an engineer that, that,
• 52:44
  that you can build a bridge that takes you to many different
• 52:47
  places. And it's like, well, a bridge
• 52:49
  should take you normally to one single place.
• 52:51
  So it's better just to make one single bridge.
• 52:54
  So yeah, that that actually helps.
• 52:56
  That actually works well. Let's talk a minute about the
• 53:02
  community and how you go about prioritizing PRS and merging
• 53:10
  different issues that come up. Because there's a lot of
• 53:14
  activity around Fast API, a lot of people are using it.
• 53:18
  As you said, there's a lot of different competing interests.
• 53:22
  So how do you look at that and how do you make sure that A,
• 53:26
  you're not doing anything that maybe is going to ruin that
• 53:30
  developer experience, but then B is not shutting people off
• 53:34
  because maybe their whole business relies on some feature
• 53:39
  being merged. Yeah.
• 53:41
  This is this is one of those things that I feel looks so
• 53:46
  different from the perspective of the person that is building
• 53:49
  the entire thing than from the people outside of it.
• 53:52
  It's, it's quite strange. So like, you know, like the, the
• 53:55
  first thing is the people that are working on the open source
• 53:59
  stuff. It's just a handful not for just
• 54:02
  for fast API for most of the projects actually fast API.
• 54:05
  I'm quite lucky and grateful that I, well, now I get to pay
• 54:11
  people to work on it, but I also get like contributions from a
• 54:13
  bunch of people in the community.
• 54:15
  And I also have a session for the fast API experts, which are
• 54:18
  the ones that come and help others with their questions in
• 54:21
  fast API. So, you know, like they prove
• 54:23
  that they know fast API by helping others.
• 54:25
  And then like I can highlight that in the documentation for
• 54:28
  the hey, these are the experts and you know, like then
• 54:32
  automatizing all that to make it work with the dogs and
• 54:35
  everything. But you know, like the inflow of
• 54:37
  communication in GitHub discussions is massive.
• 54:41
  Before I had questions in issues, but then people will
• 54:44
  come and 90% or something like that of the things that people
• 54:48
  will writing issues were actually questions or errors in
• 54:53
  their own code. So it was, you know, like it was
• 54:57
  actually not, not really a boogie fast API then.
• 55:02
  So it was very difficult to manage.
• 55:04
  Now with the with having several people, for example, the experts
• 55:08
  that can check what are the questions that are coming up,
• 55:11
  whenever they see something that is actually broken, they just
• 55:13
  ping me. And that helps so much because
• 55:16
  they help me filter out like all the noise and figure out what is
• 55:19
  actually what is actually important, what is actually
• 55:22
  working then for all the open source PRS.
• 55:26
  So the first thing is because I have translations, there are so
• 55:29
  many translations open that are just like waiting for another
• 55:33
  native speaker to come and regret.
• 55:35
  So those just have to stay there for quite a while.
• 55:39
  I'm thinking of changing that and switching it to using LLMS.
• 55:43
  I'm already doing that for Spanish.
• 55:45
  And if the results are really, really good, I want to do that
• 55:49
  for the other languages because the results are quite good, they
• 55:52
  are consistent. These one of the things that
• 55:54
  LLMS are actually very good at. There are many things that LLMS
• 55:58
  are great at translating and doing it properly, they are very
• 56:02
  good at that. So I want to extend this thing
• 56:06
  that I did for Spanish to the other languages so that we can
• 56:09
  have a consistent translations for each of the languages.
• 56:13
  Also, because there are some languages that have a couple of
• 56:15
  pages but nothing else translated.
• 56:17
  So it will be better to have like, you know, like a
• 56:19
  consistent set of languages that are supported and then
• 56:21
  translating those. Then you know, like half of the
• 56:24
  PRS are just translations. And then there's a lot of others
• 56:27
  that some, for example, don't necessarily have tests or is not
• 56:31
  a specific clear use case that they are solving.
• 56:34
  So it's not obvious what what they are doing.
• 56:37
  And there are others that are actually that can be solving a
• 56:40
  problem, but also in some cases conflict with some other
• 56:44
  features or some other things that I want to do that will
• 56:48
  solve that use case plus other three use cases.
• 56:50
  So it was like, I am not going to merge this right now because
• 56:53
  then I have to maintain it. But then like, you know, like,
• 56:56
  just like closing it and saying like, oh, I'm going to do this
• 56:59
  in another way. Another moment is so, so rude.
• 57:02
  So yeah, it's, it's, is this a difficult balance of like how to
• 57:06
  manage all that and how to make sure that you pick the right
• 57:09
  things. And many PRS for simple, they
• 57:12
  look can get so complicated. You know, like in many cases
• 57:18
  people come and say like, oh, why haven't you married?
• 57:20
  Or why haven't you reviewed this like one line change PR Like
• 57:25
  because to review it, I have to check the other 5000 lines that
• 57:29
  were not changed and like how this one affected them and how
• 57:33
  like, you know, like how everything can break.
• 57:36
  It's happened a couple of times. Well, a few times that I merged
• 57:41
  something thinking like, OK, well, it probably makes sense.
• 57:45
  Yeah, like the use case is, the use case is sensible, sort of.
• 57:50
  And the code sort of makes sense, although I'm not sure why
• 57:55
  will we need to change it, but it makes sense.
• 57:57
  The tests seem to be passing like, you know, like this is
• 58:01
  touching things that I'm, I'm not sure if there's anything
• 58:03
  else touching, but then I make the release and then like
• 58:05
  something explodes somewhere else because someone was doing
• 58:08
  something weird with fast API in most of the cases is because
• 58:11
  someone is doing something weird with the internals.
• 58:14
  But you know, like I, I still try to not affect not even those
• 58:18
  use cases. So yeah, it's like this, this
• 58:22
  strange balance. I still review each one of the
• 58:25
  PRS from the ones that are changing the internal code and
• 58:28
  like changing, you know, like complex things.
• 58:30
  I still review each one of those and like make sure that they are
• 58:33
  they are good. Now that I have a team, I have
• 58:35
  like a few people that I trust that can tell me like, hey, this
• 58:38
  looks quite good. And then I can just like, I give
• 58:40
  it, you know, like I still give it a fair object, but at least I
• 58:45
  know that this is not something that is, it doesn't make sense.
• 58:48
  You know, like, at least I have a good priority of like, what
• 58:51
  are the things that I should focus on?
• 58:53
  And then to decide what PRS, what issues or what projects to
• 58:58
  work on and to what, what to focus on is also this balance of
• 59:01
  what is the thing that will have the biggest impact for everyone
• 59:04
  right now. And in some cases is some cases
• 59:08
  is even like another third party open source project that fast
• 59:12
  API depends on or something. And it's like this needs to be
• 59:15
  fixed because we are using it in fast API or it has a big
• 59:20
  interaction with fast API. So that is the thing that
• 59:23
  requires the the the biggest priority.
• 59:25
  You know, it's just I will complete for everything.
• 59:28
  Yeah, you know, you go. Off.
• 59:30
  And you have to fix other people's open source projects so
• 59:33
  that yours works. That's you doing your civil
• 59:37
  duty, Yeah. Or or the dogs fixing the dogs
• 59:40
  here on the yeah. The funny part about that phrase
• 59:47
  that you were saying is, yeah, it's just one line of code.
• 59:49
  But then at the end of the day, you have to go and see how that
• 59:53
  interacts with the other X number of codes, thousands of
• 59:57
  code, lines of code. It made me think about that Mark
• 1:00:01
  Twain quote where he said I didn't have time to write a
• 1:00:07
  short letter, so I wrote you a long one.
• 1:00:09
  Yes, something. Like that?
• 1:00:11
  Yes, and and it's it's kind of that same thing where you it's
• 1:00:16
  almost suspect if it's just one line being changed because then
• 1:00:20
  you go like what's going on here?
• 1:00:23
  Why is this one line needing to go in?
• 1:00:26
  And then also when you're saying.
• 1:00:29
  People have to. Trust you when you are not
• 1:00:33
  fixing one issue because you have the foresight to say down
• 1:00:38
  the road, I'm going to fix this issue and two or three more.
• 1:00:42
  And so it's that 2 for one or three for one deal.
• 1:00:45
  They just have to be patient. It feels like you almost need to
• 1:00:49
  have a public Kanban board with things that you're focusing on
• 1:00:54
  issues that you're going to be hitting so that people can know.
• 1:00:57
  OK, he it's on the backlog or now it's going, yeah, he's, he's
• 1:01:02
  working on it. All right, cool.
• 1:01:03
  Yeah, but you know, like I, I tried also a bit of that having
• 1:01:08
  like, you know, like there's a public road map or like these
• 1:01:10
  are the things that are like the main thing that on my mind.
• 1:01:12
  But then also because fast API covers so many people, there's
• 1:01:18
  someone here and there that just comes to ask for something that
• 1:01:21
  is not necessarily related to the road map.
• 1:01:24
  There's just like adding comments there and like, it's
• 1:01:26
  just like more communication to manage.
• 1:01:28
  So in some cases the the trade off of making the whole thing
• 1:01:33
  public becomes having to handle so much more communication that
• 1:01:38
  it ends up becoming not not as efficient.
• 1:01:41
  You know, at some point I was just answering issues and
• 1:01:44
  discussions and things like that and I was just spending the
• 1:01:46
  whole time answering them and not fixing anything just because
• 1:01:49
  I was answering just writing messages and you were like, this
• 1:01:52
  is not working. This is not sustainable.
• 1:01:54
  I can imagine that. One of the biggest time sucks
• 1:01:58
  for you is when you go on GitHub and you just had thousands of
• 1:02:03
  notifications and it's like that, like you're saying.
• 1:02:06
  So yeah, if you're making a public road map and that just
• 1:02:11
  gives more surface area for people to comment or for people
• 1:02:14
  to engage with you on top of your social media where people
• 1:02:19
  are commenting and engaging with you on top of the actual project
• 1:02:23
  itself. Oof.
• 1:02:25
  I I didn't. Think that through, but.
• 1:02:28
  If I were you, I would be afraid to even look at my phone.
• 1:02:31
  Yeah, exactly. Should turn it off.
• 1:02:34
  Mostly I have to. I have to disable the.
• 1:02:37
  Notifications thing, the e-mail for for GitHub, like I have
• 1:02:41
  notifications in e-mail from GitHub and at some point when it
• 1:02:44
  was like you have 10,000 and read it's like, yeah, no, this
• 1:02:47
  is not working. You know, like.
• 1:02:52
  Yeah, I just have to. Go to GitHub.
• 1:02:54
  Use the GitHub notification system and also rely on the on
• 1:02:57
  the fast API experts like a few are part of the unlike, you
• 1:03:02
  know, like people on their team that are just like working and
• 1:03:04
  they just come and review. There's a lot of PRS that they
• 1:03:07
  can review and even merge on their own.
• 1:03:10
  So for example, if people have been like working on like
• 1:03:13
  checking their repositories or like doing a translation or
• 1:03:15
  something like that, probably have bonding to Sophie or
• 1:03:18
  Alejandra or maybe Pasik, you know, like people might think
• 1:03:20
  that are constantly doing things like that.
• 1:03:23
  I also get a lot of help from the fast API experts like
• 1:03:25
  Marcelo, which is part of the pedantic team.
• 1:03:29
  There's also, there's also Judy Ludovico.
• 1:03:33
  There are several people there are just like, but they are not
• 1:03:36
  necessarily they are not in the company, but are helping a lot.
• 1:03:39
  They are like some of the experts that also, yeah, that
• 1:03:42
  helps a lot and helps me also surface whenever something
• 1:03:45
  breaks, whenever there's something that I need to put
• 1:03:48
  attention to. They, they are the ones that end
• 1:03:51
  up just like bringing me the, the, the important news.
• 1:03:54
  They're doing their civic duty to make sure.
• 1:03:57
  That your shit runs. So their shit can run too.
• 1:04:00
  Yeah. So I can do my CV3 as well.
• 1:04:02
  Yeah, yeah. Exactly.
• 1:04:03
  It's just paying it forward all. Around the Internet that that's
• 1:04:07
  great. Now the last question I wanted
• 1:04:09
  to hit you with was you have had the luxury of being able to
• 1:04:15
  focus on the tech for the past X amount of years now starting a
• 1:04:22
  company. I can imagine you are already
• 1:04:26
  seeing that you're getting pulled in a million different
• 1:04:28
  directions, whether it's hiring or it's just paperwork stuff or
• 1:04:34
  it is going out in public speaking, etcetera, etcetera.
• 1:04:39
  All of that time is going to detract from the actual
• 1:04:43
  building. How are you thinking about that
• 1:04:46
  as you move forward? Because at some point, like you
• 1:04:49
  know the project and you know the cloud, I imagine the
• 1:04:54
  insurance and outs of it, your stamp and your vibes on this
• 1:04:59
  make it what it is today. Yeah.
• 1:05:03
  How do you think about continuing that even if you are
• 1:05:06
  not able to put your fingerprint on each piece of it?
• 1:05:10
  Yeah, that's a very good question and it's difficult.
• 1:05:11
  Because it's indeed a lot of work doing extra stuff.
• 1:05:17
  And I really love the code. That's something that I really
• 1:05:20
  like to do. But this is, this is like, you
• 1:05:23
  know, like I have to do this other stuff so that I can get
• 1:05:26
  that product and I can use it. So, you know, like I can have
• 1:05:29
  the team working on everything. I just have to suck it and do
• 1:05:34
  the rest of the stuff that I have to do.
• 1:05:37
  But also I, I get the fortune to rely on people that are super
• 1:05:40
  clever and helping, helping me a lot with a bunch of the things.
• 1:05:43
  And also like, get the spirit of like, how is the project going?
• 1:05:46
  And like, it's hard to find a people like that.
• 1:05:50
  And it's hard to like, you know, like get the right people in.
• 1:05:53
  But once you start like being able to just like rely more and
• 1:05:56
  more on some people, that's, that's amazing.
• 1:05:57
  And there's also like a great feeling, for example, the the
• 1:06:00
  CLI, the new CLI, the faster PICLI, since a couple of
• 1:06:06
  versions had like the new terminal UI that was created by
• 1:06:11
  Patrick. And it's like this new set of
• 1:06:14
  CLIUI components that you can use to build CLI and it's open
• 1:06:19
  source and everything. And it's sold them by him.
• 1:06:22
  And like the same with the CLI that we have for the cloud.
• 1:06:25
  It's like just a lot of work by him that I can just like quickly
• 1:06:29
  check and see like, yeah, this all makes sense.
• 1:06:30
  And he's super clear. So I can just like say like,
• 1:06:32
  yeah, this all looks good. The same with yeah, just like
• 1:06:37
  sign the approved this, this all look good.
• 1:06:40
  There's nothing good, you know, like from time to time.
• 1:06:42
  So like why this? Why that?
• 1:06:43
  OK, this that is like the standards are terrible.
• 1:06:46
  So we need to follow the standards like OK, yeah, well,
• 1:06:50
  then I get it. Let's do it.
• 1:06:51
  Perfect. The same with the UI.
• 1:06:53
  Like, you know, like a lot of the work has been done by
• 1:06:55
  Alejandra is one of the team members that I can now say like
• 1:06:59
  this is a bunch of tweaks and I see like it's a lot of React
• 1:07:02
  code and TypeScript and like tweaking the Tailwind classes
• 1:07:06
  and stuff and like here and there, like yes, makes sense,
• 1:07:10
  looks good. The screenshots look good.
• 1:07:11
  But like by this point I can say like, yeah, I chose the code.
• 1:07:14
  It's like, fine, I prove it without having to, you know,
• 1:07:17
  like get the pull request and check all the code each bit by
• 1:07:20
  digit by looking at it. The same with Sobi, for example,
• 1:07:24
  she's been helping a lot with the open source, with diaper and
• 1:07:27
  with fast API, mainly with diaper that has been like the
• 1:07:29
  main, the main focus. But then I can see whenever she
• 1:07:32
  goes and like gives like a comment with a review, it
• 1:07:35
  normally explains what was the problem, all the references, all
• 1:07:38
  the things that were tried she already fixed up, like the tests
• 1:07:41
  and the dogs and everything. And I can just like go and say
• 1:07:43
  like, makes sense approved. So that that really helps a lot.
• 1:07:47
  It's difficult to get, you know, like to to that point and like,
• 1:07:52
  you know, it has to be also gradual, like kind of just
• 1:07:54
  suddenly say, like everyone just merge away whatever you want.
• 1:07:58
  Because, you know, like the whole point of fast API and my
• 1:08:00
  open source project is that I am so picky with the quality that
• 1:08:04
  everything has to go through me for those things.
• 1:08:08
  But then being able to have like more and more reliance on the
• 1:08:11
  team, that's that's amazing. And that's an amazing feeling
• 1:08:14
  being able to see like, oh, we are building this whole thing
• 1:08:16
  together. That's us.
• 1:08:17
  Yeah, it feels like you are. Learning to let go a little bit
• 1:08:22
  of the reins and trusting the team more and duplicating
• 1:08:27
  yourself and I, I like that you say it is a great feeling
• 1:08:32
  because then you can go and focus on other stuff if you know
• 1:08:37
  that you have the team. There and you.
• 1:08:38
  Trust the team to hold the same quality standards as you.
• 1:08:44
  The last thing that I wanted to mention is I think people can
• 1:08:49
  sign up for Fast API Cloud right now, right?
• 1:08:52
  Yes, so people can go and join. The waiting list is fast.
• 1:08:55
  apicloud.com. We I hope we are going to start
• 1:09:00
  letting people in soon to try out the beta.
• 1:09:04
  Yeah, I think, I think that will be something great for people to
• 1:09:06
  go and try and also just like keep using the open source
• 1:09:09
  projects because now they have a little more power behind them.
• 1:09:14
  So yeah, like I will say you're in good hands, but like, you
• 1:09:18
  know, I'm pious. Classic man.