diff --git a/pycon-uk-2023/category.json b/pycon-uk-2023/category.json
new file mode 100644
index 000000000..7715dc0e7
--- /dev/null
+++ b/pycon-uk-2023/category.json
@@ -0,0 +1,3 @@
+{
+    "title": "PyCon UK 2023"
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json b/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json
new file mode 100644
index 000000000..75a76bb1b
--- /dev/null
+++ b/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json
@@ -0,0 +1,22 @@
+{
+    "description": "We\u2019ll revisit three stories from WWII where statisticians for the Allied forces got things perfectly right - and terribly wrong. We'll explore the flaws of averages, survivorship bias, and the German tanks problem. Drawing parallels to modern business situations, we'll discuss the takeaways for modern day data scientists.\n\nWorld War II, the largest armed conflict in human history, not only required unfathomable firepower but also unprecedented brain power. Data scientists - or statisticians as they were called back in the day - worked tirelessly to advance military technology and produce indispensable intelligence reports. Eighty years on, the lessons they learned remain relevant and are important for anyone doing data science or analysis at present.\n\nIn this talk, we\u2019ll visit three stories from WWII and discuss how the lessons learned then apply for modern day business settings. We\u2019ll explore:\n- How the flaw of averages made the scientifically optimised cockpit to be a perfect fit for no-one.\n- How survivorship bias impacted the armour placed on bomber planes.\n- How the need to assess the monthly rate of German tank production bred a simple solution.\n\nIn the second part of the talk we\u2019ll discuss how learnings from these stories can be used in a business environment, working through business use-cases with real (looking) data and some basic Python manipulations.\n\nWhile the talk was prepared with data scientists and analysts in mind, anyone with a curious mind may find it worthwhile. Basic familiarity of Python is helpful but not required. By the end of this talk audience members will be familiar with several common pitfalls in data science and equipped to handle business problems in a more mature and well-rounded way.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Alon Nir"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/yXGQBB_RFec/hqdefault.jpg",
+    "title": "3 Lessons Data Scientists Can Learn from World War II",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=yXGQBB_RFec"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json b/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json
new file mode 100644
index 000000000..379f363a7
--- /dev/null
+++ b/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json
@@ -0,0 +1,22 @@
+{
+    "description": "Python 3's `str` was a leap forward but not a panacea. Join me to dive into the strange world of unicode, how it can bite you, and what to do about it.\n\nIn Python 3 we finally got a Unicode-native `str` type throughout, and there was much rejoicing. But Unicode is a tricky beast, difficult to tame, and there are still plenty of ways it can bite you if you are not careful.\n\nWe will look at some of these ways, the eldritch abominations looming in shadowy corners of Python's text; we will discover how the siren-song of seemingly innocuous strings can dash you upon the rocks, the deep peculiarity of the humble flag, and finally come to inner peace and harmony as we understand true grapheme-nature.\n\nWe will then touch on the deeper mysteries of bidirectional text, and our hearts will turn to despair. It will be a fun time.",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Alistair Lynn"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/1yJi5DmZR-E/hqdefault.jpg",
+    "title": "Adventures in Unicode: the `str` less travelled",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=1yJi5DmZR-E"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/domain-driven-design-and-python.json b/pycon-uk-2023/videos/domain-driven-design-and-python.json
new file mode 100644
index 000000000..52af4a90d
--- /dev/null
+++ b/pycon-uk-2023/videos/domain-driven-design-and-python.json
@@ -0,0 +1,22 @@
+{
+    "description": "Have you heard of Domain Driven Design? Not well known in the Python world, it's an influential development approach that aims to 'tackle complexity in the heart of software'. If you're working on complex problems, come find out more: it may change the way you think!\n\nI've been writing code for 25 years. Over that time I've been through a few, rare, exhilarating paradigm shifts where my thinking as a developer suddenly changed. One was early on, when I suddenly understood object oriented programming. Test driven development was another. And then, six years ago, I read Eric Evan's 2003 book _Domain Driven Design_.\n\nThe book opened up for me a whole new way of thinking about the practice of software development. It is focused not on traditional technical concerns we're used to reading about, but on the conceptual world of modelling. It views an application's _domain model_ as one of its most important assets, and presents a wealth of wisdom about how to orient our thinking, code and working practices around that model.\n\nBut, for some reason, these ideas are not well known in the Python community. \n\nI now work on a highly complex project: Kraken, a Python monolith of tens of thousands of modules, serving energy and utility companies in a variety of countries. Domain Driven Design has, for me, been an invaluable influence.\n\nIn this talk, I'll outline the key ideas of Domain Driven Design, ideas that are beyond any one language, technology or architecture. I'll also ground it with some practical examples of how it can look in Python. Are you looking for your next paradigm shift? Perhaps this could be it!",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "David Seddon"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/4XKhH9whNX0/hqdefault.jpg",
+    "title": "Domain Driven Design and Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=4XKhH9whNX0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json b/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json
new file mode 100644
index 000000000..d8fcb320b
--- /dev/null
+++ b/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json
@@ -0,0 +1,22 @@
+{
+    "description": "Developers often use code coverage as a target, which makes it a bad measure of test quality. Mutation testing changes the game and fixes the problem.\n\nCome and learn to use it in your CI/CD process. I promise, you'll never look at penguins the same way again!\n\nCode coverage (the percentage of your code tested by your tests) is a great metric. However, coverage doesn\u2019t tell you how good your tests are at picking up changes to your codebase - if your tests aren\u2019t well-designed, changes can pass your unit tests but break production.\n\nMutation testing is a great (and massively underrated) way to quantify how much you can trust your tests. Mutation tests work by changing your code in subtle ways, then applying your unit tests to these new, \"mutant\" versions of your code. If your tests fail, great! If they pass\u2026 that\u2019s a change that might cause a bug in production.\n\nIn this talk, I\u2019ll show you how to get started with mutation testing and how to integrate it into your CI/CD pipeline. After the session, you\u2019ll be ready to use mutation testing with wild abandon. Soon, catching mutant code will be a routine part of your release engineering process, and you\u2019ll never look at penguins the same way again!",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Max Kahan"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/8Gl_Brl4GVI/hqdefault.jpg",
+    "title": "Fear the mutants. Love the mutants.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=8Gl_Brl4GVI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/friday-lightning-talks.json b/pycon-uk-2023/videos/friday-lightning-talks.json
new file mode 100644
index 000000000..11d6ffb89
--- /dev/null
+++ b/pycon-uk-2023/videos/friday-lightning-talks.json
@@ -0,0 +1,20 @@
+{
+    "description": "Lightning Talks\n\nLightning Talks",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/O2ApDUsPDSc/hqdefault.jpg",
+    "speakers": [],
+    "title": "Friday Lightning Talks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=O2ApDUsPDSc"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/friday-welcome-and-introductions.json b/pycon-uk-2023/videos/friday-welcome-and-introductions.json
new file mode 100644
index 000000000..4a4747f60
--- /dev/null
+++ b/pycon-uk-2023/videos/friday-welcome-and-introductions.json
@@ -0,0 +1,22 @@
+{
+    "description": "Welcome and Introductions\n\nWelcome and Introductions",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Ann Barr"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/D3oaUdCdEto/hqdefault.jpg",
+    "title": "Friday Welcome and Introductions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=D3oaUdCdEto"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json b/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json
new file mode 100644
index 000000000..9e32ea87f
--- /dev/null
+++ b/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json
@@ -0,0 +1,22 @@
+{
+    "description": "At an event, a photographer can take many photos. Which ones do you appear in? Find out how to search for faces using Python, OpenCV, OpenAI and, yes, PostgreSQL\u00ae.\n\nPython ties it all together, and PostgreSQL's pgvector extension allows making SQL queries to find photos with my face.\n\nNowadays, if you attend an event you're bound to end up with a catalogue of photographs to look at. Formal events are likely to have a professional photographer, and modern smartphones mean that it's easy to make a photographic record of just about any gathering. It can be fun to look through the pictures, to find yourself or your friends and family, but it can also be tedious.\n\nAt our company get-together earlier in the year, the photographers did indeed take a lot of pictures. Afterwards the best of them were put up on our internal network - and like many people, I combed through them looking for those in which I appeared (yes, for vanity, but also with some amusement).\n\nIn this talk, I'll explain how to automate finding the photographs I'm in (or at least, mostly so). I'll walk through Python code that extracts faces using OpenCV, calculates vector embeddings using imgbeddings and OpenAI, and stores them in PostgreSQL\u00ae using pgvector. Given all of that, I can then make an SQL query to find which pictures I'm in.\n\nPython is a good fit for data pipelines like this, as it has good bindings to machine learning packages, and excellent support for talking to PostgreSQL.\n\nYou may be wondering why that sequence ends with PostgreSQL (and SQL) rather than something more machine learning specific. I'll talk about that as well, and in particular about how PostgreSQL allows us to cope when the amount of data gets too large to be handled locally, and how useful it is to be able to relate the similarity calculations to other columns in the database - in our case, perhaps including the image metadata.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Tibs"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/_FqKxKVJGWQ/hqdefault.jpg",
+    "title": "How I used PostgreSQL\u00ae to find pictures of me at a party",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=_FqKxKVJGWQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/how-to-keep-your-database-happy.json b/pycon-uk-2023/videos/how-to-keep-your-database-happy.json
new file mode 100644
index 000000000..098b46c31
--- /dev/null
+++ b/pycon-uk-2023/videos/how-to-keep-your-database-happy.json
@@ -0,0 +1,22 @@
+{
+    "description": "5 simple things you can put in place to make sure you have a database that runs smoothly and performs well.\n\nYou don't want to spend too much time looking after your database; you've got better things to do with your time. You do, however, want your database to run smoothly and perform well. Fortunately, there are a few simple things that you can do to make sure your database ticks along nicely in the background.\nI've put together my top 5 tips, based on things that have been useful to me as a DBA and as a database consultant. These are things you can put in place, without too much effort, to make sure your database works well. The focus will be on PostgreSQL, but most of the tips are also relevant to other databases.\nYou'll come away with some simple ways to keep your database happy, leaving you free to concentrate on developing your application.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Karen Jex"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/G7glaoEa9WQ/hqdefault.jpg",
+    "title": "How to keep your database happy",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=G7glaoEa9WQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json b/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json
new file mode 100644
index 000000000..0c0c048e6
--- /dev/null
+++ b/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json
@@ -0,0 +1,22 @@
+{
+    "description": "I've always wanted to build a retro computer based on an old-stock Z80 cpu. The biggest roadblock for me in this endeavor has always been finding a way to manage I/O and a modern display.\n\nThe Pi Pico solved all this for me.\n\nIntroducing the Raspberry Pi Pico Z80-Based Retro Computer: A Revolutionary Fusion of Modern Technology, geekiness and Nostalgic Computing!\n\nPrepare to be blown away by this project, where the almighty Pi Pico take on the role of the ultimate multitasker \u2014a graphics card, clock, ROM, and keyboard controller\u2014 for a Z80-based retro computer. Did I ignite your inner geek yet?!\n\nImagine a Z80 cpu, like the one that powers the BBC micro but with vibrant 8-bit color graphics coming to life on a VGA screen! All thanks the Raspberry Pi Pico and its PIO capabilities. The Pico in this project has been turned into a somewhat efficient graphics card, enabling smooth rendering of retro-style visuals on modern screens. Experience the nostalgia of blocky pixels.... **in 4K** (with an HDMI adapter)\n\nThe Raspberry Pi Pico's versatility extends beyond its graphics capabilities. Acting as the clock, it allows for varying the speed of the cpu and do \"fancy\" things like step by step debugging of Z80 assembly.\n\nOne of the most delightful aspects of the project is using the Pico as a ROM. Gone are the days of meticulously erasing and rewriting chips, as this setup allows you to effortlessly load files instead.\n\nAnd with the Pico acting as a USB host, you are free to plug in modern hardware directly into this fancy retro computer! USB keyboard and mouse, SD-card reader, you name it!",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Emma Delescolle"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Ea3yX3fQCEo/hqdefault.jpg",
+    "title": "I plugged a Z80 into a Pi Pico, here's how it happened",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Ea3yX3fQCEo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json b/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json
new file mode 100644
index 000000000..828e692b6
--- /dev/null
+++ b/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json
@@ -0,0 +1,22 @@
+{
+    "description": "Technology is often hidden backstage at the theatre \u2013 a toolkit to enhance performance, not something artists make plays about. But generations of audience members have \u2018grown up online\u2019. To tell contemporary stories, don\u2019t we need to put tech centre stage? What is digital theatre \u2013 and is it still theatre?\n\nAda Lovelace was the daughter of a social reformer and a mad/bad/dangerous-to-know poet. She grew up to be a mathematician, an analyst, a musician, a gambler, and the first computer programmer. But the engine she coded for was never built \u2013 and she didn\u2019t live to see whether her programme worked or not. \n\nI\u2019m the daughter of an English tutor and a \u2018works in software\u2019. I\u2019ve grown up to be a playwright and a digital theatre-maker. I was also commissioned to research, write, and develop a play about Ada Lovelace, music, AI, and poetical science. But it was never staged \u2013 and I have no idea if it works in performance or not.  \n\nLuckily I\u2019m not dead yet, and I have actually managed to stage other work exploring how tech-y themes, online communities, and virtual spaces work in live theatre. My theatre-making overlaps with gaming, radio, film, and livestreaming. I love thinking about how staging the tech can create restrictions/opportunities, feeding into the form and the theme of a story. And I\u2019m especially interested in how theatre \u2013 an artform that had to change dramatically to survive lockdown \u2013 might move forwards now that audiences are more reluctant to leave their homes than ever.\n\nIf you\u2019re not the kind of person who goes to the theatre then you might be the kind of person who\u2019s up for digital theatre \u2013 poetical science, maybe, rather than just poetry. If, of course, we can agree on what digital theatre even is\u2026",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Emily Holyoake"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/PeUb0D8VDWU/hqdefault.jpg",
+    "title": "If you can\u2019t give me poetry, can\u2019t you give me poetical science?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=PeUb0D8VDWU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json b/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json
new file mode 100644
index 000000000..c15b40902
--- /dev/null
+++ b/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json
@@ -0,0 +1,22 @@
+{
+    "description": "Bring your Django, Flask, etc. pages to life using htmx. \n\nNo Javascript, nor refreshing the page.  Create, update and delete data; change the date range for a chart; drill down using a sequence of dropdowns; create an interactive search box, an infinite scrolling page or a sortable drag & drop table.\n\nPython has many excellent back-end frameworks, but we can't use it yet for mainstream front-end development. How do we bring our web pages to life without having to write Javascript, and without learning a front end framework like React or AngularJS?\n\nThe htmx library uses simple tag attributes to add behaviour to HTML tags. It gives you access to AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML for modern user interfaces. \n\nLearn how, without refreshing the page, you can: create, update and delete data; change the date range for a chart; drill down using a sequence of dropdowns; and create an interactive search box.\n\nDiscover how to use htmx with any Python web framework. The examples will mostly use Django, plus a single example of how to use the same ideas in Flask.\n\nYou will also see how to create an infinite scrolling page, a sortable drag and drop table, and more.",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Coen de Groot"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/iPraT0gscDU/hqdefault.jpg",
+    "title": "Interactive web pages with Django or Flask, without writing Javascript",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=iPraT0gscDU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json b/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json
new file mode 100644
index 000000000..d853b9827
--- /dev/null
+++ b/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json
@@ -0,0 +1,22 @@
+{
+    "description": "Earth's sustainability is on the brink. However, with today's information wars this situation isn't universally accepted. This talk democratises citizen environmental investigation by applying Python to selected Green issues. By separating facts from fiction humanity can be better informed to safeguard our existence.\n\nExistential threats to humanity as a result of decades of damage inflicted to the planet are already in motion. From the first climate refugees in 2014, to escalating public health crises of air pollution and food insecurity around the world, Earth becomes less inhabitable every day.\n\nAnd yet concern isn't as widespread as is warranted. Many parties profit from unsustainable practices, and therefore have motive to obfuscate the long-term harmful consequences. In today's post-truth world, exacerbated by generative AI and other mis-used tech, public opinion is the battleground between multiple opposing influences, only to the detriment of society.\n\nThis talk aims to better equip citizens to bypass/counter the deliberate informational noise and investigate environmental issues themselves, being more empowered to come to their own conclusions about the actual state of our world. \n\nA selection of scientific workflows, using open-source Python and publicly available resources, will be presented, each delving into a topical environmental issue to produce actionable insight. Designed to be accessible and reproducible by tech literate citizens without domain expertise, the audience will takeaway transferable Python skills for undertaking similar scientific computing exploration. \n\nLet's democratise Python's potential for citizen access to discovery of environmental facts, so that humanity can be better informed to better influence the safeguarding of our planet, and ultimately our existence.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Mx Chiin-Rui Tan"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Sbkdf6vl6n0/hqdefault.jpg",
+    "title": "Investigating Environmental issues with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Sbkdf6vl6n0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json b/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json
new file mode 100644
index 000000000..f8a88b620
--- /dev/null
+++ b/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json
@@ -0,0 +1,22 @@
+{
+    "description": "How we built a prototype to allow journalists to add highlight markers to interesting moments on BBC News in iPlayer, and how we went from idea to prototype to production.\n\nIn BBC News Labs, we work closely with journalists and we try to come up with innovative approaches to meeting their needs - either to improve or automate internal processes or to enhance the audience experience.\n\nAn idea was born from discussions with a BBC News editor to add markers to indicate to users where the big important moments are on the news channel. We built a minimum viable product, and extended the reach of the prototype over the next few months. We launched our first audience facing trial on news live pages, and then it was used on Eurovision, Springwatch, Glastonbury and Wimbledon.\n\nThe project was built using AWS lambda functions (Python), FastAPI and postgres, a React / TypeScript frontend and an iPlayer plugin (also TypeScript).\n\nThis talk will cover our rapid prototyping process, the tech stack used, as well as how we managed to deliver a production audience-facing project - and where we go from here.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Ben Nuttall"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/UEGMR0oCOqI/hqdefault.jpg",
+    "title": "Live highlights in BBC iPlayer",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=UEGMR0oCOqI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json b/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json
new file mode 100644
index 000000000..41d49a2a1
--- /dev/null
+++ b/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json
@@ -0,0 +1,22 @@
+{
+    "description": "What is the best Pok\u00e9mon team? Who should I pick? What attacks should they learn? Here, I use multi-objective linear programming, and a bit of simulation, to figure it out.\n\nHere I give an example of using Python to solve a combinatorial problem from the mathematical field of Operational Research: How to find the best Pok\u00e9mon team. Using a variety of Python libraries a mulit-objective linear programming problem is used to find the best combination of Pok\u00e9mon, and their attacks. PuLP is used to formulate and solve the multi-objective linear programming problems, and a Pareto front is found by varying the importance of each objective. Then, a third objective, a Pok\u00e9mon team's performance in a Monte Carlo simulation of Pok\u00e9mon battles, is used to differentiate between Pareto optimal solutions and find the definitive best team of Pok\u00e9mon. I relate how this fun problem is related to more serious scheduling and timetabling problems.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Geraint Palmer"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/HVcS_X5p1h8/hqdefault.jpg",
+    "title": "Multi-Objective Linear Programming to find the Best Pok\u00e9mon Team",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=HVcS_X5p1h8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json b/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json
new file mode 100644
index 000000000..8ae9c76b6
--- /dev/null
+++ b/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json
@@ -0,0 +1,22 @@
+{
+    "description": "I want a clear picture of how my application is performing in production, but proper observability involves a lot of faff. So let's look at how to add metrics to an application with only a few lines of code and an open-source library called autometrics-py.\n\nMarie Curie said, \u201cNothing in life is to be feared, it is only to be understood.\u201d\n\nFor developers, writing code is a big part of our lives. And if we want to understand how the code we write is actually performing out in the wild, then we need to use techniques and tooling from the world of observability.\n\nThis poses a problem for many of us, including myself: Observability tooling is itself fear-inducing! \n\nYes, I would love to understand how my code is doing after I release it onto the scary internets. (Please. Tell me. I have no idea.)\n\nHowever, the path to an observable codebase is full of easy-to-take wrong turns and very confusing signage. Speaking personally, I needed to get to know the the quirks of a time-series database, determine what to measure (and how to measure it), label my data correctly, and then learn a new query language to generate charts that would help me understand whether or not my app is doing as well as I (really, really) hope it is.\n\nI am a developer. I\u2019ve been creating web applications for a decade. And yet, before working for an observability company, I still relied mostly on carefully placed log statements to debug my production code.\n\nThis is why I started contributing to autometrics-py, which is a small, open source micro-framework that exposes a cute little python decorator to make implementing observability best practices much, much simpler for developers. (To be clear: I am by no measure an expert in observability, but that\u2019s exactly why I\u2019m excited to share what I\u2019ve learned while helping to make it easier for others.)\n\nIn this talk, we\u2019ll cover what makes observability tricky, especially for devs, and how we can do away with this trickiness by making some smarty-pants assumptions about the type of data we are most interested in. We\u2019ll focus on the unique power of getting metrics at the function level (because who doesn\u2019t love functions?!), and emerge with the confidence of Marie Curie when it comes to understanding the health of our codebase in production.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Brett Beutell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ayH-vn7BLyk/hqdefault.jpg",
+    "title": "Open-source, developer-friendly observability in only a few lines code",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ayH-vn7BLyk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json b/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json
new file mode 100644
index 000000000..df690275d
--- /dev/null
+++ b/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json
@@ -0,0 +1,22 @@
+{
+    "description": "In this talk, we'll explore techniques to optimize GraphQL performance for snappy, scalable, and resource-efficient APIs. Attendees will learn about batching queries with DataLoader, managing query complexity and depth, leveraging persisted queries for reduced network overhead, and implementing \ncaching strategies on both server and client-side.\n\nAPI performance is crucial for delivering a smooth and responsive user\nexperience. GraphQL has gained popularity as a flexible and efficient query\nlanguage, but without proper optimization, it may underperform or even become a\nbottleneck in your application.\n\nIn this talk, we'll dive into the essential techniques and best practices to\noptimize GraphQL performance, ensuring that your APIs are snappy, scalable, and\nresource-efficient. Attendees will learn:\n\n- The importance of batching queries and how to implement it using DataLoader or\n  similar libraries.\n- The concept of query complexity and depth, and how to set up limits to prevent\n  resource abuse.\n- Leveraging persisted queries to reduce network overhead and improve caching\n  capabilities.\n- Implementing caching strategies, both on the server and client-side, to\n  minimize redundant requests and reduce load times.\n- Exploring monitoring and observability tools that can help you identify\n  performance bottlenecks and continuously optimize your GraphQL implementation\n  for maximum efficiency.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Patrick Arminio"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-6bDHd0uB3c/hqdefault.jpg",
+    "title": "Optimizing GraphQL Performance: Tips and Techniques",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=-6bDHd0uB3c"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/saturday-lightning-talks.json b/pycon-uk-2023/videos/saturday-lightning-talks.json
new file mode 100644
index 000000000..a7005ed42
--- /dev/null
+++ b/pycon-uk-2023/videos/saturday-lightning-talks.json
@@ -0,0 +1,20 @@
+{
+    "description": "Lightning Talks\n\nLightning Talks",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/mpVDJBySGbg/hqdefault.jpg",
+    "speakers": [],
+    "title": "Saturday Lightning Talks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=mpVDJBySGbg"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/saturday-welcome-and-introductions.json b/pycon-uk-2023/videos/saturday-welcome-and-introductions.json
new file mode 100644
index 000000000..21e816ad2
--- /dev/null
+++ b/pycon-uk-2023/videos/saturday-welcome-and-introductions.json
@@ -0,0 +1,22 @@
+{
+    "description": "Welcome and Introductions\n\nWelcome and Introductions",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Ann Barr"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/NV2u3QyNQBQ/hqdefault.jpg",
+    "title": "Saturday Welcome and Introductions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NV2u3QyNQBQ"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json b/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json
new file mode 100644
index 000000000..f737ecc40
--- /dev/null
+++ b/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json
@@ -0,0 +1,22 @@
+{
+    "description": "What actually happens when you import a package? Let's find out, then explore recent packaging developments, including the new tool PDM, comparing it to pip and poetry. We'll also cover some (opinionated) best practices for handling metadata, and building secure, modern applications using third party libraries in python.\n\nPython has a rich ecosystem of open source packages available to assist with almost any conceivable requirement. Installing, using, and updating these packages should be quick, easy, and secure, however, dependency management and python packaging has historically been a source of frustration for developers, particularly with the added complications of virtual environments, and subtle differences between python versions. Furthermore, software supply chain security has attracted particular importance of late as increasing numbers of major vulnerabilities have been discovered requiring fast, sometimes immediate, mitigation.\n\nIn recent years, efforts have been made to improve packaging and dependency management in python, and we have seen the release of a number of developer tools, including poetry, pipenv, and pipx. These work alongside pip and earlier tools such as disutils, setuptools, and easy_install, and offer higher level interfaces for developers to work with. In 2020, a new tool was released called PDM (Python Dependency Manager), and is gaining traction amongst developers in recent months. \n\nThis talk will start by giving an overview of how python imports work, before moving on to cover a brief history of package management in python, and an overview of the current state of play, and the vulnerabilities that we are exposed to by supply chain attacks. We'll then give a brief introduction to PDM, before discussing what practical steps we can take to both improve our developer experiences, and ensure the code we write is modern, secure, and maintainable.\n\nWe'll ask questions including some of the below.\n\n* What actually happens 'under the hood' when we use the import statement?\n* How many different ways can we import a package in python?\n* What does a dependency manager do, and how does it work?\n* What does a supply chain attack look like, and how do we try and stop them happening?\n\nFinally, the speaker will offer an opinionated guide to some of the best python tooling and package management setups available to python developers in 2023.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Dom Weldon"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/TI8gHpI-OHQ/hqdefault.jpg",
+    "title": "Secure, Modern, and Simple Dependency Management with PDM and Friends",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=TI8gHpI-OHQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json b/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json
new file mode 100644
index 000000000..ac976249a
--- /dev/null
+++ b/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json
@@ -0,0 +1,22 @@
+{
+    "description": "In this talk, we will delve into how leveraging Google's cutting-edge tools and frameworks, combined with Python, can revolutionize the way we bridge the communication gap between sign language users and the wider world.\n\nCommunication barriers between the deaf and hard-of-hearing community and the wider world have created significant challenges in effective interaction.However the good news is cutting-edge AI technologies can revolutionize the way we transcribe American Sign Language (ASL) and enable inclusive communication.\n\nUsing the power of Python libraries and Google's AI tools, including the Google Cloud Vision API for hand and finger tracking, TensorFlow for deep learning models, and AutoML for data scarcity challenges, I will demonstrate Sign_To_Text, a revolutionary system that transforms how sign language users connect with the world.\n\nWitness live demonstrations as I seamlessly integrate Google AI technologies to translate fingerspelled letters in real time into textual representations, empowering individuals and fostering inclusive communication.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Atieno Ouma"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/TIKORzyk8Xg/hqdefault.jpg",
+    "title": "SIGN-TO-TEXT:Unleashing the Power of Google AI for real time ASL transcription",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=TIKORzyk8Xg"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/sunday-lightning-talks.json b/pycon-uk-2023/videos/sunday-lightning-talks.json
new file mode 100644
index 000000000..8f4a6d9bd
--- /dev/null
+++ b/pycon-uk-2023/videos/sunday-lightning-talks.json
@@ -0,0 +1,20 @@
+{
+    "description": "Lightning Talks\n\nLightning Talks",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/chxsC2WYNTE/hqdefault.jpg",
+    "title": "Sunday Lightning Talks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=chxsC2WYNTE"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/technical-neglect.json b/pycon-uk-2023/videos/technical-neglect.json
new file mode 100644
index 000000000..bce63bea0
--- /dev/null
+++ b/pycon-uk-2023/videos/technical-neglect.json
@@ -0,0 +1,22 @@
+{
+    "description": "Unmanaged technical debt weighs down many codebases, exerting drag on their schedules, but it is more often an effect than a cause. We will look at what technical debt is (and is not) with a view to properly attributing the root and recurring cause as technical neglect than technical debt.\n\nMany developers evoke the mischievous spirit and day-to-day burden of technical debt to explain the misfortunes and troubles of their codebase and delivery. While unmanaged technical debt weighs down many codebases and exerts drag on their schedules, it is more often an effect than a cause. In this talk, we will look at what is and is not meant by technical debt \u2014 and other metaphors \u2014 with a view to properly attributing the root and recurring cause as technical neglect than technical debt. Without seeing technical neglect for what it is, we will continue to misattribute our problems to an effect rather than a cause.",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Kevlin Henney"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/YJPu_TNedTs/hqdefault.jpg",
+    "title": "Technical Neglect",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YJPu_TNedTs"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/the-accidental-conference-director.json b/pycon-uk-2023/videos/the-accidental-conference-director.json
new file mode 100644
index 000000000..2fb0a4248
--- /dev/null
+++ b/pycon-uk-2023/videos/the-accidental-conference-director.json
@@ -0,0 +1,22 @@
+{
+    "description": "TBC\n\nTBC",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Ann Barr"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/QCRyvIzM6NA/hqdefault.jpg",
+    "title": "The Accidental Conference Director",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=QCRyvIzM6NA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json b/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json
new file mode 100644
index 000000000..d7673d7b3
--- /dev/null
+++ b/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json
@@ -0,0 +1,22 @@
+{
+    "description": "Have you ever wondered how `self` works? Whenever you call a method, `self` seems to magically appear as an argument. But behind this dark magic lies a well-defined protocol, the descriptor protocol, that you can implement yourself. Join me and learn how Python inserts `self` into methods!\n\nA phrase that I hear a lot is that \u201cPython is easy to learn but hard to master\u201d. In a way that\u2019s true: Python\u2019s many abstractions allow you to focus on the business logic of your code instead of the lower-level implementation details.\n\nAt the same time, most of Python\u2019s abstractions aren\u2019t *magical*: Its versatile data model allows you to hook into almost every aspect of the language to implement objects that behave just as Python\u2019s built-in objects do. This enables you to create new types of objects that have high-level interfaces of their own.\n\nIn this talk, I want to entice you to explore the wonderful landscape of Python\u2019s data model by diving into an especially magical feature: The automatic insertion of `self` into methods.\n\nWhen you first came across `self` in a method signature, chances are that you learned that inserting the instance into methods is just something Python does for you; that you shouldn\u2019t worry too much about it. I will go one step further and show you that there\u2019s a well-defined protocol behind this magic, the descriptor protocol.\n\nBy the end, not only should you be able to implement descriptors of your own, but you should also be able to recognize that some well-known features of Python, such as properties and classmethods, are implemented using the same descriptor protocol.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Sebastiaan Zeeff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/hNM91G41m3c/hqdefault.jpg",
+    "title": "The Magic of Self: How Python inserts self into methods",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=hNM91G41m3c"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/the-programmer-s-imagination.json b/pycon-uk-2023/videos/the-programmer-s-imagination.json
new file mode 100644
index 000000000..01778d4dc
--- /dev/null
+++ b/pycon-uk-2023/videos/the-programmer-s-imagination.json
@@ -0,0 +1,22 @@
+{
+    "description": "As creators of software, we're repeatedly told that we're not merely imagining the future of the world, but bringing it into being. Let's suppose that's true. What, exactly, are we imagining, and why does it matter?\n\nOf all our faculties, imagination is usually considered the freest, the seat of creation. I'm interested in what we are doing with this freedom, and I am suspicious of it.\n\nAt the same time, I believe that our imagination tells us truths we might not always want to hear, forcefully. \n\nIn this talk I want to pay attention to the programmer's imagination, and show how the imagination draws lines between things as disparate as Django's success page for new projects and [Dracoraptor hanigani](https://en.wikipedia.org/wiki/Dracoraptor), the recently discovered Welsh dinosaur (on view at the National Museum, next door to Cardiff City Hall). \n\nAs programmers, our imagination conjures up new worlds on blank pages, but I think that imagination can always be traced back to assumptions, prejudices and desires that are active right now - the programmer's imagination isn't telling us about the future, but about *now* - and what's wrong with it.\n\nI want to show what the imagination has meant for what we do with the software we create, and what it means for the future. I will use it to identify some of the things we have lost in the last decades, and how we can find them again.\n\nAmongst other things I'll discuss dinosaurs and birds, palaeoart and 1980s computer programming books, David H Ahl and Joseph Wiezenbaum, to help make sense of what we're doing, what we think we're doing, the relationship between them - and what, perhaps, we *should* be doing.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Daniele Procida"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/25onRvaR3MA/hqdefault.jpg",
+    "title": "The programmer's imagination",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=25onRvaR3MA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json b/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json
new file mode 100644
index 000000000..7204265db
--- /dev/null
+++ b/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json
@@ -0,0 +1,22 @@
+{
+    "description": "This talk will present how one can use acoustic-based clinical gait analysis to predict onset & progression of cognitive decline as well as assess increase in risk of falls in highly frail and vulnerable demographics of the population, especially older adults who live alone and with multiple co-morbidities.\n\nDo you know how the sound of your footsteps can be used to predict the likelihood of a fatal fall? Do you know that they can also be used to predict whether you will develop dementia in the next 6 months or so?\n\nThis talk will be a gentle introduction to the world of clinical gait analysis and how your gait (a.k.a the way you walk) is a digital biomarker for predicting physical and cognitive health. We will take an strong multidisciplinary approach where we will combine know-how of clinical science, remote monitoring, assistive technology and state-of-art acoustic AI engineering to showcase how this is possible.\n\nThe topics that we will cover are as follows:\n\nDigital Biomarker Engineering : We will discuss the framework of how you can feature engineer health indictors (\"biomarkers\") from data collected by sensors in an IOT ecosystem like PIR, magnetic sensors and even microphones/audio recorders.\nGait Analysis : We will do a crash course on Human Gait to set the foundation required to use gait data to predict for neurodegenerative conditions and cognitive decline.\nAcoustic Gait Analysis : We will spend majority of our time here to understand how acoustics engineering and machine learning can help in analysing human gait from just audio recordings to predict for cognitive decline discussed in #2 earlier.\nTo demonstrate a real life application, I will share how this concept was used to track the progression of dementia of an older adult over the past 2 years.\n\nI will showcase the tech stack to make this possible.\nI will showcase the challenges we faced along the way in undertaking niche research, architecture development, AI development and real-life feedback from the older adult, family members and care-givers.",
+    "language": "eng",
+    "recorded": "2023-09-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Debayan Das"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/4M9VNKVEX5o/hqdefault.jpg",
+    "title": "The Sound of Your Footsteps can Predict for Dementia",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=4M9VNKVEX5o"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/the-standard-library-tour.json b/pycon-uk-2023/videos/the-standard-library-tour.json
new file mode 100644
index 000000000..a25f48e1b
--- /dev/null
+++ b/pycon-uk-2023/videos/the-standard-library-tour.json
@@ -0,0 +1,22 @@
+{
+    "description": "Tired of complex code? Python's standard library has tools to simplify your tasks! Join us for a tour of the standard library where we'll dive into less-known modules that do well-known things and well-known modules that do less-known things.\n\nThe Standard Library Tour is designed to provide attendees with an understanding of Python's standard library less known features. Have you ever found yourself writing complex code only to discover that Python has tools available within its library that could have made your job easier? Then this talk is for you!\n\nThe outline of the talk:\n\n* Basic information about the library\n* Well-known modules which do less-known things\n\n  - functools less-known features: @singledispatch, partial(), @cache\n  - itertools less-known features: product(), filterfalse(), zip_longest()\n  - collections less-known features: ChainMap, defaultdict\n\n* Less-known modules which do well-known things\n   * doctest for testing: testmod()\n   * Difflib & Filecmp for comparison: Difflib.SequenceMatcher, Filecmp.cmpfiles()\n   * contextlib for tasks involving the with statement: @contextmanager, @asynccontextmanager\n\n\nBy attending this session, you'll gain a deeper understanding of Python's standard library and you'll discover the \"unknown unknowns\" - tools that you may not even know exist within Python's standard library. By becoming familiar with the library and all of its capabilities, you'll be better equipped to solve problems and build applications more efficiently, without reinventing the wheel. You'll also receive recommendations on where to find additional resources and information so you can continue learning and exploring Python's tools after the conference has ended.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Mia Baji\u0107"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/9J3Wfizht9E/hqdefault.jpg",
+    "title": "The Standard Library Tour",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=9J3Wfizht9E"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/vulnerability-management-with-cvss.json b/pycon-uk-2023/videos/vulnerability-management-with-cvss.json
new file mode 100644
index 000000000..a8b73b9b9
--- /dev/null
+++ b/pycon-uk-2023/videos/vulnerability-management-with-cvss.json
@@ -0,0 +1,22 @@
+{
+    "description": "Do you find it difficult to keep up with the increasing number of reported vulnerabilities? Are you unclear about the severity of a vulnerability in your system? Look no further than the Common Vulnerability Scoring System (CVSS).\n\nDo you find it difficult to keep up with the increasing number of reported vulnerabilities? Are you unclear about the severity of a vulnerability in your system? Look no further than the Common Vulnerability Scoring System (CVSS). \nThis standardized framework provides an objective method for scoring security vulnerabilities on a scale from 0 to 10, enabling you to prioritize resources and improve your system's security and resilience. Our talk will demonstrate how to utilize CVSS in Python projects, enabling you to efficiently prioritize efforts and set up automated vulnerability reports. Don't let vulnerabilities go unnoticed - utilize CVSS to enhance your software security today.",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Tomas Horacek"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/J9ve3bLaOZA/hqdefault.jpg",
+    "title": "Vulnerability Management with CVSS",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=J9ve3bLaOZA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/welcome-and-ukpa-agm.json b/pycon-uk-2023/videos/welcome-and-ukpa-agm.json
new file mode 100644
index 000000000..aae68f1ad
--- /dev/null
+++ b/pycon-uk-2023/videos/welcome-and-ukpa-agm.json
@@ -0,0 +1,22 @@
+{
+    "description": "Welcome and Introduction\n\nWelcome and Introduction",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Owen Campbell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/FuaJ1-b7LOc/hqdefault.jpg",
+    "title": "Welcome and UKPA AGM",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=FuaJ1-b7LOc"
+        }
+    ]
+}
diff --git a/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json b/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json
new file mode 100644
index 000000000..154463b46
--- /dev/null
+++ b/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json
@@ -0,0 +1,22 @@
+{
+    "description": "Datasets with potential to predict contaminated water are more than just numbers. They can mean the difference between drawing safe drinking water from a well and drawing unsafe levels of arsenic. This talk compares ways of generating a predictive model and addresses the ethical importance of application over technological ideology.\n\nBetween 1970 and the year 2000, the United Nations Children's Fund (UNICEF) worked with the Bangladesh government to provide safe drinking water to 80% of the population by the year 2000. The strategy was to achieve this goal by installing tubewells within the country. Unfortunately, many of these wells produced water contaminated with harmful arsenic content. \n\nWhen applying machine learning to this problem, the complexities of providing clean drinking water to an entire country highlight the limitations of foundational technological principles. I experienced this when contributing to the project iArsenic, which used data from these wells to predict a well's arsenic content.\n\nUsing iArsenic, individuals can submit data about their own well in Bangladesh and have a prediction generated to classify the safety of this well. Armed with fundamental principles of data science, I came into this project keen to enlighten the geoscience team about the data science sins they had committed. \n\nWhere was the evaluation? \nWhere was the train and test split? \nWhy does it matter if the model is opaque or transparent? \n\nUltimately, the question I was not asking gave the most valuable insight. Do these data science fundamentals matter? Surely, if we have a model that is 51% accurate all the time, it would be beneficial to use this model to tell people whether they should drink from a well or not, because 1% of people would benefit. In reality, these models are over 80% accurate.\n\nSitting in front of a MacBook Pro in a university library doing this data science project, it can look obvious that this model can be used to tell these people what is good for them and to give them the opportunity to make over 80% of the problem disappear in a take it or leave it fashion. So why is this seemingly simple and effective approach never deployed? When considering whether you would trust your health to a model with a 51% accuracy, does it still seem so simple or is the problem being underestimated by a colonial mindset?\n\nThis talk explores the computing culture shocks experienced when different fields collaborate, discussing how the convictions that help people navigate within a field can raise barriers between fields. Perhaps learning to embrace our convictions with flexibility will break barriers instead of building them.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Kane Swartz"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/xNY0FBICi4w/hqdefault.jpg",
+    "title": "Well well. ML is not the answer to everything.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=xNY0FBICi4w"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json b/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json
new file mode 100644
index 000000000..b8df12d8f
--- /dev/null
+++ b/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json
@@ -0,0 +1,22 @@
+{
+    "description": "Monday at PyCon UK is dedicated to [our code sprints](https://2023.pyconuk.org/sprints/). We'd love to have you joining in!\n\nCode sprints are a fantastic way to get started as an open-source software contributor, in a friendly, supportive environment where experienced contributors are on hand to help others get started.",
+    "language": "eng",
+    "recorded": "2023-09-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Daniele Procida"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/MLMpjDs2jzg/hqdefault.jpg",
+    "title": "What on earth is a code sprint?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=MLMpjDs2jzg"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json b/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json
new file mode 100644
index 000000000..9f0d4015d
--- /dev/null
+++ b/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json
@@ -0,0 +1,22 @@
+{
+    "description": "This year I built a library that already exists. The existing solutions didn\u2019t quite meet my needs, I wanted something that ticked all of my boxes. When thinking about building something new people referred me to xkcd #927. But I did it anyway.\n\nFor the last 6 years I\u2019ve maintained dask-kubernetes, a Python library for deploying Dask clusters on Kubernetes. In that time I\u2019ve tried nearly every Python Kubernetes client library on PyPI. In fact dask-kubernetes today uses over five different libraries and tools to interact with the Kubernetes API. Each one has different strengths and weaknesses, features and bugs. To satisfy all of the needs of Dask Kubernetes there is no one library that can do it alone.\n\nShould I continue to build wrappers and shims in dask-kubernetes to homogenize the various dependencies? Should I contribute to an existing one to fill in the blanks? Or can I build one library to rule them all?\n\nEarlier this year I decided to build exactly the library I needed. Not a perfect universal library to supersede everything, not a wrapper for everything that exists. Just the library I need to solve my problems, to reduce complexity in my projects and to help me learn the things I need to know to maintain these projects into the future. \n\nIn this talk I will dig into my perspective on when to wrap a dependency, when to contribute to a dependency and when to build a new dependency from scratch.",
+    "language": "eng",
+    "recorded": "2023-09-24",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2023.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Jacob Tomlinson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/f6VtdBLAKn4/hqdefault.jpg",
+    "title": "When to rebuild things that already exist",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=f6VtdBLAKn4"
+        }
+    ]
+}
\ No newline at end of file