diff --git a/djangocon-us-2024/category.json b/djangocon-us-2024/category.json
new file mode 100644
index 000000000..90d60598a
--- /dev/null
+++ b/djangocon-us-2024/category.json
@@ -0,0 +1,3 @@
+{
+    "title": "DjangoCon US 2024"
+}
\ No newline at end of file
diff --git a/djangocon-us-2024/videos/a-brief-history-of-django.json b/djangocon-us-2024/videos/a-brief-history-of-django.json
new file mode 100644
index 000000000..608291698
--- /dev/null
+++ b/djangocon-us-2024/videos/a-brief-history-of-django.json
@@ -0,0 +1,26 @@
+{
+    "description": "We are better programmers than historians or archivists.  There are a few great stories from the very early days of Django and how we managed to get it Open Sourced.   They are told in the hallways and at dinner amongst us old timers, but as Django is poised to enter its second decade it seems appropriate to record some of these stories for posterity. \n\n- How did the make up of the team and The World Company itself impact early Django design choices? \n- The infamous meeting where we got approval to Open Source Django\n- Why the BSD license?\n- Did we know what we were doing?",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-brief-history-of-django/"
+        }
+    ],
+    "speakers": [
+        "Frank Wiles"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/yLwx4_099aQ/maxresdefault.jpg",
+    "title": "A Brief History of Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/yLwx4_099aQ"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/a-guided-tour-through-postgres-internals.json b/djangocon-us-2024/videos/a-guided-tour-through-postgres-internals.json
new file mode 100644
index 000000000..8c0af3e11
--- /dev/null
+++ b/djangocon-us-2024/videos/a-guided-tour-through-postgres-internals.json
@@ -0,0 +1,26 @@
+{
+    "description": "Exercising your Postgres skills on this tour will give you a leg up in working with your Django app and understanding performance related to your database. The guide will provide all the gear, necessary commands, and queries for your adventure. You don\u2019t want to miss the view of your database when we get to the top. All skill levels are welcome.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-guided-tour-through-postgres-internals/"
+        }
+    ],
+    "speakers": [
+        "Elizabeth Garrett Christensen"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nOeNOKBXdUs/maxresdefault.jpg",
+    "title": "A Guided Tour Through Postgres Internals",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/nOeNOKBXdUs"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related.json b/djangocon-us-2024/videos/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related.json
new file mode 100644
index 000000000..43029a91f
--- /dev/null
+++ b/djangocon-us-2024/videos/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related.json
@@ -0,0 +1,26 @@
+{
+    "description": "What happens in an HTTP request-response cycle is often difficult to understand. Optimizing database queries is a crucial aspect of web development, yet it often remains shrouded in mystery for many beginners. By attending this talk, attendees will gain practical insights into how to leverage django-debug-toolbar to inspect an HTTP request-response cycle. By revealing and fixing pathological queries, developers can improve application performance and user experience. The talk will cover indexing, select_related, prefetching, and other optimization strategies.\n\nDuring the session, I will guide attendees through the following key points:\n1. Understanding Query Execution: Exploring the anatomy of a QuerySet, focusing on immutability, lazy evaluation, and the fact that a QuerySet is not a query.\n2. Introduction to django-debug-toolbar: An overview of what django-debug-toolbar is and how it can be integrated into Django projects.\n3. Identifying Pathological Queries: Techniques for using django-debug-toolbar to identify slow or inefficient database queries within an HTTP request.\n4. Strategies for Optimization: Practical tips and strategies for optimizing identified queries, including indexing, select_related, prefetching, and other optimization.\n5. Real-World Examples: Illustrative examples and case studies demonstrating the impact of query optimization on application performance.\n\nThis talk is ideal for beginners in Django development who are looking to deepen their understanding of query optimization and improve the performance of their Django applications. Attendees should have a basic familiarity with Django concepts such as models and basic database design, but no prior experience with query optimization is required.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/a-related-matter-optimizing-your-webapp-by-using-django-debug-toolbar-select-related-and-prefetch-related/"
+        }
+    ],
+    "speakers": [
+        "Christopher Adams"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/PtrBQj9lPVA/maxresdefault.jpg",
+    "title": "A Related Matter: Optimizing your webapp by using django-debug-toolbar, select_related(), and prefetch_related()",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/PtrBQj9lPVA"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/an-opinionated-guide-to-modern-django-forms.json b/djangocon-us-2024/videos/an-opinionated-guide-to-modern-django-forms.json
new file mode 100644
index 000000000..062795b01
--- /dev/null
+++ b/djangocon-us-2024/videos/an-opinionated-guide-to-modern-django-forms.json
@@ -0,0 +1,26 @@
+{
+    "description": "Django forms have experienced a significant renaissance within the Django community, after years of being what felt like an afterthought. Recent releases to Django have brought major improvements to built-in form templating and rendering. Instead of writing APIs to support forms rendered by the JS framework of the week, you can now use Django forms to render dynamic, interactive, responsive forms using only the batteries provided by Django, various third-party Django packages, and a handful of small, focused JavaScript utility libraries. And if you're willing to do a little bit of the leg work yourself, you can even get by without those third-party Django packages.\n\nIn recent years, web development has started to see a shift away from complex JavaScript-heavy architectures toward more streamlined, HTML-centric approaches. Technologies like HTMX and Unpoly.js enable SPA-like experiences through server-rendered HTML, pairing nicely with Django\u2019s template language. Similarly, libraries like Alpine.js and Stimulus enhance static HTML with dynamic behaviors inline, eliminating the need for comprehensive frameworks. Additionally, CSS frameworks like Tailwind CSS adopt a utility-first approach, simplifying the creation of  maintainable CSS. \n\nThis shift towards an HTML-centric approach to building web applications is complemented nicely by the recent improvements to Django forms. By leveraging these new capabilities, Django forms can now be used to render forms that are more easily maintainable, more responsive, more accessible, and -- to the end user -- just as interactive as one built using one of the many JS frameworks.\n\nBy the end of this talk, attendees will have a deeper understanding of the power and potential of Django forms, equipped with the knowledge to implement them effectively in their projects.\n\n### Outline\n\n- Introduction to Django forms, including a quick historical overview of where they have come\n- Exploration of a few new Django form features: template-based form rendering and `as_field_group`\n- Styling forms, fields, and errors using modern CSS features, with a focus on Tailwind CSS\n- Dynamic behavior with minimal JavaScript, with a focus on Alpine.js\n- Inline validation using AJAX, with a focus on HTMX\n- Useful third-party Django form packages and why you may not need them anymore\n- Hands-on demonstration of a simple form using all of the above\n\nThis talk will be suitable for anyone who has a basic understanding of Django.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/an-opinionated-guide-to-modern-django-forms/"
+        }
+    ],
+    "speakers": [
+        "Josh Thomas"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/mpS9DLTSW88/maxresdefault.jpg",
+    "title": "An Opinionated Guide to Modern Django Forms",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/mpS9DLTSW88"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/api-maybe-bootstrapping-a-web-application-circa-2024.json b/djangocon-us-2024/videos/api-maybe-bootstrapping-a-web-application-circa-2024.json
new file mode 100644
index 000000000..37381b70b
--- /dev/null
+++ b/djangocon-us-2024/videos/api-maybe-bootstrapping-a-web-application-circa-2024.json
@@ -0,0 +1,26 @@
+{
+    "description": "The last couple of years seem to have changed everything. Particularly with HTMX, but also related technologies like Alpine.js and Tailwind CSS, we've rapidly gone from a world where seemingly the only option was \"API First\".\n\nThis is the story of bootstrapping a new application in these latter days. On a core of almost old-school Django combined with HTMX, with a just sprinkling of Alpine.js, we've been able to build a rich and interactive web application, with hardly a JSON response or payload in sight.\n\nWe'll show the integration patterns we've learnt, and what the limits of those might be.\n\nFinally, we'll look at what the future might bring. As we grow the application we're looking whether we will need edge computing, offline, and richer behaviour purely on the client. Is that the limit of the hypermedia driven approach? Is that where we need an API? It's not clear: it's still very much \"API Maybe\".",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/api-maybe-bootstrapping-a-web-application-circa-2024/"
+        }
+    ],
+    "speakers": [
+        "Carlton Gibson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/I6XP7DweLzc/maxresdefault.jpg",
+    "title": "API Maybe: Bootstrapping a Web Application circa 2024",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/I6XP7DweLzc"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/choosing-wisely-spa-vs-htmx-for-your-next-web-project.json b/djangocon-us-2024/videos/choosing-wisely-spa-vs-htmx-for-your-next-web-project.json
new file mode 100644
index 000000000..aef0bd81b
--- /dev/null
+++ b/djangocon-us-2024/videos/choosing-wisely-spa-vs-htmx-for-your-next-web-project.json
@@ -0,0 +1,26 @@
+{
+    "description": "As web developers, we want to select the right architecture pattern for our projects. Web applications are inherently complex, and your choice will affect how you manage that complexity.\n\nChoosing a SPA pattern offers rich user experiences with rich interactivity and navigational transitions, but it also introduces complexity in state management, development cost, maintenance, security, and performance. \n\nOn the other hand, server-rendered applications have been around for decades and have, until recently, struggled to match the user experience of SPAs. However, thanks to the evolution of browser standards and a crop of lightweight JavaScript frameworks, server-rendered apps have caught up and are once again a compelling option.\n\nIn this talk, we'll delve into the factors influencing the choice between SPAs and server-rendered apps. We'll discuss considerations such as:\n\n- **State Management**: Your choices affect how you'll need to manage the state of today's data-rich apps.\n- **User Experience Requirements**: Assess the application's level of interactivity and real-time updates and how well each pattern performs.\n- **Performance and Scalability**: Understanding the impact of page load times, network latency, server resources, and client resources on the application's performance.\n- **Project Constraints**: Consider time, budget, and infrastructure limitations that may influence the choice of architecture pattern.\n- **Development Team Expertise**: Evaluating the team's familiarity with JavaScript frameworks and server-side rendering.\n\nThrough practical examples and case studies, we'll demonstrate how to evaluate these factors and select the most appropriate architecture pattern for a given project. Whether you're building a content-driven website, a real-time collaboration platform, or an enterprise application, this talk will provide valuable insights to help you choose between SPAs and server-rendered apps to deliver the best possible user and developer experience.\n\n## Key Points\n\n1. Understand state management in today's data-rich applications. \n2. Explain how the microservice pattern affects pattern choice.\n3. Practical guidelines and decision-making frameworks for choosing between SPAs, HTMX, and AlpineJS based on real-world scenarios.\n4. Case studies and examples illustrating the application of each architecture pattern in different types of web applications.\n5. Tips and best practices for optimizing performance, maintaining code quality, and ensuring scalability.\n\nBy the end of this talk, attendees can confidently choose when to use a SPA or server-rendered pattern based on their project's needs and constraints. They will identify the trade-offs between complexity, performance, and user experience, enabling them to deliver high-quality web applications efficiently and effectively.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/choosing-wisely-spa-vs-htmx-for-your-next-web-project/"
+        }
+    ],
+    "speakers": [
+        "Chris May"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nTnX_CC6cK0/maxresdefault.jpg",
+    "title": "Choosing Wisely: SPA vs. HTMX for Your Next Web Project",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/nTnX_CC6cK0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/closing-remarks.json b/djangocon-us-2024/videos/closing-remarks.json
new file mode 100644
index 000000000..f9f9f4848
--- /dev/null
+++ b/djangocon-us-2024/videos/closing-remarks.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/closing-remarks/"
+        }
+    ],
+    "speakers": [
+        "Peter Grandstaff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/im_DZvLGd5c/maxresdefault.jpg",
+    "title": "Closing Remarks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/im_DZvLGd5c"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/deploying-django-migrations-at-kraken-scale.json b/djangocon-us-2024/videos/deploying-django-migrations-at-kraken-scale.json
new file mode 100644
index 000000000..1b4fb5d1d
--- /dev/null
+++ b/djangocon-us-2024/videos/deploying-django-migrations-at-kraken-scale.json
@@ -0,0 +1,26 @@
+{
+    "description": "Kraken is an energy retail system built on Django. It is currently in use by over 20 clients around the world, including the largest energy retailer in the UK, Octopus Energy, which developed Kraken.\n\nWhen Kraken started out over 8 years ago supporting a single small client, applying Django migrations to make database schema changes was easy. Any migration that might be slightly dangerous was deployed outside business hours when the system was relatively quiet and there was no risk of disrupting the work of customer service staff. Kraken has now grown: the code has around 350 Django apps, with over 9000 migration files between them, and some database tables have billions of rows. With Kraken operating in 8 time zones around the globe, there is now no such thing as \"outside business hours\". We have needed to find other ways of deploying migrations that might be risky.\n\nThere are two main risk factors with applying migrations: taking exclusive database locks, and needing a long time to apply. Exclusive locks can interrupt normal system operations, while slow migrations can hold up the deployment process, potentially preventing later deployments for a long period.\n\nThis talk describes how we write migrations so that they avoid risks where possible, and how we deploy them in a scalable way, avoiding the need for manual intervention as much as possible. We describe techniques that use standard features in the Django migration system, as well as a system we have developed to complement standard Django migrations. The techniques described should be generally applicable to most large Django installations.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/deploying-django-migrations-at-kraken-scale/"
+        }
+    ],
+    "speakers": [
+        "Tim Bell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/6Ul-t4yw_Kc/maxresdefault.jpg",
+    "title": "Deploying Django migrations at Kraken scale",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/6Ul-t4yw_Kc"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-alpine-js-htmx-ups-downs.json b/djangocon-us-2024/videos/django-alpine-js-htmx-ups-downs.json
new file mode 100644
index 000000000..e71b8e9f1
--- /dev/null
+++ b/djangocon-us-2024/videos/django-alpine-js-htmx-ups-downs.json
@@ -0,0 +1,26 @@
+{
+    "description": "A few years ago we started to hear about the toolkits htmx and Alpine.js as a powerful combination that could  be used with Django to enable development of web applications that offer user experience akin to a single page application without the overhead of adopting a heavyweight front-end framework such as React. We were excited by the promise and adopted these tools in a few projects. In this talk we'll cover:\n\n- The promise we saw in this tool combination\n- The upside: examples of exciting wins in ways of using these tools that we recommend continuing\n- The downside: some rough edges and areas of concern where we recommend caution\n- Our overall assessment and plans regarding continued use of this combination",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-alpine-js-htmx-ups-downs/"
+        }
+    ],
+    "speakers": [
+        "Karen Tracey"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/eyp-ArdO1Q4/maxresdefault.jpg",
+    "title": "Django + Alpine.js + htmx Ups & Downs",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/eyp-ArdO1Q4"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-celery-a-love-story-of-async-proportions.json b/djangocon-us-2024/videos/django-celery-a-love-story-of-async-proportions.json
new file mode 100644
index 000000000..bb3ad33de
--- /dev/null
+++ b/djangocon-us-2024/videos/django-celery-a-love-story-of-async-proportions.json
@@ -0,0 +1,26 @@
+{
+    "description": "### Django: A Framework for perfectionists with deadlines\n1. Batteries included: Security, Authentication, Authorization, Administration, robust and mature ORM, etc.\n2. Opinionated: Django defines the right path for doing things with it. And this open doors for building extensions.\n3. Strong Community: Open source packages, events, meetups, active development of the main framework\n\n### Django's performance issue is a thing. We need to be careful with:\n1. Avoiding N+1s\n2. Caching\n3. Database indexes\n4. Data denormalization\n5. Running operations in the background\n\n### Why running operations in the background?\n* Each Django process loads the framework core\n* It's expensive to have too many processes\n* Requests hold one Django process each while being processed\n* Requests should be processed quickly so we don't hold a process for too long\n* We need to give feedback to the user quickly, so they can move forward with other operations\n\n### What is Celery?\nAsynchronous task queue or job queue which is based on distributed message passing\n\n### Why Celery?\n1. Distributed: It separates async tasks execution from your application\n2. Fast: Celery has a very small boilerplate and executes tasks REALLY fast\n3. Integrated: You can write Celery tasks within your application, with access to models, services, functions, classes, etc\n\n### Celery \ud83d\udc98 Django\n1. Documentation: We have dedicated docs for integrating them both\n2. Django Settings: You can configure Celery from Django settings, not extra boilerplate\n3. Django within tasks: Access to Django ORM and other tools on Celery tasks\n4. Community: There are packages for enhancing the integration\n\n### How does it look like?\nReal world example\n\n### What async tasks can be used for?\n* Delegate long lasting jobs\n* Execute remote API calls\n* Prepare and cache values\n* Spread bulk database insertions over time\n* Execute recurring jobs\n\n### How does it work under the hood:\n1. Django uses Celery client to queue a message on the Broker\n2. Celery watches the Broker queue\n3. Celery marks a task as started so other workers don't pick it\n4. Celery marks a task as succeeded\n5. Celery send the result to the Results Backend\n6. Django may read the result from the Results Backend or not\n**Disclaimer:** these steps may vary depending on your configuration.\n\n\n### Tough love \ud83d\udc94: As in every good love story, it isn't always rainbows and butterflies.\n* All connections between a service and the other may fail\n* Concurrency becomes your enemy\n* Failures may be harder to handle as they aren't sync anymore\n* Issues that only happens in production\n* Tasks that never finish\n* Infinite retries\n* Conflicting operations\n* Task runs more than once\n* Unbalanced queues\n* Periodic tasks that are queues again before the previous one starts\n* Outdated data\n\n### We're going to focus on these four problems:\n1. Outdated data\n3. Error feedback\n2. Duplicate runs\n4. Conflicting ops\n\n### Outdated data\n* Sending complex data as parameters to a Celery task may result in conflicts because we cannot ensure the data doesn't change between the task being schedule and its execution.\n* We must, as much as possible, pass ids and retrieve the most up-to-date data in the scope of the task.\n\n### Duplicate runs\n* Depending of your Celery setup and task configuration, it may not be guaranteed that the task runs only once:\n  - Multiple workers may pick the same task at the same time\n  - A task may be interrupted and requeued\n\n* So we have to ensure:\n  - Atomicity\n  - Idempotence\n\n### Complex feedback loops for errors\n* User may receive a success message from the request but the whole operation may still fail.\n* We need to develop flows that take this possibility into consideration and give the user a feedback of this error.\n* We may also need to undo successful operations run by the web service.\n\n### Conflicting operations\n* While a task haven't still run another operation is triggered by the user. This operation conflicts with the one that is still pending.\n* Consider the following use cases:\n  1. User can add notes\n  2. User can delete a note\n  3. User can bulk create copies of a note\n\n#### Example of problematic interaction: \n1. User creates a Note\n2. User creates 10 copies of the note, this runs in a background task\n3. User deletes the original note before the task to copy the 10 notes runs\n4. Task runs, but the original note isn't available anymore so it cannot be copied\n\n#### There are many solutions to this:\n* Implementing soft delete on the note so it's available even after delete\n* Canceling pending tasks before deleting\n* Locking notes with pending operations\n\n### Couples therapy pt1 (or some tips that help the relationship to flow)\n* Will retry tasks? use exponential backoffs\n* Tasks shouldn't raise exceptions: handle all of them and send reports\n* Monitoring is essential, celery-flower can help\n* ALWAYS_EAGER makes your tasks synchronous and can help on debugging and development\n* RDB is a remote debugger, it can help debug celery tasks\n\n### Couples therapy pt2 (knowing the boundaries of the relationship)\n* Celery is excellent for asynchronous tasks and for doing simple jobs. For complex workflows it may not be very reliable, there are open issues for that, and many complaints of lost tasks and unpredictable behaviors.\n* Long running tasks may be problematic. Ideally split the task into smaller ones or use a different tool.\n* Monitoring tools are very limited. You may need to implement some monitoring yourself. Ex.: queues heartbeat.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-celery-a-love-story-of-async-proportions/"
+        }
+    ],
+    "speakers": [
+        "Hugo Bessa"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/HPWUsoZ_zv0/maxresdefault.jpg",
+    "title": "Django & Celery: A love story of async proportions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/HPWUsoZ_zv0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-ledger-uniting-developers-and-accountants-for-innovation.json b/djangocon-us-2024/videos/django-ledger-uniting-developers-and-accountants-for-innovation.json
new file mode 100644
index 000000000..82979f7c3
--- /dev/null
+++ b/djangocon-us-2024/videos/django-ledger-uniting-developers-and-accountants-for-innovation.json
@@ -0,0 +1,26 @@
+{
+    "description": "Why Django Ledger?\nIn the world of money apps, it's not just about transactions; it's about understanding how each financial decision ripples out. It's like dropping a pebble in a pond and watching the waves spread. Every dollar spent or saved can have a bigger effect than you realize. Django Ledger looks at both sides of the money picture because it is a double entry accounting system. This capability makes sure the insights aren't just whole, but you can act on them right away. It's like having a financial monitor that helps you see the bigger picture to take the right steps forward. \n\nI'm a developer, why should I care?. \nDevelopers aren't accountants, and accountants aren't exactly tech savvy. It feels like they're worlds apart. But what if we could bring them together? Imagine the power of combining the skills and knowledge of both sides to create something truly amazing and innovative. \n\nBy using Django Ledger's capabilities to implement transaction blueprints, developers can easily work their magic on their projects. It's like having a toolbox filled with all the right tools to make your coding journey smoother and more efficient. \n\nI'm an accountant or business owner, why should I care?\nFor accountants and business owners, it's a game-changer. Adding Django Ledger to the stack means getting instant financial stats and insights whenever you need them. It's like having a financial advisor at your fingertips, ready to give you the guidance you need to make smart decisions. \n\nBest of Both Worlds\n\nDjango Ledger makes it smooth for developers to blend financial stuff into their projects, while giving accountants and business owners real-time financial statements. It is like a bridge that connects these two worlds, making collaboration and understanding easier between them. It's like breaking down barriers and creating new possibilities for innovation and growth in the tech and finance world.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-ledger-uniting-developers-and-accountants-for-innovation/"
+        }
+    ],
+    "speakers": [
+        "Miguel Sanda"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Sn7Z6ZN-DU8/maxresdefault.jpg",
+    "title": "Django Ledger | Uniting Developers and Accountants for Innovation.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/Sn7Z6ZN-DU8"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-the-web-framework-that-changed-my-life.json b/djangocon-us-2024/videos/django-the-web-framework-that-changed-my-life.json
new file mode 100644
index 000000000..a2529dee3
--- /dev/null
+++ b/djangocon-us-2024/videos/django-the-web-framework-that-changed-my-life.json
@@ -0,0 +1,26 @@
+{
+    "description": "The year was 2018. I was studying computer science at the University of Indonesia. I learned Django as part of a web programming course. At the time, Django felt just like any other framework out there \u2013 it's part of the tech stack that you use.\n\nA year later, I tried my luck with Django in [Google Summer of Code](https://g.co/gsoc). I took a deep dive into Django's codebase to implement the cross-database `JSONField`. The feature managed to make it in Django 3.1.\n\nFast forward to now, I've got a job in the UK to work on the Django-powered Wagtail CMS.  Since then, I've had the opportunity to give talks at conferences in Europe and the US, including this one.\n\nThis is a story of how Django changed ~~my life~~ people's lives \u2013 and how you played a part in it.\n\nIn this talk, we'll go through:\n- How Django can be used to teach web programming\n- Django's participation in Google Summer of Code\n- The awesome Django community and what it means for us\n- What we can do to make Django change the lives of even more people",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-the-web-framework-that-changed-my-life/"
+        }
+    ],
+    "speakers": [
+        "Sage Abdullah"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/X0Urp3RsKLY/maxresdefault.jpg",
+    "title": "Django: the web framework that changed my life",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/X0Urp3RsKLY"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-ui-components-for-perfectionists-with-deadlines.json b/djangocon-us-2024/videos/django-ui-components-for-perfectionists-with-deadlines.json
new file mode 100644
index 000000000..f1e06b78c
--- /dev/null
+++ b/djangocon-us-2024/videos/django-ui-components-for-perfectionists-with-deadlines.json
@@ -0,0 +1,26 @@
+{
+    "description": "We pay great attention to how to write composable python code (with inheritance, decorators, modules, namespaces, etc). But when it comes to architecting the templates of your website, this is often overlooked, which rapidly degenerates in tons of copy&paste of html, css and javascript.\nSome might say that this is what React or Vue (et al) are all about and already solve, but having to render HTML on the client can increase the complexity of the application (introducing build steps, another language, more dependencies, etc).\n  \nWriting reusable and composable UI components can be achieved using the good 'ol django templates, with the help of some libraries to fill in the gaps (like django-components, django-cotton and TailwindCSS) that we will explore and suggest as a possible solution.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/reusable-django-template-components-for-perfectionists-with-deadlines/"
+        }
+    ],
+    "speakers": [
+        "Hernan Lozano"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/KJjnPoDSmIc/maxresdefault.jpg",
+    "title": "Django UI Components for Perfectionists with Deadlines",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/KJjnPoDSmIc"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/django-user-model-past-present-and-future.json b/djangocon-us-2024/videos/django-user-model-past-present-and-future.json
new file mode 100644
index 000000000..4de9dec3f
--- /dev/null
+++ b/djangocon-us-2024/videos/django-user-model-past-present-and-future.json
@@ -0,0 +1,26 @@
+{
+    "description": "Django's default User model is now 20 years old and, in the words of former Django Fellow Carlton Gibson, a \"leaky battery.\" This talk examines the historical basis for User and past efforts to update or replace it. It evaluates current best practices, including custom user models and third-party packages, that support modern user authentication patterns. And it looks forward to future updates to User that support Django's goal of advancing the state of the art in web development.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/django-user-model-past-present-and-future/"
+        }
+    ],
+    "speakers": [
+        "Will Vincent"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/cky2PGvFQLU/maxresdefault.jpg",
+    "title": "Django User Model: Past, Present, and Future",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/cky2PGvFQLU"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/empowering-tertiary-students-introducing-pyclubs-for-enhanced-python-skills-and-community-engagement.json b/djangocon-us-2024/videos/empowering-tertiary-students-introducing-pyclubs-for-enhanced-python-skills-and-community-engagement.json
new file mode 100644
index 000000000..046de285b
--- /dev/null
+++ b/djangocon-us-2024/videos/empowering-tertiary-students-introducing-pyclubs-for-enhanced-python-skills-and-community-engagement.json
@@ -0,0 +1,26 @@
+{
+    "description": "Description:\n\nPyClubs, an initiative spearheaded by Python Ghana, represents a groundbreaking effort to empower tertiary students across the nation through the power of Python programming. As a leading organization dedicated to promoting Python and fostering a vibrant tech ecosystem in Ghana, Python Ghana has taken the initiative to launch PyClubs in collaboration with universities and colleges.\n\nPyClubs serve as dynamic hubs where students can come together to enhance their Python skills, collaborate on innovative projects, and engage with a supportive community of fellow enthusiasts. Under the guidance and support of Python Ghana, PyClubs provide students with access to resources, mentorship, and networking opportunities that are essential for success in today's tech-driven world.\n\nThis talk shines a spotlight on the transformative impact of PyClubs as an initiative of Python Ghana. By harnessing Python Ghana's expertise, networks, and resources, PyClubs offer students a unique platform to gain practical experience, expand their knowledge, and prepare for rewarding careers in the tech industry.\n\nFurthermore, Python Ghana's commitment to inclusivity and diversity ensures that PyClubs serve as inclusive spaces where students from all backgrounds feel valued and empowered. Through outreach programs, workshops, and community events, Python Ghana and PyClubs work hand in hand to foster a culture of diversity, equity, and inclusion in the tech community.\n\nAttendees of this talk will gain valuable insights into the collaborative efforts between Python Ghana and PyClubs in driving innovation, excellence, and inclusivity in Python education. They will be inspired to get involved in PyClubs initiatives and leverage Python Ghana's resources to unlock their full potential as future leaders in the tech industry. Join us in this exciting journey of learning, collaboration, and empowerment with PyClubs and Python Ghana.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/empowering-tertiary-students-introducing-pyclubs-for-enhanced-python-skills-and-community-engagement/"
+        }
+    ],
+    "speakers": [
+        "Johanan Oppong Amoateng"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/XjlmmQpORuM/maxresdefault.jpg",
+    "title": "Empowering Tertiary Students: Introducing PyClubs for Enhanced Python Skills and Community Engagement",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/XjlmmQpORuM"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/error-culture.json b/djangocon-us-2024/videos/error-culture.json
new file mode 100644
index 000000000..111656bfe
--- /dev/null
+++ b/djangocon-us-2024/videos/error-culture.json
@@ -0,0 +1,26 @@
+{
+    "description": "In my talk titled \"Error Culture,\" I take a deep dive into the widespread but often overlooked issue of how organizations manage error alerts in technology and programming domains. The core of my discussion revolves around the concept of 'error culture'\u2014the organizational tendency to ignore or minimize the significance of error notifications due to their frequency and the false perception of irrelevance. This paradox arises from our dependency on technology and the need to be alerted to failures, which results in a deluge of alerts, many of which are false positives or not actionable, leading to a dangerous desensitization to potentially critical warnings.\n\nThrough my analysis, I address the serious consequences of error culture, such as the risk it poses by allowing significant alerts to slip through the cracks and the challenges it creates in integrating new team members who lack critical, undocumented knowledge. I pinpoint several root causes behind this phenomenon, including alert fatigue, misunderstandings about the alerts' purpose, and a culture that inadvertently celebrates crisis resolution over preventive measures.\n\nMy experience has led me to identify certain symptoms that indicate the presence of an error culture, such as an over reliance on email rules to filter alerts and a widespread uncertainty about why certain alerts are received in the first place. To move forward, I propose a refined strategy for managing alerts to ensure they are meaningful, actionable, and directed at the appropriate recipients. This approach involves clarifying the significance of each alert, tailoring them to the correct audience, and providing actionable resolution steps.\n\nThis talk will leave you with a call to action, urging a shift towards a more mindful and efficient approach to error management. By reevaluating our interaction with technology alerts, I believe we can transform them from noise into valuable signals that enhance organizational efficiency, resilience, and growth. Join me as I outline practical steps for combating error culture and fostering a proactive error management environment within our organizations.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/error-culture/"
+        }
+    ],
+    "speakers": [
+        "Ryan Cheley"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/JLYaAYY4JPc/maxresdefault.jpg",
+    "title": "Error Culture",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/JLYaAYY4JPc"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/faster-leaner-greener-10x-lower-website-carbon-emissions.json b/djangocon-us-2024/videos/faster-leaner-greener-10x-lower-website-carbon-emissions.json
new file mode 100644
index 000000000..301b83ef4
--- /dev/null
+++ b/djangocon-us-2024/videos/faster-leaner-greener-10x-lower-website-carbon-emissions.json
@@ -0,0 +1,26 @@
+{
+    "description": "We\u2019ll first look at a quantitative assessment of thousands of Django websites on the web, to get a good picture of the Django ecosystem\u2019s overall emissions, and understand which specific aspects of a project contribute to overall power and resource usage.\n\nWe\u2019ll then dive deeper on a single Django website\u2019s energy use, studying djangoproject.com specifically, as a good example of a high-traffic website with a big footprint. We\u2019ll use different performance testing, power measurement, and generic static analysis tools to understand how the site could be improved. We will review common issues, straightforward improvements, and more \u201cpie in the sky\u201d changes that are attainable with effort:\n\n- Energy consumption of front-end technology (React, HTMX, vanilla JS)\n- How design affects emissions (light vs. dark mode, image assets, fonts)\n- Application server: serverless Django options to reduce emissions\n- Database: how SQLite and other \"serverless\" database options can reduce emissions\n- Overlap with common Django performance considerations",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/faster-leaner-greener-10x-lower-website-carbon-emissions/"
+        }
+    ],
+    "speakers": [
+        "Thibaud Colas"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/sDPNwl6UZY4/maxresdefault.jpg",
+    "title": "Faster, leaner, greener: 10x lower website carbon emissions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/sDPNwl6UZY4"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/fighting-homelessness-with-django.json b/djangocon-us-2024/videos/fighting-homelessness-with-django.json
new file mode 100644
index 000000000..f9d72193b
--- /dev/null
+++ b/djangocon-us-2024/videos/fighting-homelessness-with-django.json
@@ -0,0 +1,26 @@
+{
+    "description": "My company built CHAMP, the online application for state-aided subsidized housing for the state of Massachusetts.  We did it in Django.  This site is used to find housing for thousands of low-income and homeless applicants a year.  The site handles over 10,000 monthly users at all times of day.  We've supported it in production for over five years, and deployed major new features continuously throughout that time.\n\nIn this talk, we'll cover the best tricks of Django we used to build the site, as well as the biggest challenges we faced and how we solved them.  This includes:\n\n* Using Django with Vue\n* Keeping the site running fast despite high user load and large data volumes\n* Managing duplicate applications in the system\n* Regularly replicating gigabytes of data to a data warehouse\n* Migrating data from 230 organizations into the system\n* Zero-downtime deployments\n* And more!",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/fighting-homelessness-with-django/"
+        }
+    ],
+    "speakers": [
+        "Benjamin \"Zags\" Zagorsky"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/eNq-fbSNbIo/maxresdefault.jpg",
+    "title": "Fighting Homelessness with Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/eNq-fbSNbIo"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/finding-2-0.json b/djangocon-us-2024/videos/finding-2-0.json
new file mode 100644
index 000000000..2b3b9299c
--- /dev/null
+++ b/djangocon-us-2024/videos/finding-2-0.json
@@ -0,0 +1,26 @@
+{
+    "description": "In the world of library development, achieving version 2.0 often takes years, if it's achieved at all. Surprisingly, nearly 90% of packages published to PyPI using semantic versioning have a major release number of less than two. What makes reaching this milestone so elusive?\n\nIf we applied software versioning to our lives, what version would we give ourselves? Perhaps in our formative years as students, we'd be a part of a 0.x series, and as we establish careers and become self-sufficient, we might progress to a 1.x scheme. But do we settle there?\n\nJust like software libraries, our lives require maintenance, and despite our best intentions, hacks and workarounds inevitably infiltrate our routines. As these multiply and compound, our health can suffer. Do we wait for disaster to strike? Or, can we take a proactive approach in not only addressing problem areas but also striving for more?\n\nTogether, we'll explore certain risks to our wellbeing inherent to our profession as software developers: sedentary lifestyles, long work hours, and social isolation, and how we can plan and design our next major release for success.\n\n\"Finding 2.0\" is an invitation to reimagine what's possible across life areas. Whether facing health struggles, burnout, or feeling stuck in a rut, this talk provides practical insights and actionable steps for rewriting the code of your life and embracing a future of health and fulfillment.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/finding-2-0/"
+        }
+    ],
+    "speakers": [
+        "Marc Gibbons"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/GtslRj85DGA/maxresdefault.jpg",
+    "title": "Finding 2.0",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/GtslRj85DGA"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/hidden-gems-of-django-5-x.json b/djangocon-us-2024/videos/hidden-gems-of-django-5-x.json
new file mode 100644
index 000000000..9d6bf81cc
--- /dev/null
+++ b/djangocon-us-2024/videos/hidden-gems-of-django-5-x.json
@@ -0,0 +1,26 @@
+{
+    "description": "Did you know Django doesn't include any bug fixes or code optimisations in it's release notes? \nEach feature release (.0, .1, .2) only draws attention to a handful of features and classes many as \"minor\", restricting them to a very small summarising bullet point. \n\nIf you're looking for more reasons to upgrade to the latest feature branch or are curious about hidden gems - this is the talk for you.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/hidden-gems-of-django-5-x/"
+        }
+    ],
+    "speakers": [
+        "Sarah Boyce"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/zxiqJCQTax0/maxresdefault.jpg",
+    "title": "Hidden gems of Django 5.x",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/zxiqJCQTax0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/how-to-design-and-implement-extensible-software-with-plugins.json b/djangocon-us-2024/videos/how-to-design-and-implement-extensible-software-with-plugins.json
new file mode 100644
index 000000000..d6db52f27
--- /dev/null
+++ b/djangocon-us-2024/videos/how-to-design-and-implement-extensible-software-with-plugins.json
@@ -0,0 +1,26 @@
+{
+    "description": "This talk will cover:\n\n- When to consider adding plugin support to your project\n- Understanding [Pluggy](https://pluggy.readthedocs.io/), the Python world's most mature plugin mechanism and possibly the most effective plugin framework in any language\n- How [entrypoints](https://packaging.python.org/en/latest/specifications/entry-points/) enable simply installing a new Python package to register it as an installed plugin\n- How to effectively design your plugin hooks: the ways in which your software can be customized by plugins\n- Traps to avoid in implementing plugins\n- Documentation! How to ensure potential authors have everything they need to start writing plugins\n\nI'll illustrate the talk with examples of different plugin patterns I have tried in my own software.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/how-to-design-and-implement-extensible-software-with-plugins/"
+        }
+    ],
+    "speakers": [
+        "Simon Willison"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wEqbxunc3wk/maxresdefault.jpg",
+    "title": "How to design and implement extensible software with plugins",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/wEqbxunc3wk"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/if-we-had-1000000-what-could-the-dsf-do-with-4x-its-budget.json b/djangocon-us-2024/videos/if-we-had-1000000-what-could-the-dsf-do-with-4x-its-budget.json
new file mode 100644
index 000000000..4ade2e763
--- /dev/null
+++ b/djangocon-us-2024/videos/if-we-had-1000000-what-could-the-dsf-do-with-4x-its-budget.json
@@ -0,0 +1,26 @@
+{
+    "description": "This talk comes to you in three parts:\n\n**Part 1: the DSF's budget.** That (roughly) $250k annual budget: where does it come from and where does it go? I'll break down our various sources of funding and the major ways we spend money. I'll look mostly at the 2024 budget, but will talk a bit about how these numbers fluctuate over time.\n\n**Part 2: If We Had $1,000,000.** Let's imagine that magically our budget grew by 4x, to $1m a year. What would we be able to do with all that money? What a budget that size mean to Django developers and the global Django community. I'll talk about a all wish list items that I and other DSF members have -- things the DSF _could_ be doing, but isn't, because we don't have the cash.\n\n**Part 3: How Do We Get There?** Unfortunately, we can't magic a 4x budget increase into existence \u2014 we have to do the work. How might we -- people both within and outside the DSF -- move towards increased funding. How can we incrementally move towards a future where the DSF is able to do lots more? This won't just be a \"you should donate to the DSF\" section. But also it will, just a little bit.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/if-we-had-1000000-what-could-the-dsf-do-with-4x-its-budget/"
+        }
+    ],
+    "speakers": [
+        "Jacob Kaplan-Moss"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2uBsbSQ6cWU/maxresdefault.jpg",
+    "title": "If We Had $1,000,000: What Could The DSF Do With 4x Its Budget?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/2uBsbSQ6cWU"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/introduction-to-opentelemetry-with-django.json b/djangocon-us-2024/videos/introduction-to-opentelemetry-with-django.json
new file mode 100644
index 000000000..d6b38f4a7
--- /dev/null
+++ b/djangocon-us-2024/videos/introduction-to-opentelemetry-with-django.json
@@ -0,0 +1,26 @@
+{
+    "description": "OpenTelemetry (OTel) is an observability framework for cloud-native software. It provides standardized APIs, libraries, and tools to collect telemetry data such as metrics, logs, and traces. OTel is open source and vendor neutral, designed to work with any backend system.\n\nThis talk will present several examples demonstrating why logs alone may be insufficient, along with the benefits of incorporating extra signals. These benefits include enhanced visibility into the execution flow and call timing, metrics on how users utilize services to pinpoint unnecessary ones, and the ability to detect patterns, such as peak usage times, which aids in production planning and scaling.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/introduction-to-opentelemetry-with-django/"
+        }
+    ],
+    "speakers": [
+        "Jessica Garson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/SS2q0NA4GFw/maxresdefault.jpg",
+    "title": "Introduction to OpenTelemetry with Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/SS2q0NA4GFw"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/keynote-how-to-be-a-developer-and-other-lies-we-tell-ourselves.json b/djangocon-us-2024/videos/keynote-how-to-be-a-developer-and-other-lies-we-tell-ourselves.json
new file mode 100644
index 000000000..1b63b9309
--- /dev/null
+++ b/djangocon-us-2024/videos/keynote-how-to-be-a-developer-and-other-lies-we-tell-ourselves.json
@@ -0,0 +1,26 @@
+{
+    "description": "In the children's book \"Am I Even A Bee?\" by Felicity Muth, Osmia begins feeling uneasy when she notices that she doesn't look like other bees at all. She even notices that some flies, moths, or beetles look more like bees than she does. Her perspective changes when she bumps into another unlikely bee named Xyla.\n\nOur journey as developers sometimes follows a similar pattern. We may question what it means to be a developer in the first place and we're not quite sure how we fit in. On the other end, when we grow to be more experienced, we may inadvertently (or sometimes consciously) make it more difficult for others to _belong_.\n\nWhat is the role of community in an individual's sense of identity, and what are some of the ways that we try to come to terms with our place within the developer landscape? Let's find out... together!",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/keynote-tuesday/"
+        }
+    ],
+    "speakers": [
+        "Mario Munoz"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/YT579vCBgvA/maxresdefault.jpg",
+    "title": "Keynote - How To Be A Developer and Other Lies We Tell Ourselves",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/YT579vCBgvA"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/keynote-power-to-the-people-who-teach-the-people.json b/djangocon-us-2024/videos/keynote-power-to-the-people-who-teach-the-people.json
new file mode 100644
index 000000000..2830d6aa5
--- /dev/null
+++ b/djangocon-us-2024/videos/keynote-power-to-the-people-who-teach-the-people.json
@@ -0,0 +1,26 @@
+{
+    "description": "One thing I absolutely love about the Python community is the fact that there are so many people with teacher's hearts. Teaching is an amazing thing, you can change a person's life just by spending some time with them, having conversations, showing them stuff.\u00a0\n\nIt's normal for people with software development skills to take on teaching roles - this might be through formal or informal workplace mentorship, community involvement, through being hired to teach or any number of other situations. Teaching and sharing knowledge is often a part of the job.\u00a0\u00a0\n\nSoftware development and teaching are two distinct skill sets. There is a science to teaching and learning - there is a robust body of knowledge, there are techniques, mindsets and patterns that make teaching effective. And, on the flip side, there are mistakes, anti-patterns and myths that are very much worth avoiding.\u00a0\u00a0\n\nIt's perfectly normal for software developers to take on teaching roles and responsibilities, but it's exceedingly rare for software developers to receive any training in how to teach well.\u00a0\n\nI've been working in alternative education for\u00a0quite some time, I've learned a lot of lessons along the way. In this talk, I'll share some of the most impactful lessons I've learned.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/keynote-monday/"
+        }
+    ],
+    "speakers": [
+        "Sheena O'Connell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-GpMgu8Utks/maxresdefault.jpg",
+    "title": "Keynote - Power to the People who Teach the People",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/-GpMgu8Utks"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/keynote-the-fellowship-of-the-pony.json b/djangocon-us-2024/videos/keynote-the-fellowship-of-the-pony.json
new file mode 100644
index 000000000..722446a1b
--- /dev/null
+++ b/djangocon-us-2024/videos/keynote-the-fellowship-of-the-pony.json
@@ -0,0 +1,26 @@
+{
+    "description": "This keynote will present the Django Fellowship program, highlighting its critical role in the maintenance and development of the Django project. It will cover the purpose and significance of the Fellowship, illustrating how it contributes to the project's overall success.\n\nThe talk will explore the daily tasks and responsibilities of a Django Fellow, including their priorities and key activities, with a focus on the contributing process . We will reflect on how we can make the most of the current Fellowship program, which is supported by 1.5 Fellows, and also on how the active involvement of the community is essential to Django's evolution.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/keynote-wednesday/"
+        }
+    ],
+    "speakers": [
+        "Natalia Bidart"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/leA7oWylQJg/maxresdefault.jpg",
+    "title": "Keynote - The Fellowship of the Pony",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/leA7oWylQJg"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/lessons-from-e2e-testing-web-applications.json b/djangocon-us-2024/videos/lessons-from-e2e-testing-web-applications.json
new file mode 100644
index 000000000..b731b9c52
--- /dev/null
+++ b/djangocon-us-2024/videos/lessons-from-e2e-testing-web-applications.json
@@ -0,0 +1,26 @@
+{
+    "description": "Lots of companies are investing in end to end testing to release high quality software and remain competitive in today\u2019s market. Now with libraries like Cypress and Playwright, end to end testing web applications have become very intuitive and a whole lot of fun.\u2028\u2028\n\nOver the years, after working with these tools, there are many lessons that I have learned the hard way. These valuable lessons taught me how to write robust and reliable tests that vastly improved the quality of my applications.\n\nIn this session, let's discuss best practices that I found useful to write E2E tests. These guidelines will enable you to release high quality software to your clients.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/lessons-from-e2e-testing-web-applications/"
+        }
+    ],
+    "speakers": [
+        "Avindra Fernando"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/bh0JvUBc09w/maxresdefault.jpg",
+    "title": "Lessons from E2E Testing Web Applications",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/bh0JvUBc09w"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/level-up-your-django-performance-identifying-and-taming-n-1-queries.json b/djangocon-us-2024/videos/level-up-your-django-performance-identifying-and-taming-n-1-queries.json
new file mode 100644
index 000000000..95637cbc3
--- /dev/null
+++ b/djangocon-us-2024/videos/level-up-your-django-performance-identifying-and-taming-n-1-queries.json
@@ -0,0 +1,27 @@
+{
+    "description": "In this presentation, attendees will embark on a journey to understand and overcome the notorious N+1 query problem in Django development. The session will begin with an exploration of the importance of performance optimization in Django applications, emphasizing the critical role of efficient database queries in achieving robust and scalable web solutions.\n\nWe will delve into the intricacies of the N+1 query problem, unraveling its origins and impact on application performance. Through real-world examples and case studies, attendees will gain a deeper understanding of how N+1 queries manifest and the detrimental effects they can have on Django applications, such as increased latency, decreased throughput, and degraded user experience.\n\nThe core of the presentation will focus on practical solutions to mitigate the N+1 query problem and optimize Django code for enhanced performance. Attendees will learn how to identify N+1 queries in their projects and understand the underlying causes behind them. We will explore a range of techniques and best practices for resolving N+1 queries, including lazy loading, prefetching, and leveraging Django's ORM features such as select_related and prefetch_related.\n\nMoreover, the attendees will discover how to utilize debugging tools and techniques, including the Django Debug Toolbar and SQL logging, to diagnose and address N+1 query issues effectively.\n\nAs the presentation draws to a close, we'll leave attendees with a thought-provoking question: \"Why do some experts caution that fixing certain N+1 queries could potentially hurt performance?\" This question invites attendees to delve deeper into the complexities of performance optimization and encourages further research and exploration into the nuanced considerations of optimizing database queries in Django applications.\n\nBy the end of the presentation, attendees will be equipped with actionable insights and practical skills to:\nIdentify and diagnose N+1 queries in their Django projects.\nImplement effective solutions to optimize application performance and eliminate performance bottlenecks.\nUtilize debugging tools and techniques to pinpoint and resolve N+1 query issues efficiently.\n\nThis presentation is designed for Django developers of all experience levels, from beginners to seasoned professionals. Whether you're new to Django or a seasoned veteran, join us to deepen your understanding of Django performance optimization and elevate your development skills to the next level.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/level-up-your-django-performance-identifying-and-taming-n-1-queries/"
+        }
+    ],
+    "speakers": [
+        "Mohammad Ahtasham ul Hassan",
+        "Shafqat Farhan Ahmed"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/KngX7n26jWQ/maxresdefault.jpg",
+    "title": "Level Up Your Django Performance: Identifying and Taming N+1 Queries",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/KngX7n26jWQ"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/lightning-talks-monday.json b/djangocon-us-2024/videos/lightning-talks-monday.json
new file mode 100644
index 000000000..6081f5fa7
--- /dev/null
+++ b/djangocon-us-2024/videos/lightning-talks-monday.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/lightning-talks-monday/"
+        }
+    ],
+    "speakers": [
+        "Andrew Mshar"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/T5w7Dbslw6o/maxresdefault.jpg",
+    "title": "Lightning Talks (Monday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/T5w7Dbslw6o"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/lightning-talks-tuesday.json b/djangocon-us-2024/videos/lightning-talks-tuesday.json
new file mode 100644
index 000000000..3b94b6e5c
--- /dev/null
+++ b/djangocon-us-2024/videos/lightning-talks-tuesday.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/lightning-talks-tuesday/"
+        }
+    ],
+    "speakers": [
+        "Andrew Mshar"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/dUJ1LscUpYU/maxresdefault.jpg",
+    "title": "Lightning Talks (Tuesday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/dUJ1LscUpYU"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/lightning-talks-wednesday.json b/djangocon-us-2024/videos/lightning-talks-wednesday.json
new file mode 100644
index 000000000..6cbaeefee
--- /dev/null
+++ b/djangocon-us-2024/videos/lightning-talks-wednesday.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/lightning-talks-wednesday/"
+        }
+    ],
+    "speakers": [
+        "Andrew Mshar"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/IB6lgQrGyns/maxresdefault.jpg",
+    "title": "Lightning Talks (Wednesday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/IB6lgQrGyns"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/maps-with-django.json b/djangocon-us-2024/videos/maps-with-django.json
new file mode 100644
index 000000000..c56bf1a47
--- /dev/null
+++ b/djangocon-us-2024/videos/maps-with-django.json
@@ -0,0 +1,26 @@
+{
+    "description": "A *map* in a website is the best way to make geographic data easily accessible to users because it represents, in a simple way, the information relating to a specific geographical area and is used by many online services.\n\nIn this talk, we'll see how to create a web *map* with the **Python** based web framework **Django** using its **GeoDjango** module, storing geographic data in your local database on which to run geospatial queries.\n\nThrough this talk, you can learn how to add a *map* to your website, starting from a simple *map* based on **Spatialite/SQLite** up to a more complex and interactive *map* based on **PostGIS/PostgreSQL**.\n\nThe talk will be structured like a **hike** in the mountains, it will start gradually and then increase in **difficulty**, stopping in key **passages** and then arriving at the final **goal**.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/maps-with-django/"
+        }
+    ],
+    "speakers": [
+        "Paolo Melchiorre"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/r54ViYzzDlw/maxresdefault.jpg",
+    "title": "Maps with Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/r54ViYzzDlw"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/one-thousand-and-one-django-sites.json b/djangocon-us-2024/videos/one-thousand-and-one-django-sites.json
new file mode 100644
index 000000000..d8df56117
--- /dev/null
+++ b/djangocon-us-2024/videos/one-thousand-and-one-django-sites.json
@@ -0,0 +1,26 @@
+{
+    "description": "This talk will touch on strategies and challenges we have encountered along our journey of hosting over 1,000 Django/Wagtail sites. Told in the storybook style of \"One Thousand and One Nights\" (a.k.a. \"Arabian Nights\") this talk will feature real-world anecdotes about: technical architecture, business challenges, financial challenges, customer support, and security challenges such as dealing with onslaughts of spammers and attack vectors.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/one-thousand-and-one-django-sites/"
+        }
+    ],
+    "speakers": [
+        "Vince Salvino"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/WRtrlFUmHHA/maxresdefault.jpg",
+    "title": "One Thousand and One Django Sites",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/WRtrlFUmHHA"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/only-reliable-data-protecting-database-integrity.json b/djangocon-us-2024/videos/only-reliable-data-protecting-database-integrity.json
new file mode 100644
index 000000000..9a9a13a05
--- /dev/null
+++ b/djangocon-us-2024/videos/only-reliable-data-protecting-database-integrity.json
@@ -0,0 +1,26 @@
+{
+    "description": "Database transactions are incredibly important for the reliability of financial operations. The reliability and accuracy of these tarnsactions hinge upon robust database integrity measures. This presentation will explore key concepts essential to maintaining database integrity within financial ledger environments using the Django Framework.\n\nAttendees will gain insights into the following aspects:\n1. Transaction Atomicity: Understanding how atomic database transactions are performed in Django to ensure data consistency.\n2. Concurrency Control: Using the Django ORM to manage concurrent transactions to safeguard data against corruption.\n3. Durability through Logging: Performing transaction logging to ensuring help teams recover from failures.\n\nThis talk will address real-world challenges and considerations in implementing and maintaining database integrity using the Django framework. Practical examples and case studies will be shared to illustrate the application of database integrity with the help of the Django ORM.\n\nWhether the attendee is a database administrator or a developer, this session will provide valuable insights into the foundational principles and strategies for upholding database integrity in critical financial environments.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/only-reliable-data-protecting-database-integrity/"
+        }
+    ],
+    "speakers": [
+        "Eva Nanyonga"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/BVkUf9_Hc5I/maxresdefault.jpg",
+    "title": "Only reliable Data: Protecting Database Integrity",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/BVkUf9_Hc5I"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/open-source-python-tools-to-visualize-and-analyse-geospatial-data.json b/djangocon-us-2024/videos/open-source-python-tools-to-visualize-and-analyse-geospatial-data.json
new file mode 100644
index 000000000..0aef2b481
--- /dev/null
+++ b/djangocon-us-2024/videos/open-source-python-tools-to-visualize-and-analyse-geospatial-data.json
@@ -0,0 +1,26 @@
+{
+    "description": "The talk will provide an overview of the available Python related geospatial tools that can be used to analyze location data highlighting the possibilities and the potential of this attendees will be able to grasp what tools they can use to access particular location data.\nAmong the available\u00a0python\u00a0geospatial tools we will discuss the main and most used in accessing location data types raster and vector, we will have a look at how these base tools can be used to access the types and their benefits.\nWe will then dive into one of the tools called QGIS and use it as an exemplar of how we can now interact, analyze, and visualize geospatial data in Python. A step-by-step guide on how to import and use QGIS features in Python.\nQGIS is a freely downloadable open-source GIS software suite that contains a desktop option, mobile, and web components. QGIS version 3.14 was released with a Temporal Controller an interesting feature that allows immersive and creative visualization of time-based geospatial data.\nThen we will see how QGIS can be used inside Django as a package. Showing how to achieve a link between the two tools.\u00a0\nAt the end of the talk attendees should expect to have a comprehensive understanding of different Python geospatial tools, whether you are a developer or a professional learning new ways of technology, this talk will equip you with the knowledge on the right geospatial tools.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/open-source-python-tools-to-visualize-and-analyse-geospatial-data/"
+        }
+    ],
+    "speakers": [
+        "Samweli Mwakisambwe"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/p6ioi-dWtpc/maxresdefault.jpg",
+    "title": "Open-source Python tools to visualize and analyse geospatial data.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/p6ioi-dWtpc"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/opening-remarks-monday.json b/djangocon-us-2024/videos/opening-remarks-monday.json
new file mode 100644
index 000000000..8f580c6e0
--- /dev/null
+++ b/djangocon-us-2024/videos/opening-remarks-monday.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/opening-remarks-monday/"
+        }
+    ],
+    "speakers": [
+        "Peter Grandstaff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/oK-8tu1CsWs/maxresdefault.jpg",
+    "title": "Opening Remarks (Monday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/oK-8tu1CsWs"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/opening-remarks-tuesday.json b/djangocon-us-2024/videos/opening-remarks-tuesday.json
new file mode 100644
index 000000000..3531c8db5
--- /dev/null
+++ b/djangocon-us-2024/videos/opening-remarks-tuesday.json
@@ -0,0 +1,26 @@
+{
+    "description": "Velda will introduce Tuesday's keynote and go over any administrative notes for the day.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/opening-remarks-tuesday/"
+        }
+    ],
+    "speakers": [
+        "Velda Kiara"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/GWEE8_EaJXQ/maxresdefault.jpg",
+    "title": "Opening Remarks (Tuesday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/GWEE8_EaJXQ"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/opening-remarks-wednesday.json b/djangocon-us-2024/videos/opening-remarks-wednesday.json
new file mode 100644
index 000000000..14aee6102
--- /dev/null
+++ b/djangocon-us-2024/videos/opening-remarks-wednesday.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/opening-remarks-wednesday/"
+        }
+    ],
+    "speakers": [
+        "Peter Grandstaff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/cL_3Zkhl-fY/maxresdefault.jpg",
+    "title": "Opening Remarks (Wednesday)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/cL_3Zkhl-fY"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/operations-the-missing-django-piece.json b/djangocon-us-2024/videos/operations-the-missing-django-piece.json
new file mode 100644
index 000000000..c0aebba6c
--- /dev/null
+++ b/djangocon-us-2024/videos/operations-the-missing-django-piece.json
@@ -0,0 +1,26 @@
+{
+    "description": "In this talk, I\u2019m going to demonstrate a new perspective on how to structure Django codebases using something I call \u201cOperations\u201d, so that Django codebases can scale well with any amount of features or complexity inside an application as it grows over time.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/operations-missing-django-piece/"
+        }
+    ],
+    "speakers": [
+        "Micah Lyle"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/J-_VQq_wrUs/maxresdefault.jpg",
+    "title": "Operations: The Missing Django Piece",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/J-_VQq_wrUs"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/optimizing-remote-work-pull-requests-stand-ups-and-emojis.json b/djangocon-us-2024/videos/optimizing-remote-work-pull-requests-stand-ups-and-emojis.json
new file mode 100644
index 000000000..b5c29d3e3
--- /dev/null
+++ b/djangocon-us-2024/videos/optimizing-remote-work-pull-requests-stand-ups-and-emojis.json
@@ -0,0 +1,26 @@
+{
+    "description": "Positive asynchronous working relationships have always been a core feature of what makes Django successful. Many of us have spent our careers working asynchronously across International borders and timezones, but it's new to many of our clients, employers, and project stakeholders. \n\nIn this talk, I'd like to discuss an important ingredient of successful asynchronous work: clear, concise communication. We'll discuss the importance of establishing clear boundaries and expectations early and often. We'll learn how to write excellent issues and pull requests, and how to tailor your writing to various audiences and purposes that arise in every project. We'll talk about when scheduling a meeting is actually a good idea, and how to communicate your successes, status reports, and blockers to those who need to know.\n\nClear communication is the key to good working relationships. Good working relationships make for happier, more productive teams, healthier work/life balance, and ultimately optimized profits and delivery. Let's work better together!",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/optimizing-remote-work-pull-requests-stand-ups-and-emojis/"
+        }
+    ],
+    "speakers": [
+        "Kasey Kelly"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/yKP8DHaNpkg/maxresdefault.jpg",
+    "title": "Optimizing remote work: Pull Requests, Stand-ups, and emojis",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/yKP8DHaNpkg"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/orientation.json b/djangocon-us-2024/videos/orientation.json
new file mode 100644
index 000000000..2ba15dc92
--- /dev/null
+++ b/djangocon-us-2024/videos/orientation.json
@@ -0,0 +1,26 @@
+{
+    "description": "",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/orientation/"
+        }
+    ],
+    "speakers": [
+        "Kojo Idrissa"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/hkYxUN7YJH0/maxresdefault.jpg",
+    "title": "Orientation",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/hkYxUN7YJH0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/panel-discussion-open-friendly-and-welcoming-on-the-history-and-future-of-mentoring-in-django.json b/djangocon-us-2024/videos/panel-discussion-open-friendly-and-welcoming-on-the-history-and-future-of-mentoring-in-django.json
new file mode 100644
index 000000000..ebdda8040
--- /dev/null
+++ b/djangocon-us-2024/videos/panel-discussion-open-friendly-and-welcoming-on-the-history-and-future-of-mentoring-in-django.json
@@ -0,0 +1,26 @@
+{
+    "description": "Lacey Henschel will moderate a panel discussion on the history and future of communities within the Django community.\nWe'll explore how mentoring, community involvement, and support networks are important in keeping Django resilient. By highlighting the work of groups like Django Girls, PyLadies, Djangonaut Space, and Black Python Devs, we\u2019ll see how these initiatives not only foster personal growth but also play a vital role in keeping the Django community strong and sustainable for the long term.\n\nWe\u2019ll discuss:\n\n- Panelists' unique journeys in the Django community\n- The role of mentorship, sponsorship, and advocacy in these communities and in Django's future\n- Successes and challenges in building supportive, sustainable communities\n- How the Django community can keep investing in long-term success\n\nOur panelists include:\n- **Lacey Henschel**, moderator, former Django Girls contributor and organizer\n- **Keanya Phelps**, Django Girls organizer and participant, mentor in Djangonaut Space\n- **Afi Maame Dufie**, involved in Django Girls, PyLadies, and Black Python Devs\n- **Sarah Boyce**, Django Fellow, co-founder and mentor in Djangonaut Space\n- **Carlton Gibson**, former Django Fellow, mentor in Djangonaut Space, mentor and coordinator of Django's efforts in Google Summer of Code, and Django Girls coach and advisory board member.\n- **Velda Kiara**, DEFNA director, former [AnitaB.org](http://anitab.org/) Kenya Community Lead, former Open Source Community Africa Nairobi organizer and contributor, participant in Djangonaut Space, and current contributor and leader of Black Python Devs\n\nJoin us as we reflect, explore, and hopefully inspire even more excitement and support for our broader Django communities.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/panel-discussion-mentoring-django/"
+        }
+    ],
+    "speakers": [
+        "Lacey Henschel"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/SzrgDmMBipo/maxresdefault.jpg",
+    "title": "Panel Discussion: Open, friendly, and welcoming: on the history and future of mentoring in Django",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/SzrgDmMBipo"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/passkeys-your-password-free-future.json b/djangocon-us-2024/videos/passkeys-your-password-free-future.json
new file mode 100644
index 000000000..e272008e5
--- /dev/null
+++ b/djangocon-us-2024/videos/passkeys-your-password-free-future.json
@@ -0,0 +1,26 @@
+{
+    "description": "We'll start at the beginning, with a simple username and password login form, and explore various approaches that the web has taken to try to solve it.\n\nWe'll explore briefly OpenID (remember that?), Federation, Single Sign-on, Magic Links, and Login Codes, and why each of them has usability drawbacks that often mean that the username and password, especially combined with a password manager, just can't be beat for its user experience.\n\nPasskeys, however, are the better option that we've been waiting for. There are still some important trade-offs, but are a much better fit for consumer applications, with a user experience that is quite comparable to using a password manager.\n\nThey can be a simple login button, or they can augment a username and password dialog very similarly to a password manager's autocomplete. Finally, we have a way that gives a good user experience and doesn't have us storing a potentially shared secret!\n\nNow that we've motivated passkeys, we'll explore how we can integrate them into Django. We'll see how we can use them to log into the Django admin. Then we'll see if we can disable them entirely for Django, and how we can bootstrap our superuser account creation, so that our new Django project never has a username and password form at all!\n\nAlong the way, we'll also cover some important challenges that can come up with Passkeys in development and how to address them, including dealing with localhost, and remote development environments like Codespaces.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/passkeys-your-password-free-future/"
+        }
+    ],
+    "speakers": [
+        "Ryan Hiebert"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ylv_k8TRpPk/maxresdefault.jpg",
+    "title": "Passkeys: Your password-free future",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/ylv_k8TRpPk"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/path-user-user-username-user-view-profile.json b/djangocon-us-2024/videos/path-user-user-username-user-view-profile.json
new file mode 100644
index 000000000..0041592be
--- /dev/null
+++ b/djangocon-us-2024/videos/path-user-user-username-user-view-profile.json
@@ -0,0 +1,26 @@
+{
+    "description": "Since Django-2.0, most people use path converters instead of regexes to describe the different URL patterns, and how these will trigger views. One can use the already builtin path converters, but also define new ones to parse dates, booleans, etc. more effectively. One can not only define a pattern, but also provide methods to convert between Python objects and URL fragments.\n\nThat last feature can be used to automatically fetch model objects if the path contains the value for the primary key of the model object, or another unique field. We thus avoid writing queries to fetch the objects, but can also turn these into lazy objects where we postpone the roundtrip to the database, until the view needs that object, and thus save a roundtrip if the view has a codepath that does not require the object. Some databases also allow to combine multiple queries in one roundtrip, so we can combine all the objects that go to the same database, limiting the roundtrips further.\n\nA problem with path patterns in general is that often they overlap: the same path can trigger multiple patterns. In that case the first one is picked. This issue has already lead to countless hours of debugging since people expect a different view to be triggered. Since path patterns eventually compile to regexes, and one can determine if two regexes (fully) overlap, we can automatically detect if there are paths for which two or more URL patterns are triggered, and in case a pattern is fully covered by patterns above, advise to rearrange the patterns. Probably not very suprisingly we found that Django's admin pages suffer from this issue as well: if we make a model with a `CharField` as primary key, then adding items with \"remove\" or \"history\" as value for the primary key, means certain views can not be used for these objects. We show some ways to mitigate this.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/path-user-user-username-user-view-profile/"
+        }
+    ],
+    "speakers": [
+        "Willem Van Onsem"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Tx0vqVyXIyw/maxresdefault.jpg",
+    "title": "path('/user/<user.username:user>/', view_profile)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/Tx0vqVyXIyw"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/postgresql-beyond-django-strategies-to-get-max-performance.json b/djangocon-us-2024/videos/postgresql-beyond-django-strategies-to-get-max-performance.json
new file mode 100644
index 000000000..fcf0f4d5a
--- /dev/null
+++ b/djangocon-us-2024/videos/postgresql-beyond-django-strategies-to-get-max-performance.json
@@ -0,0 +1,26 @@
+{
+    "description": "PostgreSQL has been evolving in functionality and performance for decades, yet we often fail to extract full potential of the most advanced FL/OSS RDBMS. In this talk, I'll cover techniques for optimizing database performance and reducing space usage, beyond the basics of modeling and indexing and exploring powerful features such as triggers and bulk data import/export (not the Django one).\nIf you want to handle millions of records easily and lower your infrastructure costs, this talk is for you! All the features mentioned will be presented using a simple Django app, created specifically for this talk. Topics to be covered:\n- Introduction of the speaker\n- Context about the dataset used on examples (52M+ rows)\n- Issues caused by inadequate data modeling (from wrong types to field ordering)\n- Understanding query execution\n- Indexing, triggers, and other tools\n- Using postgres' full-text search the right way\n- Importing and exporting large amounts of data with Python",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/postgresql-beyond-django-strategies-to-get-max-performance/"
+        }
+    ],
+    "speakers": [
+        "Alvaro Justen"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/oDosT7ol9rw/maxresdefault.jpg",
+    "title": "PostgreSQL Beyond Django: Strategies to Get Max Performance",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/oDosT7ol9rw"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/product-101-for-techies-and-tech-teams.json b/djangocon-us-2024/videos/product-101-for-techies-and-tech-teams.json
new file mode 100644
index 000000000..6763c2852
--- /dev/null
+++ b/djangocon-us-2024/videos/product-101-for-techies-and-tech-teams.json
@@ -0,0 +1,26 @@
+{
+    "description": "In this talk, I intend to cover basic product concepts with the goal of sparking engineers' interest in how their work can have a greater impact in their users' lives. In my opinion, everyone in tech should be able to speak a little of their colleagues' language so that we can better collaborate and be more efficient as teams. With that said, I believe any engineers who would like to become more product-minded will benefit from attending as the talk covers the most common topics in that knowledge domain, serving as an introduction to the product world.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/product-101-for-techies-and-tech-teams/"
+        }
+    ],
+    "speakers": [
+        "Amanda Savluchinske"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/75M0MC66H2o/maxresdefault.jpg",
+    "title": "Product 101 for Techies and Tech Teams",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/75M0MC66H2o"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/project-management-in-open-source.json b/djangocon-us-2024/videos/project-management-in-open-source.json
new file mode 100644
index 000000000..56bf43adc
--- /dev/null
+++ b/djangocon-us-2024/videos/project-management-in-open-source.json
@@ -0,0 +1,26 @@
+{
+    "description": "This Session will highlight and expand on better practices of Project Management in open-source while focusing on exploring the complexities of leading projects, maximizing various forms of collaboration, decentralized decision-making, and community-driven innovation promoting inclusivity. \n\nThere will be interactive sessions and case studies to provide practical insights and how to navigate various forms of challenges and opportunities to aid my  objectives which include \n\n- Equiping project managers, developers and enthusiasts with the right information and knowledge \n- \u2060Ways of maximising diverse talents in projects \n- \u2060Fostering transparency in all areas \n- \u2060Forms of promoting and encouraging volunteer-driven teams",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/project-management-in-open-source/"
+        }
+    ],
+    "speakers": [
+        "Harmony Elendu"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/0xotTtQh6Z0/maxresdefault.jpg",
+    "title": "Project Management in Open Source",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/0xotTtQh6Z0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/pygoat-learn-django-security-the-hard-way.json b/djangocon-us-2024/videos/pygoat-learn-django-security-the-hard-way.json
new file mode 100644
index 000000000..90a52392c
--- /dev/null
+++ b/djangocon-us-2024/videos/pygoat-learn-django-security-the-hard-way.json
@@ -0,0 +1,26 @@
+{
+    "description": "Pygoat is an intentionally vulnerable Python Django application that can be used to learn to secure our Django apps. In this talk, we will attack a deployed Pygoat application, identify the underlying security issues in our code, and then secure it. We will learn about common security vulnerabilities (OWASP Top 10) in Django apps and how to fix them so that we can keep our applications safe from attackers.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/pygoat-learn-django-security-the-hard-way/"
+        }
+    ],
+    "speakers": [
+        "Adarsh Divakaran"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-KcGTEVTUv4/maxresdefault.jpg",
+    "title": "Pygoat - Learn django security the hard way",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/-KcGTEVTUv4"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/seamless-transition-how-i-converted-an-existing-mysql-database-to-be-fully-managed-by-django-migrations-framework.json b/djangocon-us-2024/videos/seamless-transition-how-i-converted-an-existing-mysql-database-to-be-fully-managed-by-django-migrations-framework.json
new file mode 100644
index 000000000..d6e555e5c
--- /dev/null
+++ b/djangocon-us-2024/videos/seamless-transition-how-i-converted-an-existing-mysql-database-to-be-fully-managed-by-django-migrations-framework.json
@@ -0,0 +1,26 @@
+{
+    "description": "In this presentation, I aim to demystify the complexities of database migrations in Django, catering to audiences with basic knowledge of the framework. Through a structured approach, I will delve into three key topics:\n\n- Understanding Django's Migration Process: I will elucidate how Django determines and executes migrations, shedding light on the underlying mechanisms that govern this process.\n- Managing Dependencies in Migration Files: Delving deeper, I'll explore how dependencies within migration files impact the migration process, offering insights into best practices to navigate potential challenges.\n- Practical Steps for Migrating an Existing Database: Leveraging my own experience, I will guide attendees through a step-by-step methodology for migrating an existing database to Django. This will include:\n1. Ensuring consistency in the id field type and configuring the DEFAULT_AUTO_FIELD setting accordingly. I'll also address strategies for handling inconsistencies.\n2. Utilizing 'manage.py inspectdb' to generate models and incorporating them into the 'models.py' file.\n3. Transitioning models from 'managed=False' to 'managed=True' to initiate migration tracking.\n4. Handling existing Many-to-Many Relationships seamlessly.\n5. Generating initial migration files with 'manage.py makemigrations' and faking the initial migration with 'manage.py migrate --fake'.\n6. Optionally, creating ForeignKey fields and enforcing backend foreign key relationships.\n7. Addressing the cleanup of orphaned columns in preparation for conversion to Foreign Keys.\n\nThis talk will be structured with slides covering the first two topics, followed by a practical demonstration of the third topic through real-world examples and code snippets.\n\nIt's important to note that while my methodology was successful with a MySQL database, variations may occur with other database languages. In the event of selection, I am committed to collaborating with a mentor to adapt the content for broader applicability.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/seamless-transition-how-i-converted-an-existing-mysql-database-to-be-fully-managed-by-django-migrations-framework/"
+        }
+    ],
+    "speakers": [
+        "Daniel Ramas"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-JLmeUC-JGM/maxresdefault.jpg",
+    "title": "Seamless Transition: How I Converted an Existing MySQL Database to be Fully Managed by Django Migrations Framework",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/-JLmeUC-JGM"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/streaming-video-in-django-demystified.json b/djangocon-us-2024/videos/streaming-video-in-django-demystified.json
new file mode 100644
index 000000000..e06b7bef9
--- /dev/null
+++ b/djangocon-us-2024/videos/streaming-video-in-django-demystified.json
@@ -0,0 +1,26 @@
+{
+    "description": "## General details\n\n**Level**: All\n**Categories** : Async, Django Channels, Video processing\n\n## Table of Contents\n\n1. **Introduction**\n   - Brief overview of video streaming\n   - Explain me like I'm 5 : How does Video Streaming work?\n\n2. **Video Streaming Protocols**\n   - Understanding HLS (HTTP Live Streaming)\n   - Overview of MPEG-DASH (Dynamic Adaptive Streaming over HTTP)\n   - HLS vs MPEG-DASH: A comparative analysis\n\n3. **Media Processing Approaches**\n   - Defining the model for media processing\n   - Introduction to FFmpeg\n   - Exploring Microservices for Media Processing\n   - Celery Task: An asynchronous processing approach\n   - Async vs Sync model functions : Model Function Approach\n   - Handling media processing on upload\n   - Make the user do all the work Approach\n\n4. **Video Streaming Implementation**\n   - Frontend demonstration with media file logic\n\n5. **Scaling Video Streaming with Django Channels**\n   - Explaining the role of Django Channels\n   - Diagram illustrating how Django Channels facilitates scaling\n   - Code samples demonstrating Django Channels in action\n\n6. **Conclusion**\n   - Summing up key points\n   - Emphasizing the importance of efficient video streaming architectures",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/streaming-video-in-django-demystified/"
+        }
+    ],
+    "speakers": [
+        "Vaarun Sinha"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/p78ddlh21Rg/maxresdefault.jpg",
+    "title": "Streaming Video in Django | Demystified",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/p78ddlh21Rg"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/the-art-of-not-redirecting.json b/djangocon-us-2024/videos/the-art-of-not-redirecting.json
new file mode 100644
index 000000000..630da194d
--- /dev/null
+++ b/djangocon-us-2024/videos/the-art-of-not-redirecting.json
@@ -0,0 +1,26 @@
+{
+    "description": "URLs are meant to never change, but change is the only constant of thriving products. As web developers we have the duty to not only design our URLs in a way that they withstand the passage of time, but also to \"never\" break old URLs when, in the face of inevitable change, we are forced to re-design them in order to keep a consistent experience in our evolving products. Join me in this practical journey to master URL design and evolution.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/the-art-of-not-redirecting/"
+        }
+    ],
+    "speakers": [
+        "Lorenzo Peña"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wKwOFCSd_xw/maxresdefault.jpg",
+    "title": "The art of (not) redirecting",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/wKwOFCSd_xw"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/the-magic-of-dependencies-installing-themselves.json b/djangocon-us-2024/videos/the-magic-of-dependencies-installing-themselves.json
new file mode 100644
index 000000000..ed66f7526
--- /dev/null
+++ b/djangocon-us-2024/videos/the-magic-of-dependencies-installing-themselves.json
@@ -0,0 +1,26 @@
+{
+    "description": "When you write a Python script that has dependencies, the standard has always been to use a separate file like requirements.txt or pyproject.toml (using Tom\u2019s Obvious, Minimal Language format) for handling the dependencies from external libraries. To share these scripts that are dependent on external libraries or other versions of Python, the process becomes more complex since the receiver has no choice but to create a new virtual environment with all the necessary dependencies. It becomes even more cumbersome in educational settings or among collaborators, where people might have different levels of Python expertise.\n\nWith the introduction of PEP 723, we\u2019ve brought simplicity to our code, as we can now embed dependencies directly in a single file script. In this talk, we will explore this new method that enhances our productivity by making it easier to share, deploy, and work with Python scripts, making working with Django closer to being seamless.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/the-magic-of-dependencies-installing-themselves/"
+        }
+    ],
+    "speakers": [
+        "Ilerioluwakiiye Abolade"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/908fpWtYyj0/maxresdefault.jpg",
+    "title": "The Magic of Dependencies Installing Themselves",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/908fpWtYyj0"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/troubleshooting-is-a-lifestyle.json b/djangocon-us-2024/videos/troubleshooting-is-a-lifestyle.json
new file mode 100644
index 000000000..2c5426a55
--- /dev/null
+++ b/djangocon-us-2024/videos/troubleshooting-is-a-lifestyle.json
@@ -0,0 +1,26 @@
+{
+    "description": "## Audience Level\n\nBeginner to Intermediate\n\nThis talk is suitable for anyone who wants to improve their troubleshooting skills, regardless of their industry or technical background. No prior troubleshooting experience is required, but a basic understanding of technology concepts will be helpful. We will start with general concepts, and move into some practical and technical examples specific to Django and Python.\n\n## Objectives\n\nBy the end of this talk, attendees will understand how to:\n\n- Break down complex problems into manageable parts\n- Utilize the tools and resources available for effective troubleshooting\n- Learn to ask for help and leverage online communities\n- Avoid tunnel vision and maintain a broad perspective when diagnosing issues\n- Document the troubleshooting process to track progress and learn from experiences\n\n## Outline\n\n1. Introduction (4 minutes)\n    - My background in electronics design, radar maintenance, and software development\n2. The Troubleshooting Mindset (5 minutes)\n    - The importance of troubleshooting skills in various fields\n    - Why troubleshooting is a lifestyle \ud83d\ude0e, not just a job skill\n    - The importance of persistence and curiosity\n3. Breaking Down Problems (6 minutes)\n    - Strategies for dissecting complex issues into manageable components\n    - The power of isolating variables and narrowing down the scope\n4. Utilizing Tools and Resources (10 minutes)\n    - Introduction to a wide variety of troubleshooting tools and indicators for solving problems with Django and Python\n5. Asking for Help (6 minutes)\n    - The importance of knowing when to seek assistance\n    - How to ask for help effectively and provide the necessary information\n6. Avoiding Tunnel Vision (5 minutes)\n    - Recognizing the dangers of focusing too narrowly on a single solution or part of the problem\n    - Techniques for maintaining a broad perspective and exploring alternative approaches\n7. Documenting The Process (5 minutes)\n    - The benefits of writing down your troubleshooting steps and findings\n    - How to create a troubleshooting log and learn from your experiences\n8. Conclusion and Q&A (4 minutes)\n    - Summarize key points.\n\n## Prerequisites\n\n- Basic understanding of technology concepts\n- Curiosity and a willingness to learn\n- Pen and paper or a digital note-taking device",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/troubleshooting-is-a-lifestyle/"
+        }
+    ],
+    "speakers": [
+        "Jack Linke"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/a7iUKbug82k/maxresdefault.jpg",
+    "title": "Troubleshooting is a Lifestyle \ud83d\ude0e",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/a7iUKbug82k"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/unlocking-performance-benchmarking-and-profiling-django-for-maximum-efficiency.json b/djangocon-us-2024/videos/unlocking-performance-benchmarking-and-profiling-django-for-maximum-efficiency.json
new file mode 100644
index 000000000..82f90dc92
--- /dev/null
+++ b/djangocon-us-2024/videos/unlocking-performance-benchmarking-and-profiling-django-for-maximum-efficiency.json
@@ -0,0 +1,26 @@
+{
+    "description": "In most cases performance issues are caused by a very small fraction of the application.  Identifying these bottlenecks can be a daunting task. Well, not anymore, we now have tools to easily identify these bottlenecks. In this talk we will talk about it all: the why, what and how to do profiling and benchmarking.\n\nWe will look at `django-silk` for profiling while for benchmarking we will be using the ever reliable `pytest-benchmark`. We will cover the basics and slowly move into seeing things like the actual raw query buried which is buried in Django. Lastly l will share tips on how to avoid over running your services while try to optimise. This talk is suitable for intermediate to senior developers, however junior developers can also benefit.",
+    "language": "eng",
+    "recorded": "2024-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/unlocking-performance-benchmarking-and-profiling-django-for-maximum-efficiency/"
+        }
+    ],
+    "speakers": [
+        "Ron Maravanyika"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/zm3QkypHdHY/maxresdefault.jpg",
+    "title": "Unlocking Performance: Benchmarking and profiling Django for Maximum Efficiency",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/zm3QkypHdHY"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/upgrading-eol-django-a-journey-from-v1-to-v5.json b/djangocon-us-2024/videos/upgrading-eol-django-a-journey-from-v1-to-v5.json
new file mode 100644
index 000000000..3342e3180
--- /dev/null
+++ b/djangocon-us-2024/videos/upgrading-eol-django-a-journey-from-v1-to-v5.json
@@ -0,0 +1,26 @@
+{
+    "description": "Finding out that an application is using a legacy version of a framework can be a stressful and intimidating task, knowing that you're going to be responsible for bringing the application back to a supported version.  This talk will cover what this type of journey would look like in the Django ecosystem by using a real world example of a small Django project that was acquired from its original developer. We will be covering multiple different scenarios and also be providing helpful tips for approaching legacy applications in general along the way.  \n\nBy the end of the talk, the attendees will be able to:\n- Know where to find critical documentation for moving between Django versions\n- Identify the ideal upgrade path\n- Learn and Explore ways to deal with legacy code\n- How to effectively evaluate which version of dependencies need to be upgraded to.",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/upgrading-eol-django-a-journey-from-v1-to-v5/"
+        }
+    ],
+    "speakers": [
+        "Michael Riley"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/OI7HsIyX0eQ/maxresdefault.jpg",
+    "title": "Upgrading EOL Django: A Journey from V1 to V5",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/OI7HsIyX0eQ"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/webrtc-with-django-channels-htmx-and-coturn.json b/djangocon-us-2024/videos/webrtc-with-django-channels-htmx-and-coturn.json
new file mode 100644
index 000000000..1c710d207
--- /dev/null
+++ b/djangocon-us-2024/videos/webrtc-with-django-channels-htmx-and-coturn.json
@@ -0,0 +1,26 @@
+{
+    "description": "Audio/Video conferencing has become standard in many areas for augmenting communications among individuals. Modern browsers facilitate this by including support for Web Real Time Communications (WebRTC).\n\nWebRTC itself is a point-to-point protocol, which means that two browsers using this for a video call are talking directly to each other. But, before that can happen, the those browsers need to know that each other exists and are looking to establish this connection. Then they need to negotiate the parameters for the connection.\n\nThen there are many network-related issues that can affect the ability for those two browsers to connect.  Things like firewalls and Network Address Translation (NAT) can affect how each side \"sees\" the other side, further complicating the situation.\n\nAll these issues have known solutions. The WebRTC APIs have matured to the point where they can be considered reasonably stable and reliable. It has become practical to incorporate these solutions in a Django-based website.\n\nThis session will discuss one implementation of a Django-based website that facilitates a group video conferencing system, using Channels as the signalling mechanism, HTMX for page-content management, and coturn as the NAT transveral and and gateway server.",
+    "language": "eng",
+    "recorded": "2024-09-25",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/webrtc-with-django-channels-htmx-and-coturn/"
+        }
+    ],
+    "speakers": [
+        "Ken Whitesell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/XhGu16OYrjk/maxresdefault.jpg",
+    "title": "WebRTC with Django, Channels, HTMX, and coturn",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/XhGu16OYrjk"
+        }
+    ]
+}
diff --git a/djangocon-us-2024/videos/you-got-that-nice-tech-salary-now-what.json b/djangocon-us-2024/videos/you-got-that-nice-tech-salary-now-what.json
new file mode 100644
index 000000000..c8bdaf2f9
--- /dev/null
+++ b/djangocon-us-2024/videos/you-got-that-nice-tech-salary-now-what.json
@@ -0,0 +1,26 @@
+{
+    "description": "Talking about finances is awful.\n\nThere are several things I'd rather talk about with a group of strangers before finances. However, I believe that as a part of the tech community, there's a moral responsibility to make sound personal financial decisions because you earn a comfortable salary. I have made several mistakes along my career, and I'm probably still making some. The goal here is to make it a bit easier for us to have these conversations.\n\nI was the first in my family to graduate from college. One of my parents attended some college. They knew how to balance a budget, and they knew to max your employer's 401k matching program. Beyond that, there wasn't much of a plan.\n\nI didn't have any financial literacy when I entered the tech industry. In fact, I fell prey to a corporate insurance provider, bought an insurance-investment type product and contributed to it for years! I've left money in my savings account because I was scared of the market.\n\nAt the end of this talk you will have a basic understanding of:\n- The importance of planning, budgeting and saving\n- Where to put your savings\n- Maximizing employer contributions\n- How to evaluate an index fund",
+    "language": "eng",
+    "recorded": "2024-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2024.djangocon.us"
+        },
+        {
+            "label": "Talk Webpage",
+            "url": "https://2024.djangocon.us/talks/you-got-that-nice-tech-salary-now-what/"
+        }
+    ],
+    "speakers": [
+        "Tim Schilling"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/XuNxrNALgLg/maxresdefault.jpg",
+    "title": "You got that nice tech salary, now what?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://youtu.be/XuNxrNALgLg"
+        }
+    ]
+}