Scientists Meet Django: Building Bridges Between Research and Software with Barkha Jain

This video features Barkha Jain at DjangoCon US 2026 in Chicago, Illinois, USA.

Scientists Meet Django: Building Bridges Between Research and Software with Barkha Jain
0:26:44
Published October 26, 2026
54 views

Scientists and developers are solving the same problems—but rarely together.
Researchers generate valuable datasets, insights, and discoveries, but these often stay locked in papers, spreadsheets, or lab notebooks. Developers, on the other hand, build scalable platforms, APIs, and user experiences, but may lack access to scientific workflows and domain expertise. Django sits at a powerful intersection: it can transform research into accessible, interactive, and impactful software.
In this talk, I’ll share lessons from working across chemistry research, AI, and software development to show how Django can bridge the gap between scientific discovery and real-world applications. We’ll explore how research workflows map naturally onto Django models, data pipelines, and dashboards, and how web platforms can democratize scientific knowledge through citizen science portals, research collaboration tools, and public data platforms.
Beyond technology, this session focuses on people and communities. I’ll discuss strategies for building interdisciplinary communities that bring scientists and developers together—through open-source projects, workshops, and collaborative platforms—and why these bridges are essential for tackling global challenges.
This is a non-technical, narrative-driven session designed to inspire Django developers, researchers, educators, and community leaders to collaborate across disciplines and build software that amplifies scientific impact.

This talk was presented by Barkha Jain at DjangoCon US 2026 in Chicago, Illinois, USA
https://2026.djangocon.us/talks/scientists-meet-django-building-bridges-between-research-and-software/

LINKS:
Follow Barkha Jain 👇
Website: https://www.linkedin.com/in/jbarkha/

Transcript

3,314 words · auto-generated · en Show

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

0:14

Hello everyone, am I audible? Yeah, okay. So I'm speaking today for the building bridges between research and software. So it's a quick introduction about myself. I'd done my master's in organic chemistry and bachelor's in education, and I am also a trained katak dancer. And my Twitter handle is at the barkharate, barkha underscore jen underscore. So now let's get into this. So let me back up for a second and tell you how I actually got here because I think the path matters for what I am about to say. I started in organic chemistry years at the bench, running experiments, purifying compounds, writing them up for the papers.

1:04

And here's the thing about those papers, they are written for other chemists, not for the developers, not for the public. For a very very narrow audience. I remember finishing a project that took the better part of a year and watching it become a PDF Behind a paywall that maybe 200 people on Earth would ever open. That stuck with me, honestly. All that work and such a narrow door out into the world. At some point I moved into STEM community leadership, organizing scientists, students, and technologists. And what struck me immediately was this.

1:50

These groups almost never ended up in the same room. Scientists had their conferences, developer had theirs. Rarely did the two overlap. I had go to a scientific meeting and hear people talk about data management like it was some unsolved minister mystery. And then I had go to a developer meetup a week later and hear people talk about data management. Like it was Tuesday. Same problem, completely different rooms. And then I found Django. And it was a strange realization. The framework that was built for newsroom Deadlines for shipping features fast for managing content at scale

2:37

turned out to be exactly what research needed to. So that's the arc of this talk, chemistry to community to code. And I think that combination gives me a slightly different lenses. on a problem. I had bet a lot of you have felt too, even if you have never set foot into a lab. So let's start with the problem. A research lab produces an enormous amount of stuff. Lab notebooks, spreadsheets, papers, months, sometimes years of work. And here is what I want you to sit with for a second Most of it stays exactly there

3:22

in the notebook, in the spreadsheet, in the PDF, and maybe 200 people will ever read. So I want to ask you a question And I want you to actually think about it, not just hear it, how many discoveries never become useful simply because they never become software. Think about that for a second. A cure, a technique, and insight that could change something. Sitting in a spreadsheet on someone's laptop, because nobody ever built the bridge That a spreadsheet to something usable. It's not that researchers don't want the bridge to exist. It's that building it is not their job and it is not their training.

4:10

They are trained to discover things, not to ship them. That's the gap this talk is about. And I think Django is one of the best tools we have to close it. So here is something I noticed pretty quickly. Once I was living in both worlds, scientists and developers are solving the exact same problems. They just don't know it. Look at this side by side. Where a scientist runs an experiment, a developer ships a feature. Where a scientist collects the data, a developer collects data too. Reproducibility for a scientist is testing for a developer.

4:57

Ask any researchers what keeps them up at night And is usually near the top of the list. Ask any developer the same question about their test suite And you will hear almost the same anxiety in different words. Collaboration for a scientist is open source. For a developer. Publications become documentation. Peer reviews become code review Somebody else reading your work critically before it goes out into the world. That instinct is identical in both Fields. Same instinct, same vibes, same values, honestly, rigor, verification, sharing your work so others can build on it.

5:44

Just completely different vocabularies are completely different tools. And once you see that mapping, you can't unsee it. These are not two different mindsets. They are same mindsets wearing different clothes. So, is they are solving the same kind of problem? What are they actually working forward? Scientists think in hypothesis, experiments, publications. Developers think in products, APIs, deployments. Different languages again, but look at what's sitting in the middle: climate, healthcare, AI, sustainability, and education.

6:33

These are the challenges both groups are actually both groups are actually trying to solve. Every single one of them needs scientific insight, and every single one of them needs that insight turned into. Something people can actually use. A climate model is only useful once someone builds the dashboard, a policymaker can actually read. So, the disconnect between these two words is not about ambition. It's not that developers don't care about climate change or that scientists don't care about usability. The disconnect is language. And its workflow. And that's a solvable problem. That's not a culture war. That's a translation problem.

7:19

And translation is something we are actually pretty good at if we choose to be. Which brings me to why I am standing on a Django stage talking about chemistry. Django is not just a framework. Say that with me in your head for a second because I think a lot of us, myself included, for a long time Think of Django as a tool for building websites, blogs, admin panels, APIs. But that's understanding it. Django at its core is an engine for turning knowledge into usable tools. And research is knowledge, raw, unconstructed, often logged away in a format nobody outside the field can open.

8:07

But knowledge all the same. So let me show you exactly what I mean. This is the part of the talk. I I'm most excited about because once you see this mapping, I promise you will not look at a research lab the same way again. On the left, how are scientists think about their work On the right, how that maps directly unto Django. A research project is a Django project, not metaphorically, literally, it has the same shape. A defined scope, a team, a timeline, a set of goals, funding

8:53

attached to it, deadlines attached to it. An experiment is a model. Think about it. An experiment had a structure, it has fields, it has relationships to other experiments, to the researchers who ran it. To the equipments that was used, that is Django model, described in scientific language before anyone written a single line of Python. Samples are your database, physical samples, sequence samples, tissue samples, whatever the domain. They are row of structured data waiting to be queried waiting to be filtered, waiting to be cross-referenced against every other sample that's ever come through the lab.

9:40

Workflow, it's a business logic. The step as research researcher takes the validation, the order of operations The approvals that have to happen before a sample moves to the next stage. That is the exact same thing as the business logic layer in any Django app you have ever built. A publication is a public web app because that's what a publication actually is. If you stripe away the PDF, it's the output Meant to be consumed by an audience, meant to inform a decision. A research dashboard is your admin interface. Django ships with one for free

10:25

and it is shockingly close to what most labs are trying to build from scratch. Badly in Excel with macros nobody else in the lab can maintain. And results are an API structured, curable Something that something other systems and other research can plung into instead of copying and pasting numbers out of a table in a paper. So here's the point I want to learn before we move on. Django is not just a framework, it's an engine for turning knowledge into a usable tool. Every single piece of research process has a Django-shaped hole waiting for it.

11:17

So if Django maps this clearly onto research, now do you actually start building I want to give you three principles, not Django features, a mindset. First, think beyond papers. A research output does not have to end as a PDF. It can become a actually opens more than once. Imagine a public health dataset that's an actual queryable API. Instead of a zip file, buried three links deep on a government website. Second, a model scientific workflow, projects, experiments, samples, collaborators, datasets. These maps naturally onto Django models. The way I just showed you.

12:03

You don't need to invent a new abstraction. The abstraction already exists in the lab. You just have to go listen for it. Third, the design for non-developers. Because your users are not going to be developers. They are going to be scientists, educators, students, policymakers, citizens Each of them interact with your platform completely different. And a good Django app respects that. Instead of assuming everyone reads our database For fun, and here is the line I want you to remember from this section. The goal is not to digitize a lab notebook, it's to amplify a scientific impact. Those are very different goals

12:48

and they lead to very different software. So before we move, three quick takeaways from this section, things you can actually act on this week. Designs for users beyond the research team. Treat scientific data as a product, not just a publication, and start with reusable models and workflows. Don't rebuild the wheel for every single project. Write those down if you want, because I am going to keep coming back to this platform. Every section of this talk is going to end exactly like this story, then something you can actually do.

13:35

All right, I promise this talk would be non-technical and it mostly is. But I want to give you about 5 minutes of something more concrete because I think it makes everything else learned harder Here is the question I want to pose to you. In dev workflows, we already have something amazing that we mostly take for. Mostly take for granted a bot that watches every single pull request and flags problems before a human ever looks at it. We built that muscle years ago and now it feels completely unremarkable. What if a research pipeline had the same thing? Let's put these side these side by side. In a dev workflow, an agent watches new pull requests.

14:23

In a research workflow, an agent watches near new results row. Come in in front of Front coming in from an experiment. In dev, it flex risky diffs in research. It flex anomalies, outliers, results that don't match what's expected. In dev It posts a review comment in research, it writes a flag back to the model and in dev. Human review the short list. In research, the scientists review it right inside Django Admin. It's the exact same pattern we just have not applied to it it to research yet, at least not nearly as often as we could. Let me show you what that actually looks like.

15:18

So here is the research review agent and I want to walk go walk you through it step by step because every single piece of this is something you already know how to build. Step 1, a result gets saved. That's just a normal Django model, getting a normal row inserted the way it happens a thousand times a day In any app you have ever shipped, step two, that save triggers a background task, a signal fires, and it kicks off a celery task Step 3, that task calls an LLM, it hands over the results and some content about the experiments. What was being tested? What past results look like? And it asked for a first pass.

16:04

Does this look like an outlier? Does it contradict something we have seen before? Does it resemble a result? From a completely different experiment that the research might not even note about. Step four, whatever comes back gets written into a review queue Not overwritten onto the original result that matters. Keep the original clean. It goes into a separate models, flags. Related results, sitting there waiting for a human to look. And step 5, the scientist open Django admin, the same admin you already know And review the short list, accepts it, dismisses it, moves on with their day.

16:50

And here's the point I really want to learn. The agent does not decide anything. It triages. The scientists stay the reviewer always. I want to show you just how small this actually is in code because I think sometimes AI agent sounds like it requires some brand new architecture, it does not. This is a result model. It belongs to an experiment. It ho it holds some JSON data and it has a flagged Boolean. Completely ordinary, the kind of model you have written without thinking twice. Below it a signal, post save on result and when a new one is created it kicks off a salary

17:36

task, which is the piece that actually calls the LLM. That's genuinely it, 9-10 lines. And the point I want to leave you with, here is this models, signals, backgrounds, task. The agent is just another consumer of the structure. You are not learning a new framework to do this. You already know how to build this. You have probably already built something with this exact shape. For a completely different reason, maybe a notification system, maybe a fraud check, maybe an image processing pipeline. So three takeaways from the technical section. Agents plug into Django the same way any background worker does.

18:23

There is no special agent framework you are missing out on. Model the review not just the results that separate Q matters more than the API the AI call itself and start with narrow high signal triads task before you get ambitious. All right, let's step back out of a technical weed and talk about people. Because here is the truth: the biggest barriers between these two words are almost never technical. I have sat in rooms With brilliant scientists who say some version of this.

19:10

I don't know how to build software. And I have sat in rooms with brilliant developers who say the exact mirror of that. I don't understand the science. And both of those sentences are completely true. And here's the thing: both of them are solvable. Neither one is a reason to keep working apart. Nobody's either of those rooms is wrong. There is just missing a bridge. And that bridge is not a technology, it's a set of habits and a little bit of intentional efforts from both sides. So, what does the that bridge actually look like in practice? Here is our three patterns I have ever been seen over, work over and over.

19:55

First, start with problems, not technology. Don't walk into a room with researchers and ask what framework should we use. Ask what scientific questions are we actually trying to answer. The technology decision comes after that and it comes easily. Once the cushion is clear. Second, build shared vocabulary, scientists, developers, designers, community managers, every single one of them defines success differently. Third, make collaborations visible. Open source it, document it, pull together a rough roadmap to Do regular demos, even small ones. That visibility is what turns one -off help into an ongoing partnership.

20:42

And you know, I have seen collaborations fail for exactly the opposite reasons. A developer builds in isolation for three months. Then unveils something that scientists barely recognize because nobody checked in along the way. That's not a technology failure. That's a visibility failure. And it's completely avoidable. So, takeaways from this section. Pair domain experts with developers from day one.

21:31

So, takeaways from this section pair domain experts with developers from day one, not after the architecture already logged in, build shared vocabulary Before you write a single line of code and document decision for mixed discipline teams, because what's obvious to you is very often not obvious to the person across the table. Okay, last big section because platforms and collaborations only get you so far if there is no actual community connecting these words long term. And I want to make this concrete Not just communities matters because you have probably heard that a hundred times. University and Django meetups

22:18

just Invite researchers into the room developers are already gathering in. It's genuinely that simple and it happens far less than you had think. Most researchers have never been to a meetup like this one, not because they would not enjoy it, but because nobody ever asked. Hackathons on real data, not generic build-to-do app challenges. Real scientific database, real open questions. People show up differently and they build differently when the problem is real. And someone actually needs the answer. Open source and citizen science lower the barrier for students to contribute. And let the public become

23:03

contributor instead of just consumer of research, the way biodiversity and astronomy projects already do beautifully. And two-way mentorship, scientists mentor domain knowledge, developers mentor software practice. Nobody has to become an expert in the other field. They just need one person who can translate. This is the part of the talk that genuinely closest to my heart because I have watched this exact pattern take a scientist who never touched code and a developer who never opened a research paper and turned them into a team that ships something real, something that outlives the hackathon weekend at the start at.

23:57

So I want to leave you with this. Just I have one sec one minute. So invite researchers to developer events and developers to research one. Both directions matter. Contribute to scientific open source projects, they need maintainers just as much as any other project does. And create recurring spaces, not one-off events. A single hackathon is a nice memory. A monthly meetup is a community. So let's bring this all together.

24:44

If you remember nothing else from the next 20 minutes of your day, I want you to walk about able to answer three questions How do I build a science-driven Django application? You know how have the mapping, research projects, experiments, samples, workflow. They translate directly and you don't need to invent anything new to get started. How do I collaborate with researchers? Start with the problem Build shared vocabulary, make the work visible. And how do I help build the community around of All of this invite people in, use real problems, and make the spaces recurring not one off. Build, collaborate

25:30

and connect. That's the whole talk really compressed into three words. It's a build, collaborate, and connect. So I want to leave you with this. Scientific knowledge changes the world only when people can actually use it. A paper sitting in a journal, read by two hundred peoples, that's not nothing. But it's not everything either The next breakthrough might not need another paper. It might need a web application, an open source community, and someone in this room, maybe that's you. Maybe it's someone you partnered with next month at a meetup you almost did not to go to.

26:16

I started in a chemistry lab. Written things up, and I genuinely thought only a handful of people would ever read. And somehow that path led me here to a room full of people who build the tools that turn knowledge. Into something the world can actually use. Thank you so much.

Presenters

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 from DjangoCon US