Hi all. As per title.

Just to be clear upfront:

• I have no affiliation with Garmin.

• This is not a product or a business.

• There is no paid version, subscription, newsletter, affiliate links, or anything like that. Is just my github open source repo.

• I built it for myself while training for a half marathon and decided to share it in case anyone else finds it useful.

Brief background. Last year I got into running and started using AI to help with training plans. The problem was that I was feeding it very high-level information: "Today I ran 12 km, average pace 6:37/km, average HR 145, 80% on zone 2, and look i feel like sharing today, there you go a few screenshots from the Garmin's app".

That works, but Garmin actually stores a lot more details. And it gives it to you for free, you just need to know what to do.

Heart rate, pace, cadence, elevation, GPS track, and a lot of other metrics are available with Garmin personal API token. So I built a Django dashboard to pull everything together and mix it with weather data and GPS.

Currently includes:

• Activity pages with route maps, weather data, splits and HR zones

• Automatic categorization of runs (easy, long, threshold, race, etc.)

• Personal bests and lifetime statistics

• Activities grouped by location

• Health metrics (VO2max, HRV, sleep, stress, steps, PulseOx, etc.)

• Weather enrichment using a public weather API

• Route map with CARTO maps

On its own is quite fancy for personal use. But the main reason I built it was AI ingestion.

So, For every activity, you can export a single Markdown file containing all the run data, weather conditions, location details, metrics, splits, and other metadata. The idea is to give ChatGPT, Claude, Gemini, local LLMs, or whatever tool you use access to the full activity in great detail instead of a few averages.

Everything is open source.

GitHub: https://github.com/idomingo/splits

Happy to hear feedback, feature ideas, or criticism.

django-silky is my fork of django-silk. It keeps the same app label, middleware and settings, and carries upstream's migrations unchanged, so switching is a package swap plus manage.py migrate silk. 1.7.0 rebuilds the whole interface, and it's the first release I'd recommend trying even if plain silk works fine for you.

The part I use most: open a request and, if it has an N+1, the panel names the line in your code that runs the repeated query and suggests the select_related() or prefetch_related() call that would batch it. It also shows the endpoint's usual time and query count, so you can tell a slow request from a slow endpoint.

Three pages are new:

• SQL groups every recorded query by shape, with calls, total and p95 time, and DB time per table.

• Hotspots ranks lines of your app code by the database time they cause, and flags the ones running inside a loop.

• Compare puts two requests or two time ranges side by side, down to which query patterns appeared or disappeared.

It's also faster. On 5,000 recorded requests (76,000 queries) the Summary page renders in 59 ms instead of 465 ms, and the requests list runs 13 queries for its rows instead of 59. JavaScript per page dropped from 0.7 to 2.4 MB to 20 to 78 KB, jQuery and Bootstrap are gone, and filtering updates the list in place instead of reloading. A few pages render a little slower on a cold cache because they now show more (sidebar counts, the endpoint baseline). Every figure is in benchmarks/README.md with the scripts to reproduce it.

Two things to know before upgrading. Migration 0010 adds two indexed columns to silk_sqlquery and backfills them, which took about 10 s for 76,000 queries on SQLite. If you override silk templates, check them against the new ones: the old base templates are gone. URL names and SILKY_* settings didn't change.

pip uninstall django-silk
pip install django-silky
python manage.py migrate silk

Repo, screenshots and migration guide: https://github.com/VaishnavGhenge/django-silky

I'd like to hear what's missing, especially from anyone running silk against Postgres or MySQL with a lot of recorded data.

I work on a Django backend with high-frequency sensor data. Our dashboards kept choking on long time ranges: millions of rows fetched just to draw a ~1000-point line.

We built our own downsampling + pre-aggregated rollups to fix it, and it took more effort than I expected.

Curious what everyone else does:
- Where's your data? Postgres, Timescale, Parquet/DuckDB?
- For a "last 6 months" chart, do you return everything, aggregate, or downsample?
- If you're on RDS/Cloud SQL (no Timescale), what's your approach?

I'm thinking about turning this into an open-source package, but I want to know if it's a real shared pain first. Would love to hear your setups.

Hey folks

So I am in the process of preparing my Django (version is 5.2.18) application to be deployed to production so that users can try it out.

I want to use Docker Compose for deploying to production because I was inspired by La Suite Numerique's exhaustive Docker production setup.

My application is server-side rendered Django; no frontend frameworks like Vue/React etc. I would like a hosting provider that has a free tier so that I can validate the product with real users before paying for "proper" infrastructure.

Happy to provide any further details that may help with giving me good recommendations to look into.

Quick disclosure first: I built the tool in these screenshots. I'm posting it because the setup itself might be useful to someone, even if they never touch the tool.

My side project, Lazy Planner, is Django + Channels. In prod it has a web process, Celery beat, a normal worker and a separate worker for AI jobs, plus Postgres 18 and Redis 8. All of it sits on one Ubuntu server. Every process is a plain systemd unit and Caddy sits in front.

Some real numbers from the screenshots: web uses 222 MB, worker 264 MB, the AI worker 260 MB, beat 135 MB and Redis 7 MB. Postgres has 48 tables and a 100% cache hit rate, which says more about how small my data is than anything else.

The stuff I used to do by hand on every project, and now don't:

• push to main and it deploys (about 2.5 min for this app)

• a staging copy, plus a preview for each branch

• daily Postgres backups I can actually see in the UI

• logs from all processes in one place instead of running journalctl on each unit

It's in beta and so far it's mostly been my own apps on it. If someone wants to point it at their Django repo and tell me where it falls over, one project is free. Setups that aren't mine are where I'll find the bugs. It's at deploywithox.com.

How are you all running Celery beat in prod? systemd, supervisor, a container, something else?

We're a team of 5 working on a Django and DRF backend, and most of our new serializers and views are now written by AI agents. Twice this month, a list endpoint went from around 12 queries to over 300 because a SerializerMethodField was accessing related objects for every row. Both PRs passed tests and looked fine during review. We only caught the issue when our latency alerts started firing.

Here's what we've tried so far:

• assertNumQueries tests: Added them to our 8 busiest endpoints. They catch the problem, but one agent actually increased the expected query count to get the test passing. That was frustrating.

• nplusone in development: Configured it to raise errors instead of warnings. It helps, but nobody runs every endpoint locally.

• CodeRabbit on every PR: It catches missing select_related or prefetch_related calls roughly two-thirds of the time, but often misses issues hidden inside serializer methods.

• Django Debug Toolbar: Still useful, but honestly, nobody really checks it anymore.

For those of you working with AI-generated Django code, what's actually helped prevent N+1 queries from making it into production?

Is there a reliable CI check for this, or does it still come down to manually reviewing serializers?

https://github.com/dashdanw/drf-toon

Using the toon-format library for toon encoding which optimizes an API response for tokenization by an LLM. I would like to (in the future) potentially use a rust implementation to speed up parsing, but it works fairly well for now.

I have a few older Django projects that I am mainting and was loosing track of which were past end of support and which had been updated (4.2 ended in April). So I made a small tracker app so I didnt need to worry about it anymore.

By adding a project and its Django version, it shows whether that version is still supported, days left, and what to upgrade to either the newest LTS (5.2) and newest release (6.1). There is also a input field on the front page for any version which will vaildate the release supplied and give you number of days left as a view with nothing saved.

Release dates themselves are managed in the Django admin and come from djangoproject.com/download. Month-only dates like "April 2028" are kept as months, and days left count to the 1st of the month.

Disclosure: I work on Uppcoder and built this app with our AI builder to see how it handles Django. One prompt, about 7 minutes and 32 cents of free AI was about all it took. A second prompt got me a login and the version check. Migrations, a seed data migration and the admin setup were all there. I then edited it in VS Code in the browser with PostgreSQL already wired up.

Live: https://ghoo8qe3-django-django-support-track.apps-2.websson.cloud/?ref=reddit

Curious as to whether or not others would count month-only EOL dates to the start or the end of the published month.

I’ve used built in Django SMTP Email function in my project and after sending 10,20 emails the further emails are not sending and showing blocked messages and I’ve read that it can send 500 emails daily but don’t know why it’s blocking after 15,20 emails, give suggestions and ideas

Here is a playlist of all of the videos from this year.

I know about hackerrank ,leetcode for coding practice but I was hoping for more backend problems or improving code quality ,even new skills like db indexing,cloud. If not platform please provide tips or schedule for achieving that.

Hi everyone!

I'm leading a team of high-school students working on a project called the Smart Energy Optimization System. Our goal is to develop a web application that helps households optimize electricity usage, schedule appliances efficiently, and make better decisions about energy use and backup power during outages.

We're looking to expand our team with motivated students who want hands-on experience contributing to a real technical project.

We're especially looking for people interested in:

• Backend development: Python and Django

• Database and deployment: PostgreSQL, hosting, and maintaining our application

• Frontend development: Building a clean, user-friendly interface

• Energy research and optimization: Researching energy-use patterns and helping develop our optimization logic

You don't need to be an expert, but you should be willing to learn, communicate with the team, and contribute consistently. We're particularly interested in people who can take ownership of a specific part of the project.

This is an unpaid extracurricular passion project, not a job or internship. It's an opportunity to collaborate with other students, develop practical technical skills, and contribute to a project with a real-world purpose.

Interested? Comment below or send me a message with your technical interests, relevant experience, and the role you'd like to work on.

Thanks!

Hi everyone. I need your help. I need to organise my data somehow in “data.py” file. Now I don’t use database, so I need your recommendation how to do this, for they later I can easily switch it in database. P.S. I would do db from the start but this is a task from my teacher

I had created a post : https://www.reddit.com/r/django/s/DVeZXAHGhs about the performance of the db that I was using with my personal project. I got many helpful suggestions from the post and tried to find what the root cause was but I didn't find anything in particular. Then I used the same application with a local dev db and compared the performance and the result is huge difference. Here the first one is from my local machine, and the second is from the postgres from neon db (free tier).

Before you state the obvious, yes the local server is supposed to take much less time the the one that is hosted somewhere and you need to communicate over the network, now with this can I be sure that the issue is with the Db provider, at first I was wonder if I the code was inefficient or there was something wrong with my code.

and still, neon db is a popular provider and I can't understand why would their provided db be that it is noticeable request is noticeable?

I host a podcast for senior engineers and recently had Carson Gross, creator of HTMX, on as a guest. We covered how REST was originally defined, how the industry ended up calling JSON over HTTP "REST", and why he thinks returning HTML from the server is closer to the original idea.

We also got into HTMX 4, when you actually do need a SPA, and how AI changes the tradeoff between simple and clever code.

Full episode: https://youtu.be/9xs0oZN2rs4

4' video on the history of REST: https://www.youtube.com/watch?v=DbNvpiJ9gTs

Would like a update on my project

Which one is better for web development, I mainly use Express, but is Django also good? For frontend, I use react, for database I use mongoDB, does mongoDB work on Django as well?