Batteries vs. Speed: The Django/FastAPI Debate with Calvin Hendryx-Parker and Frank Wiles

This video features Calvin Hendryx-Parker and Frank Wiles at DjangoCon US 2026 in Chicago, Illinois, USA.

Batteries vs. Speed: The Django/FastAPI Debate with Calvin Hendryx-Parker and Frank Wiles
0:39:23
Published October 26, 2026
332 views

Few debates in the Python world generate more discussion than Django vs. FastAPI. After decades of building production systems with both, we've arrived at a simple conclusion: they don't actually do the same thing, and that changes everything about how you should evaluate them.

This talk walks through a structured, no-hype comparison across three areas:

What they share:

Python-native development experience
Async support
Ecosystem depth and active communities

Where Django excels:

Batteries-included philosophy
The ORM, admin, auth, and forms out of the box
A rich plugin ecosystem that makes full-stack web development fast and predictable

Where FastAPI pulls ahead:

Blazing performance
First-class type hints
A lightweight footprint ideal for shipping a focused API layer fast

Co-presented by two custom software development agency leaders who have made this exact call on behalf of real clients, this talk won't crown a winner. Instead, it will leave you with a practical decision framework: reach for FastAPI when you need a fast, focused API layer; reach for Django when you need a full-featured, maintainable application with the ecosystem already proven.

This talk was presented by Calvin Hendryx-Parker and Frank Wiles at DjangoCon US 2026 in Chicago, Illinois, USA
https://2026.djangocon.us/talks/batteries-vs-speed-the-django-fastapi-debate/

LINKS:
Follow Calvin Hendryx-Parker 👇
On Mastodon: https://Fosstodon.org/@CalvinHP
Website: https://sixfeetup.com/

Follow Frank Wiles 👇
On Mastodon: https://frankwiles.social/@frank
On X: https://x.com/fwiles
Website: https://www.revsys.com

Transcript

7,279 words · auto-generated · en Show

Automatically transcribed, so expect mistakes in names and technical terms.

0:15

Speaker 1: We didn't have time for the organizers to get the cage match uh deployed for us up here, but we figured Frank and I could probably make do somehow. Uh so wanna welcome you. Thank you all for joining us for Django vs. Fast API. a batteries versus speed discussion. Uh I think what we'll start off with though is there's really probably no wrong answer here. We don't want you to think that this is an adversarial conversation, much to the chagrin of many of the folks in the room who are expecting an all-out battle. you know, coming up here with the uh gloves on and and duking it out. But there's definitely gonna be some trade-offs that we're gonna chat about during the conversation.

0:51

Speaker 2: But I mean Django wins, right?

0:54

Speaker 1: I mean I I'm okay with Django winning too, or Fast API is pretty cool as well. But what I think what the value of the two of us getting together and talking about this is the perspectives that we bring. So I'm Calvin Hendrix Parker. I'm co-founder and CTO of SixFeed Up. And we've done projects obviously in Django, Zop and Plone over the years, and FastAPI now. And so I think we wanted to just kind of bring like the agency. We're both agencies, we both do similar types of projects, and then we both got a lot of perspective to bring to the topic itself. So I think You want to give a quick intro, Frank?

1:27

Speaker 2: Yeah, I'm I'm Frank Wiles. I'm the founder and president of Repsys, uh agency just like six feet up. Uh we focus though almost exclusively on Django. While we've done a little bit of fast API, uh we just haven't had the need. But I'm also on the Django Steering Council and uh hopefully everybody will see that there's there's really there's differences, but they are not huge, and you don't have to leave your comfy home ecosystem. uh to get some of the same benefits.

1:54

Speaker 1: Yeah. So you're saying you know a thing or two about Django.

1:56

Speaker 2: Just a little bit.

1:57

Speaker 1: Just a couple things. That's great. Well that that that's what we're here for. But I think we need to cover what we're actually talking about. So Frank, if you want to cover this one.

2:05

Speaker 2: Yeah, so fast API is obviously about APIs, and so we're not talking about the parts of Django that don't involve APIs. So we're not talking about forms and the and and that kind of elements. We're comparing Django Ninja specifically because it is a fast API-like experience, but inside of Django. Most everybody still uses DRF, Django Rest framework, and DRF is also a choice, but that's not what we're comparing today. We weren't trying to do a three-way comparison of fast API, DRF, and Ninja. So we're just comparing Ninja versus Fast API.

2:35

Speaker 1: But it may convince you to stop using DRF if you look at the n if you look at the numbers later and see what we we actually kind of came down to in the end. The Django Ninja is a really great comparison to the past API side of this. So if you've thought about both these options and haven't considered Ninja, that's definitely the way to go here. Starting with kind of like the context behind this, if you have a team who already has opinions and already has tons of knowledge and built up like stack of deep like learnings behind using tools like Django over a fast API, you have to take these things into consideration as you are looking at what choices you make. You may make different kinds of choices depending on the composition of the team.

3:18

Speaker 2: Absolutely. If if you don't have any experience in a web framework, like obviously you should look around and Taste test them all and make a decision. But if you have a huge deep history with something like Django, there's there isn't as a as compelling of a reason to use something different, right? Um also with the scope FastAPI is primarily about building APIs and what Django can build APIs, but Django has a lot of other things to it. So if you don't sh know for sure that your project is not going to stay an API for the long haul, you might be better served by choosing Django.

3:56

Speaker 1: And if you talk about the workload, uh behind the scenes if you have specific characteristics that may match uh Django's type of style of workload or may match more of the I. O. characteristics or some really special needs that come out of the fast API frameworks. You may have to leverage that as part of like your choice. The the frameworks actually, you know, aren't as important as what you're doing with them. Uh they each can stand on their own. They want to start well. closer to each other.

4:22

Speaker 2: Okay.

4:22

Speaker 1: They want us to like kind of snuggle, I think. In the back there. So yeah. It's it's more yeah, it's more than just a technology choice. It actually comes down to the the a lot of the human beings who are involved in the room.

4:35

Speaker 2: Absolutely.

4:35

Speaker 1: So let's let's cover a a a quick minimal API and Fast API and what this looks like. And I'm not going to give you a code demo here. I think the k the key aspect here is to look at the simplicity of this fast API code. A couple imports, uh a couple classes uh classes plus a route, and that is what you've got to get basically a basic fast API hello world style application up.

5:00

Speaker 2: Yep. And next up is Django Ninja.

5:03

Speaker 1: Wait, Frank, did you did you not change the slide?

5:07

Speaker 2: I I I did. I changed the slide.

5:08

Speaker 1: You sure? Wait, let's go back. Oh no. Forward? Oh yeah, you're right. Did we actually change the slide? Yeah. No, I think this the the again, looking at the differences in the code, the uh the syntax is actually not the decision point here. They can be very, very similar from a syntactic standpoint.

5:40

Speaker 2: Yeah, I mean that's the imports are named different. That's that's pretty much the difference.

5:45

Speaker 1: Yeah, yeah, it was very, very similar as you as you just saw from that example. Uh but let's look at the different batteries included. I mean Frank's gonna cover like the Django versus Ninja Django Ninja pieces here.

5:55

Speaker 2: So, you know, with with Ninja, you are using Django, so you can leverage all of that same Django knowledge and expertise you've had. And so that means you're probably using the Django RM. the Django admin, the whole rest of the Django ecosystem is at your you know at your fingertips. Um you can use WebSockets and ASGI. And we have this third-party app ecosystem that you can pull from that is large and mature.

6:20

Speaker 1: And then if you're looking on the Fast API side, it's a little less opinionated. So you bring your own ORM. The the the open API uh pieces are are built in which is nice because it's it's an API targeted framework. So if you are doing just that, it's gonna have a lot of pieces out of the box that satisfy those specific needs. but doesn't make opinion choices where on other parts. Like you can use SQL Alchemy, which is what I chose to do in our various demos. You've got an ad there's no admin predefined, which is a superpower of Django. But may not matter in some applications where you're just building a simple API over the top of a set of data and could you know be surface area you may turn off in Django anyway. Uh the again auth, all those kinds of pieces, not as opinionated. But it it's also a younger framework, so it's gonna have a lot less kind of things that have been brought along historically.

7:10

Speaker 1: That's just the the nature of of a framework that's really mature and has been built over uh lots of time and lots of battle-tested scars. So you kind of get look at both of those as you're evaluating the various kinds of choices you make.

7:26

Speaker 2: Basically, it forces these choices of the ORM on you. It allows for a larger and more rich ecosystem to develop Because you you have this common, you know signals are available in your app. You know, you know, various aspects of Django are going to be there, and so you can build an app that is more widely used.

7:45

Speaker 1: Yeah. I mean I'll say the Django team's done a tremendous amount of work putting async into the core pieces of Django and done it very intentionally and carefully over t over time. Where Fast API, that's just out of the box. That's the experience you get as you open the framework up and start actually implementing and building with it.

8:03

Speaker 2: So the batteries included nature of Django comes with a lot of benefits. So for example, this is uh a third-party app that we use a lot in our client projects called Django Activity Stream. It lets you capture Bob did this at this time, right? So the code here is saying send this action for the currently logged in user, commented on this. Here's this particular comment, and the target we were talking about was a particular listing. And then this lets you construct later a user timeline of Frank commented on the 123 Main Street listing.

8:39

Speaker 1: Yeah, so again with with Fast API you don't have nearly as many of these ecosystem of add-ons that have been created over time. But you could build it.

8:48

Speaker 2: You could absolutely build it. It's not particularly complicated.

8:50

Speaker 1: But should you build it?

8:52

Speaker 2: Probably

8:52

Speaker 1: not. But sometimes some of these batteries have a shelf life. Uh from our experience Yeah, we we came from a content management background doing a lot of work in the Plone ecosystem where we had some really robust built-ins in Plone, for example, like uh DC workflow. DC workflow is a finite state machine, workflow machine. It had lots of robust features built into it. And I found an equival a relative equivalent in the Django community called Django FSM. If you haven't tried Django FSM, don't, because it's not maintained anymore And that's where the problem kind of started. We got excited about it, deployed into a lot of projects, the maintenance slowed on it, you know, people moved from project to project or job to job. and lose interest or don't have the time to maintain these things, maybe an alternative arrives like Django

9:39

Speaker 1: FSM2, but you have to think it through like what you're buying, why you're bringing it in, all the aspects of these extra dependencies that come into your various projects and like what you own as the choices you've made. I think that there's a you know build versus buy or vendor uh diagram and uh again all these slides are all on the github so if you want to check this out it may be a little small to read on there But make sure you go through a can again an intentional process of thinking through what add-ons, what dependencies I'm bringing into my project. Is it small enough that I probably should either maybe vendor it or really just build in that little piece of functionality? So I'm not bringing along a lot of baggage and the potential uh downside of maintainers moving on to other projects or other interests.

10:25

Speaker 2: Yeah, I mean you have to think about the total cost of ownership here, right? Like it's It's not just, oh, I'm using this thing, but like, is it well maintained? Is it going to cause me problems later? Should I, you know, we shouldn't be using left pad. like packages, right? Like as just an industry. We shouldn't be doing that. That's just too simple. Write it yourself. Put it in your own code. But, you know, things like activity stream. Or, you know, OAuth 2, things that you, you know, that need careful attention and maintenance and you probably don't want to know all the details, you should absolutely be using third-party packages.

11:01

Speaker 1: Yeah. And then for building those simple pieces, I feel like FastAPI provides a really clean, simple canvas to build these small pieces of functionality. Django obviously gives you a lot of batteries, which is a the upside there. So you've got things built into like all the helpers and all the other pieces. But if you don't need all that, it's still it's just a lot more stuff you're dealing with. Let's talk about async frank.

11:24

Speaker 2: Okay.

11:26

Speaker 1: Do we actually need it?

11:28

Speaker 2: Probably not.

11:30

Speaker 1: Right?

11:31

Speaker 2: You probably don't need async. It's probably more trouble than it's worth for 98 % of projects.

11:43

Speaker 1: Just the

11:44

Speaker 2: just a yeah, there's like three of us.

11:46

Speaker 1: Yeah, yeah, yeah.

11:47

Speaker 2: Again, read the docs back there, yeah, right.

11:49

Speaker 1: He's got requests.

11:51

Speaker 2: That's when that sort of stuff really matters, right? And we'll show later. Um, I don't think it's on the next slide, but yeah, we're we even use we end up doing the part of Django async without doing async I. O. uh. The part that you need in a Django app that typically you want async is the communication to the database, and you can use a G event backend and get Async to the database without having to write await everywhere.

12:17

Speaker 1: So why do we even care about Fast API?

12:19

Speaker 2: Well, um you you it's it's still a really good choice.

12:23

Speaker 1: It is, yeah, that's true. But I there's been many a keynote given on this topic of like async or not async. I think async has been obviously a hot topic in the community, a lot of people looking in from the outside who don't understand. Maybe the Python ecosystem of tools or like, oh, maybe you haven't had async as a a native from day one type feature. But it's absolutely here, absolutely usable, but you maybe you should consider what you're doing and whether you actually need it. There are specific kinds of things like reading from file systems or places where the the the global interpreter lock may block you from from activity, but many people don't have this kind of a need.

12:59

Speaker 2: I think people m mistakenly think that it is magic pixie dust that you spread on your project that somehow just immediately makes it faster.

13:06

Speaker 1: No, it immediately makes it more complex and harder to debug. It would be the magic pixie dust you just spread on your project. Now, that said, obviously very valuable in these kinds of cases when you've got lots of concurrent I. O. lots of parallel services, lots of like web sockets and long-lived connections, which are also problematic in their own right. So again, look at your actual architecture, evaluate why you're using these kinds of tools and why you'd want to use them. Uh but it's not magic.

13:34

Speaker 2: Not magic.

13:35

Speaker 1: You you will you will end up in it sounds faster land.

13:40

Speaker 2: Yeah. And and it intuitively sounds like, ooh, well, this will make my thing faster, but it in most cases it it's not something that you actually need to do, right?

13:48

Speaker 1: Yeah. So again, kind of a choice here on whether you've got specialized parts or non-specialized parts of your API. Building out a monolith plus a focus service can be actually a feature. So in this case, you can see here we've got the Django uh pieces in here. But we may actually have other specialized API services with Fast API playing a role or a part there as just a side player or a really fast implementation of a very small, slim uh piece of of work.

14:17

Speaker 2: Yeah, we've had a lot of projects where a monolith is appropriate up to a point, but then there is one particular piece of the puzzle that needs to scale wildly differently or use a different data source. And sometimes it's beneficial to break that out as a service without going full microservice when the rest of the app has no business being a microservice.

14:38

Speaker 1: Right, exactly. Shall we get into the fun part of the talk?

14:43

Speaker 2: This is the cage match.

14:45

Speaker 1: So wait, did you bring the gloves?

14:47

Speaker 2: No, I didn't. This is a full contact cage match.

14:51

Speaker 1: So all benchmarks are biased, including ours. I think again, we wanted to make sure we set forth at least a fair playing ground with what we built. Inside the repository you'll see a research folder that has some demos in it. And there are two different demos that we'll go over. But as we evaluated how we wanted to present these demos, we didn't want it to just be a raw throughput like uh Apache Bench style uh benchmark against a single endpoint. We wanted it to have some sort of behaviors that would be demonstrating value being delivered as part of the application. So we looked at equivalent behavior, you know, behavior and validation. We we each wrote, I wrote the fast API parts, Django wrote or uh Frank wrote the Django pieces for each of these demos

15:39

Speaker 1: to try and make them as similar as possible as far as like the signatures and the database versions and the versions of Redis and the versions of Python. So we weren't evaluating a difference in the version of Python. We were evaluating a difference in kind of as close as possible to the the various framework versions. Again, pend everything, set up hopefully similar concurrency levels, similar database connection levels as as we could across each of these pieces. We had a shared set of data that we generated that each of the projects loaded up as a seed into the the various uh demonstrations here. And then obviously the same uh methodology for doing the warm-up and repeated measuring across it. So you you'll see some of the results here.

16:19

Speaker 2: And you know it's fair because um Django doesn't completely win on the performance, right? We didn't cheat.

16:26

Speaker 1: I mean we don't think we expected I don't know we didn't expect it to win on a raw performance standpoint. But I think you'll be surprised. So the very first scenario was a zip code type ahead. So given this request string of a zip code and and be able to start typing a couple characters, could you build an autocompleter that would respond quickly back to you. So again, Redis SPAC's there's no relational database here involved in this mix at all Uh we wanted to look at like ex no real external I. O. there's no s there's no ORM. Uh it's literally just a very thin service on top of a Redis cache that is returning results as fast as possible.

17:03

Speaker 2: And we thought this was More fair and more realistic than just returning hello world in JSON.

17:09

Speaker 1: So if you're going and doing some amount of work, obviously Redis is going to be fast in both cases. Not a big deal. Let's look at the results. If you look at the zip look uh zip lookup here, we've got fast API in blue and Django in green. Uh you can kind of see here that obviously it's fast, but they're both fast. These numbers are in milliseconds, by the way.

17:34

Speaker 2: And this is a sustained 200 requests per second on my laptop.

17:38

Speaker 1: What does that mean? Like 200 requests per second? What could people compare that to?

17:41

Speaker 2: It's 26 million web requests a day. Right. Like that's a lot. That's not your average internal conference room booking website, right?

17:52

Speaker 1: Right. So you you can see we got the uh three times uh lower P99. But how many people are I mean, maybe you can explain like the P50, P95, P99.

18:02

Speaker 2: Yeah, so P50 means that fifty percent of your users Got an answer in one millisecond. And up to 95 % of your users got it in three milliseconds with Django. And

18:14

Speaker 1: unacceptable, Frank.

18:15

Speaker 2: Totally unacceptable, right? Um we should be able to get that down to two with some concerted effort, right? Um and then a P99 means that 99 % of your users got their response in six milliseconds or less. Uh and but it is three times faster with fast API uh because it is only two milliseconds there. I'm here to say that that probably doesn't matter to anybody.

18:39

Speaker 1: For most for most folks.

18:41

Speaker 2: I mean exactly. It matters to Instagram and Reddit and and sites like that, but not probably you. So it's speed is not always the reason to pick something.

18:49

Speaker 1: Right. The second demo, uh Frank and I built a little app we called Zealot. Think of Zillow, cross with Reddit, and what the hilarity would ensue if that existed. The reason for that though is we wanted to incorporate Postgres, uh exercise the ORM, have multiple tables of data, have table have things that were referring to blobs on disk potentially. uh because we had fun images of the the houses you could go comment on of course in in this system. Uh it includes the zip code demographics, you know we've got Joins going between homes and photos. There's optional upvoting and downvoting uh built into this API of the system. But again, more realistic uh

19:35

Speaker 1: dealing with connection management. That was actually one of the things as we were building out the benchmarks, we had to sit and kind of fiddle with that. The very first benchmark you did what we're doing.

19:44

Speaker 2: Yeah, we we yeah, it failed. Like I it was like four like ten times slower and it was yeah, I had some configuration problems.

19:51

Speaker 1: Fast API is faster, but we didn't think that Django would be ten times slower.

19:55

Speaker 2: Yeah, but it was just a configuration problem on my part.

19:59

Speaker 1: And how long you've been doing Django for, Frank? A little while. Well, I think this this show showcases that the out-of-the-box experience or the naive approaches to many of these performance problems will land you in this same spot. This is that I don't think this is uncommon. And with some very minimal concerted looking at what was actually going on, doing a little of the bit running the benchmarks exposed what this problem was. So this is a great way to take a look at how you tune the application and Django, you know, ended up not being ten times slower, which was uh obviously more what we were hoping for.

20:31

Speaker 2: And I asked Claude too. Uh

20:33

Speaker 1: I th I think we asked I asked I asked uh GPT.

20:36

Speaker 2: Okay.

20:36

Speaker 1: I had soul on my side I think. So if you wanted to look at a guess Yeah, right. So the the results here. So again, in milliseconds. We're only looking at like a 2x slower on Fast API, but in a scale that probably matters to almost no one again in the room.

20:58

Speaker 2: And this is just going to show you that your scalability problems in almost all web-based things is with your data store. It's not the framework. I'm sure that if we wanted to get max performance here, we should probably just ditch both of these and do this in Rust, right? Like and we would get that down from the 30 milliseconds to six milliseconds again. But you know, we probably also don't need that.

21:22

Speaker 1: And there's also no fancy caching in here. This is this is literally ORM performance right to the database. Doing those joins across multiple databases. And again, this is not the last one was 200.

21:33

Speaker 2: This is 300.

21:34

Speaker 1: This is 300 requests per second in this this real real simulated application. So Uh no failures. We had what 18,000 responses per trial as we went through and warmed up the caches and ran through these pieces. All of this was done with a tool called Artillery, which is a great benchmarking tool on the back end. All of this is in the repo for you to go explore and dive deeper in. I think if anything, Hopefully this helps people grab a couple of new tools that they haven't seen before so they can go dive deeper in on the performance of their existing code and use the patterns and the and the kind of recommendations we've given, which is really to go how do you figure out where the the pinpoint the problems, make the tuning fix, rerun the tests, and validate that you actually made a change that was beneficial.

22:19

Speaker 2: And then one of the diff other differences between the two of these in terms of the benchmark is this is running four replicas, uh where the first benchmark was just one replica, which more approximates a real app. Right. You're going to have several WISCI processes or ASCII processes running on different machines. And so this more simulates a real world um scenario.

22:40

Speaker 1: Yeah, I think you were using Ubicorn. No, I was using Ubicorn.

22:43

Speaker 2: And I'm using uh Gunacorn with G event.

22:45

Speaker 1: Yeah.

22:46

Speaker 2: And so that was the that part does async to the ORM, uh, but your code isn't async. Yeah.

22:55

Speaker 1: Normal normal looking Django code.

22:57

Speaker 2: Yep.

23:00

Speaker 1: The fast API code is very, very beautiful. Very clean, very uh easy to understand.

23:06

Speaker 2: It is pretty clean.

23:07

Speaker 1: It is very clean. I mean, I will say it's very clean. Uh it there is a benefit to a very small framework in that if you've got a very small task, it's it's gonna be a lot less overhead to manage and maintain. Faster is not the same as better. So I think we hopefully demonstrated that like you have to look for the bottlenecks you actually have. This is gonna depend on your specific workloads. We couldn't give you a global, just change this one. piece of tuning and everything will be better, uh type advice?

23:36

Speaker 2: Not really, no. I mean caching is usually the answer, right? But like not always, right?

23:41

Speaker 1: Yeah. So I guess this is just kind of just a recap of like it really just depends. Uh I hate saying that on stage to everyone who's looking for a a magic uh key to just unlock the performance pieces. But we've given you the tools to go find where you can go stick that key in and unlock those pieces.

23:59

Speaker 2: And again, it's the like we said earlier, the total cost of ownership of your app, right? It's where do you have experience? Where do you feel comfortable? Pick that one.

24:07

Speaker 1: And speaking of total cost of ownership.

24:08

Speaker 2: Ooh, we got deploys.

24:10

Speaker 1: We're going to talk about deployment. Because how many hours have you toiled trying to get apps deployed? And each, yeah, each of these pieces have uh A happy path and a very simple path to getting deployed. If you've not checked out Fast API Cloud, so the Fast API folks have built up a service where literally in the Fast API package You can type this command and it will ask you to pop up on a window with an OAuth and log in, and then you when you say go, it deploys for you. It's it's literally the one command and you're done after you've done the auth piece. Very, very simple. It's a very much a happy path. I've been playing with it and it it's fun for lots of little toys. It may even be fun for uh production level uh workloads. But things typically or r

24:55

Speaker 1: rarely stay that simple. I think Django Simple Deploy.

24:58

Speaker 2: Django Simple Deploy is very similar. Obviously there's not one service out there for deploying Django, so it targets several. And if you're using one of those services, it's a great way to make it easy on yourself and get your app deployed.

25:12

Speaker 1: But real production.

25:13

Speaker 2: Real production is usually more complicated.

25:16

Speaker 1: Right. And so what's nice about these two frameworks, FastAPI and the Django framework on Ninja, you're typically going to be building a container. And as you get into any kind of scale, you're using some kind of container orchestration. I think we both prefer

25:30

Speaker 2: Kubernetes.

25:30

Speaker 1: Kubernetes. But it may not be the popular choice yet for your organization, but maybe it should be.

25:36

Speaker 2: Yeah. I mean it's overkill for a lot of projects, but it is becoming kind of the lingua franca of ops these days. Um it's often easier to ride that wave than it is to uh kind of try to swim against it and do your own thing in a different way. Um it's I don't know for sure that Kubernetes is going to be something I'm using in five years, but I know whatever I'm using in five years is probably very much shaped like Kubernetes. There may be an alternative that comes out that is better in in ways, but it's going to be very similar.

26:07

Speaker 1: But each each of the hypervisors like Amazon, Google, have I mean, I think Amazon has at least nineteen ways to run containers, different ways to run containers. And you can deploy Kubernetes and use the same thing on all across all of your providers. So I would I would urge folks to check that out. Unless you are so heavily locked into the Amazon ecosystem and that really matters to you. I I don't like the feeling, but uh I even as a an AWS person uh from time to time, I still recommend folks to evaluate what makes the most sense for you. And in this case, being able to deploy those containers have a system that makes sure that they stay alive and rolls out your changes for you. Sounds like Kubernetes.

26:52

Speaker 2: And you know, to be clear, the deployment here doesn't really change if it's Fast API or it's Django or it's Go or Rust, right? You're gonna have something that's shaped like this. the this layout here. You're gonna have multiple web servers, some sort of primary data store of some sort of database, some sort of caches. It's going to look very similar. It's just gonna be different code in those containers.

27:12

Speaker 1: Yeah. Well and then things that are also on the bottom here, like migrations, for example. having tasks that handle migrations, observ observability, secrets. A lot of this benefit comes from adopting a an orchestration platform like Kubernetes because you can bake those in. So they all just happen and no one has to think about them or push a button to make them happen.

27:32

Speaker 2: And it also makes it easier to be cross-cloud or multi-cloud. Yeah. Because I for example, if I build a tool that works F the way I wanted to work with Kubernetes, it works the same in AWS or Google or DigitalOcean or Linode or or or or right. Obviously if your team already knows Django, I don't see any reason why you would Do use anything else. Um when you're adding an API to an existing project, it's much easier to just use something like Ninja or DRF. than it is to duplicate all of the logic of all your business logic in another framework.

28:18

Speaker 1: Pretty solid advice. It's hard to beat the batteries that are built into Django. So when we lean toward Fast API, again, if you have a team that isn't familiar with either of these frameworks, maybe you've got a very simple specific task. You're only going to be building an API or many little APIs on top of this Fast API makes a lot of sense. Not only is it faster from a rec response or request standpoint, it's going to be smaller and more tight around the implementation of these just strictly API pieces. As soon as you need to add on a UI or an admin or some other like major piece of functionality, that's when you might want to still consider the Django Ninja route. Uh the other aspects is again the deploy routes are going to be very similar. There's lots of

29:03

Speaker 1: similarity and common ground uh between the two frameworks and obviously we're using Python which is a a win for everybody involved And I think our thing is you can use both. If you've got a specific product, but you want to be able to have Django for that. There's nothing saying you can't actually put in a fast API piece on the site for very specialized workloads that would have actually just been simpler to code up that way.

29:27

Speaker 2: Uh I have a client that recently uh debated Ninja versus Fast API and they went with Fast API for a non-technical reason. They were worried that they were getting pigeon-holed career-wise with Django, and they wanted to be able to, you know, realistically put fast API on their resume for the next job in case They, you know, the next company they worked for was a fast API shop. And it's not a reason I would have chosen it, but I can understand the logic, right?

29:52

Speaker 1: No, I think that totally makes sense. Um but over overall Adding the two together does add complexity and and complexity must earn its keep. There has to be a true value to the organization to be able to use both these tools simultaneously. Don't just use both of them because they both look flashy and and both seem to m meet your needs. truly evaluate whether both of them determine deserve to live into your environment. So again it comes down to that first slide around context. You know valuing your team's knowledge understanding what the the culture has been historically and where you want the future to be uh may actually be uh how you determine which ones you pick.

30:34

Speaker 2: And then like for measuring your workload, one of the things that people, you know, look at when they see benchmarks of say like Django REST framework versus uh a fast API is They don't realize that the slowness there is not Django. It's it's you know, the way DRF does serializers is just slower than Pydantic in Rust. Right. And so that's the bulk of the speed difference in a lot of a lot of situations. And people mi miss that for some inherent slowness in Django.

31:04

Speaker 1: Yeah. And so make sure you can buy the batteries for leverage when you can use something like the activity stream uh piece right on top of Django without having to really move much of a finger to get that done. Big win there. But

31:15

Speaker 2: yeah, then you know, you should not be afraid of building your own code, obviously. You you don't have to do everything with third party apps, and it's you know it's perfectly reasonable to Use something like Fast API or something like Flask that is very kind of bare bones when you have a bare bones need and you want to make all those decisions and hopefully you know you've got good reasons that you're wanting to make those decisions. Uh but that's only for you to know, obviously

31:38

Speaker 1: All right, Frank. Hopefully no one ended up with too many black eyes.

31:41

Speaker 2: No, no, I'm good. I'm good. But we've left it plenty of time for questions because we kind of assumed that this would generate a bunch of questions. So hopefully people have some questions.

31:58

Speaker 1: We do have a mic mic runner here.

32:00

Speaker 3: Thank you for that. I just have to ask about Django Bolt. Have either of you played with that or have public thoughts to share?

32:08

Speaker 2: I have not gotten a chance to play with it, but I really want to.

32:11

Speaker 3: So for those who don't know, it's faster than fast API, Django rewritten in Rust and other things.

32:17

Speaker 2: Yeah.

32:17

Speaker 3: But

32:19

Speaker 1: does it matter that it's that much faster?

32:21

Speaker 2: I mean, fast is cool, but yeah, but yeah.

32:31

Speaker 3: Thank you both. That was great. My question is, given that FastAPI has an order matitude, more downloads on PyPI. What would each of you would like to see Django do differently from a marketing perspective to try to gain some ground back given that, you know, it's kind of it depends on which framework you should choose.

32:51

Speaker 2: So I think downloads are not a great measure, just like I don't think GitHub stars are a great measure, right? Um I don't think it's a bad measure. It's better than stars, probably. Uh but You know, you have to factor in that a lot of this comes down to like how many projects have CI and have you know automatic AI agents opening PRs and doing fresh downloads, right? Uh I mean that may be a third of Django's downloads, right? Who knows, right? Uh you know, it may be only 10% of fast API. Don't know, right? Uh so like I think it's a it's a it's an odd measurement, but I get why people use it. Um I forgot the last part of your question, I'm sorry. Oh see, different from a marketing perspective. Yeah.

33:35

Speaker 1: I think more talks like this need to be given at more conferences so people will recognize that Django Ninja is a very solid choice and you get all the benefits that we've had of the of a long history, but yet we are still modern. It is still a very much with the current times framework that can do Async can handle the loads and the speeds that would satisfy ninety-nine point nine nine percent of most people's needs. And I I don't think m enough gets said about that. at other at other conferences. I mean obviously we're in a f very friendly room here, but I think that needs to be said in other places.

34:11

Speaker 2: Yeah, I mean everybody hopes that they're going to be the next unicorn and that they, you know They get billions of dollars of funding and they have a huge scalability problem, but they're you know, it's like getting into pro sports. It's probably not going to happen to us, right? Um

34:23

Speaker 1: But we do have a Django pony.

34:24

Speaker 2: We do have a pony, we have a pony, we got we got that going first. Um actually one of the things is like seeing things like uh in Sarah's talk uh before showing that pull requests are going up to Django, right? Some of that may be AI uh helping, but Django's still there. It's still moving. It's actually moving faster over the last few years than it has. So I think some people have this opinion that it is dying. But it no, it's just boring, right? It's boring because it's good.

34:50

Speaker 1: And and then that helps a lot of teams with not having a lot of chaos in their projects is that you want to use those boring tokens. Uh and you only get what one one exciting token of a new thing you can bring into a project. And that that's kind of the rule that most folks forget forget about when they go after all the shiny.

35:18

Speaker 4: Thanks for for the talk. In the conclusion you say that uh if the team already used Django there is no uh reason to to change or if you want to start from scratch. Fast API can be a simpler solution. This has been something that I heard for a long time also about uh Django and Flask, for example, it's very common. But actually what I saw is quite the opposite uh in the sense that if you are starting from scratch, what I said also having some Django girls or other workshop with newcomers is that if you want to start from scratch in a simple project that involve uh the web page, login

36:05

Speaker 4: at the RM and the database, starting with fast API or

36:09

Speaker 1: That's harder, I think.

36:10

Speaker 4: It's harder. I

36:11

Speaker 1: I agree with that.

36:12

Speaker 4: So uh if you want to be s a simpler start, maybe Drang already give you or the answer you need if you want to do basic things that is storing your data and showing on the website. So maybe we we have to promotes better the fact that it is not true that starting with a simpler tool is simple But quite the opposite. If you want to start and you don't know how to search for uh O RAM for Fast API can be an hard task. And maybe we can promote this better.

36:46

Speaker 1: Yeah, I I think the opinions Django brings to the table are definitely way stronger for exactly that use case. I like FastAPI's unopinionated piece because I do have opinions about the other pieces I bring along. Like I want to use SQL Alchemy, for example, or I'm in a specific situation where I'm deploying into Cloudflare workers and I need something ultra like slim to deploy because there's just constraints in that environment. I can't bring more than what is it, five megabytes uh to the containers that I'm going to run at those various edges. I've got like other kind of weird opinions that draw me toward using FastAPI for specific pieces like that. I think for the newcomers, you're right. I mean I I would hate to have to like go make decisions about how do I do uh temp what templing engine do I pick and how do I wire it in and how do I like

37:34

Speaker 1: wire up the right ORM. I think those are hard and shouldn't be uh approached by beginners until they've gotten their feet wet with a tool that makes those uh decisions for you.

37:44

Speaker 2: And I think one of the things that's different is that I think some people when they say this is simpler They don't mean for new users, they mean for very experienced developers that this is simpler. So a fast API or a Flask is easier for somebody like from people in this room to quickly spin up something that talks to just Redis. Where if you use Django Start Project, you have to figure out how do I turn off the database. Right? So that's it's not simpler in that case, right? Um I I have to do a bunch of work to just talk to Redis and not a database, right? We're assuming there's a SQL database in the mix, right? So For somebody who's very experienced, it's like, okay, here's less steps. I don't have to turn off a bunch of stuff to use Django. But for a newcomer, you're absolutely right.

38:29

Speaker 2: It's harder to get going that initial project in something that's not Django.

38:34

Speaker 1: And we should all agree that we should strike the words simple and easy from our vocabulary when talking to folks about these kinds of things.

38:42

Speaker 2: You're absolutely right.

38:46

Speaker 1: Wait a minute. Am I talking to Claude? What's going on here? We still got time for questions.

38:56

Speaker 2: Surprised no one's asked me about G event yet.

39:00

Speaker 1: Maybe no one has that much performance problem.

39:03

Speaker 2: They don't care. Yeah.

39:04

Speaker 1: It's all right. Well, with that all said, thank you all for uh being out here. I mean Frank and I are obviously around for the whole presentation or conference.

Conference

DjangoCon US

August 24 - 28, 2026

Chicago, Illinois, USA

Note: We understand that names change, people change, and bodies change. We respect each individual's journey and privacy. If you have any concerns about a video or need us to remove content, please don't hesitate to contact us. We will handle your request with care and promptly address any issues.

More videos by Calvin Hendryx-Parker and Frank Wiles

More videos from DjangoCon US