DEV Community: Corix RID

I built an initial data syncing system for Django projects

Corix RID — Wed, 24 Sep 2025 16:07:51 +0000

One recurring headache in Django projects is keeping seed data consistent across environments.

You add reference data (categories, roles, settings) in development… and forget to sync it to staging or production.
Different environments drift apart, leading to version conflicts or missing records.
Deployment scripts end up with ad-hoc JSON fixtures or SQL patches that are hard to maintain.

I got tired of that. So I built django-synced-seeders — a simple, ORM-friendly way to version and sync your seed data.

What it does

Versioned seeds: Every export is tracked so you don’t re-import the same data.
Environment sync: Run syncseeds in staging or production to automatically bring them up to date.
Export / Import commands: Seamlessly move reference data between environments.
Selective loading: Only load the seeds you need by defining exporting QuerySets.

Quick start

pip install django-synced-seeders

or use uv

uv add django-synced-seeders

Add it to INSTALLED_APPS in settings.py, then run:

python manage.py migrate

Define your seeders (e.g. seeders.py):

from seeds.registries import seeder_registry
from seeds.seeders import Seeder
from .models import Category, Tag

@seeder_registry.register()
class CategorySeeder(Seeder):
    seed_slug = "categories"
    exporting_querysets = (Category.objects.all(),)
    delete_existing = True

@seeder_registry.register()
class TagSeeder(Seeder):
    seed_slug = "tags"
    exporting_querysets = (Tag.objects.all(),)

Export locally:

python manage.py exportseed categories
python manage.py exportseed tags

Sync on another environment:

python manage.py syncseeds

Now your development, staging, and production stay aligned — without manual JSON juggling.

Why this matters

Prevents “works on my machine” seed data issues.
Keeps environments aligned in CI/CD pipelines.
Easier to maintain than fixtures or raw SQL.
Open source (MIT license) and ready for contributions.

If you’ve ever wrestled with fixtures or forgotten to copy seed data between environments, I think you’ll find this useful.

👉 Check it out here: github.com/Starscribers/django-synced-seeders

👉 Join my Discord Server: https://discord.gg/ngE8JxjDx7

Skellar Dev Log #2: Backpack System

Corix RID — Fri, 05 Sep 2025 08:54:38 +0000

Why an Inventory System?

Let's be direct. Making the process of learning inherently fun is a near-impossible task. Our solution is to use extensive gamification to wrap and enhance the entire learning behavior cycle. When selecting these auxiliary systems, we set a few core principles:

Lightweight: Avoid requiring players to invest excessive energy in the game itself.
Low Complexity: The system design must be intuitive and easy to use, without adding to the learning curve.
A Sense of Home: Create a familiar and comfortable virtual environment.

Based on these considerations, we ruled out heavy-duty competitive, strategy, or management-style systems. After two days of rigorous market research, I've narrowed down the most suitable systems for integration:

Inventory & Items
Crafting
Pets
Gacha
Monopoly
Quests
Levels
Leaderboards
Companions & Guilds

Inventory Limits: A Design Feature, Not a Flaw

As players, we often want maximum convenience and unlimited resources. However, this very desire stems from an initial state of inconvenience and resource scarcity.

This is the key element of gamified design: Engineered Scarcity.

A good game design must be "appropriately troublesome" or "lack human-friendliness" to spark player engagement. Limiting inventory space forces players to make choices and prioritize what's truly important.

The Stamina System: Why Restrict the Player?

The stamina system is often a point of frustration for players, but its underlying design logic is based on several psychological considerations:

Regulating the Dopamine Loop: By intermittently limiting rewards, we can effectively increase a player's desire for the next action.
Preventing Player Burnout: We don't want players to exhaust all content in a short period, leading to content droughts and player churn. The stamina system distributes content over time, maintaining long-term player retention.
Extending Product Lifespan: With daily or regular stamina replenishment, we ensure players consistently return, keeping the community active.
Balancing Player Equity: Stamina limits the playtime of heavy users, giving casual players a chance to catch up and helping maintain a healthy ecosystem.
Promoting Knowledge Digestion: This is especially crucial for our product. Learning is an intense cognitive activity, and prolonged sessions can lead to fatigue. Forced breaks help players genuinely digest knowledge and prevent "one-time complete fatigue."

Guiding Stars: An Investment in Personal Growth

Guiding Stars are, in my opinion, the most creative highlight of our item system. They represent a visual learning objective. It's a scarce item that players can "deploy" on an unachieved goal by spending in-game currency. Upon completion, the system grants additional currency based on how quickly they finished. This process is like having players "invest in their own learning journey to receive a significant return."

Conclusion: Fueling Your Passion for the Work

During the prototyping phase, I spent a lot of time on technical roadblocks—iterating to validate PRs and waiting for GitHub Actions and Ngrok. These unseen efforts took a toll on my initial enthusiasm.

That's precisely why I decided to pivot from the core learning flow and develop these auxiliary systems first. I needed to see the tangible possibilities of gamification to re-energize myself and the project.

When building a product, validating your own work is paramount. Most side projects fail because the creator loses interest. Find what keeps your passion alive and push forward.

Starscribers Discord Server: https://discord.gg/KURmknGA
Skellar Open Beta: https://skellar.rn-ws.com/

Skellar: Sky of Skills Dev Log #1

Corix RID — Wed, 03 Sep 2025 09:07:47 +0000

About Skellar

I’ve always been fascinated by the idea of a gamified learning platform. For a long time, it was just a thought due to the technical challenges. But recent advancements in AI have broken down many of those barriers. With a break between jobs, I finally decided to make this project a reality.

The core concept of Skellar is simple: transform learning into a skill map.

Imagine this: you complete tasks, unlock skills, and see your progress laid out clearly. You know exactly what you’ve learned and what’s next. You can even connect these achievements directly to your resume or portfolio.

What to Learn and How

My initial idea for Skellar was a huge skill tree where you could learn “everything.” I quickly realized this was too ambitious. I learned a key lesson about product development: constraints are a source of power. Just like how Duolingo focuses on languages and Brilliant on STEM, Skellar needs to start with a specific field to get the gamification right.

But I also didn’t want to compromise my vision. So, I split the platform into two parts:

The Skill Map: This is your personal skill tree, showing your progress and path.
The Playground: This is where you actually learn by doing. When you unlock a skill on the map, you’re taken to an environment to “learn by doing, playing.”
The map and the playground are separate experiences, but they’re linked together, creating a clear and engaging journey.

A New Approach to Coding

The first version of Skellar will launch with a coding course. People often ask, “How is this different from Codecademy or LeetCode?”

I thought back to my own learning experience. The most effective way I learned wasn’t by doing one exercise after another. It was by: starting with a completed project, trying to add new features, and then testing them. This forces you to understand the existing code and build something new at the same time.

This led me to design a unique learning model for Skellar:

The system provides a realistic codebase.
The content is broken into missions.
You develop a feature, test it, and submit a pull request (PR).
The system automatically verifies your PR with unit tests.
This experience is designed to feel as real as possible. The main challenge is making sure the learning curve is smooth and the interface is clear enough to prevent learners from getting stuck and quitting.

The platform will also be open to third-party creators, whom we call Starscribers, who can upload their own courses. The goal is to build a community based on two-way knowledge sharing. In the future, we could expand to all kinds of knowledge, even linking with real-world classes.

The MVP and the Future
Before the official launch, I’ve created a minimum viable product (MVP). You can check it out and give me feedback, or join the Starscribers Discord community.

Frontend: Next.js + Shadcn UI
Backend: Django + DRF
Database: PostgreSQL
The graph layout is created with ReactFlow.

I chose these technologies because they are mature, widely supported, and work well with AI tools like GitHub Copilot — which will be doing a lot of the work!

For me, Skellar is an experiment. I’m not focused on building the next “unicorn” product. I’m simply trying to answer one question: can learning truly feel like a game? I’m putting my idea out there and seeing what happens.

I don’t know what the final answer will be, but I know the journey will be fun. If this idea resonates with you, or if you’re curious about how a learning platform is built from scratch, I invite you to join the Discord and witness the growth of this skill constellation.

Starscribers Discord Server: https://discord.gg/KURmknGA
Skellar Open Beta: https://skellar.rn-ws.com/