Beta
Evaluate APIs and limitations against your own requirements.
Open source · Beta / Built for Django Your Django.
Your Django.
A clearer architecture.
Typed boundaries for Django applications.
Bring Pydantic validation and explicit contracts to your Django models.
Add caching, async tasks, and observability as your application grows.
pip install django-novaclass ArticleSchema(BaseModel):
title: str = Field(min_length=1, max_length=200)
content: str = Field(min_length=10)
class Article(NovaModel):
_nova_config = NovaConfig(
pydantic_schema=ArticleSchema,
strict_validation=True,
)
title = models.CharField(max_length=200)
content = models.TextField() Shared schema · explicit model configurationFull runnable example →
Beta software. Explore supported behavior and limitations before adoption.
01 / PROJECT STATUS
Evaluate before you integrate.
Public source, reports, and release history give you a starting point for evaluating the library.
Check your release
Package requirements and CI test coverage are different. Check both.
Package metadata ↗Inspect the evidence
Coverage describes executed lines. It does not establish correctness or production readiness.
Coverage report ↗02 / QUICK START
One schema. A concrete example.
A minimal synchronous save path using SQLite. Start here before adding caches, background tasks, or API integrations.
Download or clone the site repository and open
examples/quickstart. The full example includes Django settings and a verification script. Verified with django-nova 0.6.1, Django 5.2.17, Pydantic 2.13.5, and Python 3.12.14 on 2026-09-14. Site repository ↗Terminal · from examples/quickstart
python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
python manage.py migrate --run-syncdb
python manage.py shell < demo.pyarticles/schemas.pyDefine one shared schema.
from pydantic import BaseModel, ConfigDict, Field
class ArticleSchema(BaseModel):
model_config = ConfigDict(str_strip_whitespace=True)
title: str = Field(min_length=1, max_length=200)
content: str = Field(min_length=10)articles/models.pyImport that schema into your model.
from django.db import models
from nova.typing import NovaConfig, NovaModel
from .schemas import ArticleSchema
class Article(NovaModel):
_nova_config = NovaConfig(
pydantic_schema=ArticleSchema,
strict_validation=True,
cache_enabled=False,
)
title = models.CharField(max_length=200)
content = models.TextField()demo.pyCreate a valid record, then reject invalid input.
from nova.core.exceptions import NovaValidationError
from articles.models import Article
article = Article(title="Hello Nova", content="A shared validation contract.")
article.save()
print(f"Saved: {article.title}")
before = Article.objects.count()
try:
Article(title="", content="too short").save()
except NovaValidationError:
print("Rejected invalid article before persistence.")
else:
raise AssertionError("Expected validation to reject invalid input")
assert Article.objects.count() == before
print("PASS: invalid input did not create a record.")Scope: this example covers
NovaModel.save(). It does not demonstrate bulk-write validation, cache invalidation, async execution, or production deployment. Explore the documentation ↗03 / ARCHITECTURE
Make the boundaries visible.
Django retains its ORM and persistence responsibilities. Nova connects shared validation schemas with explicit integration points.
Schema contract
Pydantic defines supported data rules. Reuse the schema at configured integration points.
Validation boundary
The Nova model save path invokes validation before delegating to Django persistence.
Database integrity
Database constraints remain necessary. An application-level schema cannot protect writes that bypass it.
Engineering note: understand the decision, alternatives, and limits of the model save boundary.
Read the engineering note →04 / MODULES
Choose the integration you need.
Start with a small adoption scope. Inspect each module before making it part of an application boundary.
nova.typing
Typed interfaces
Model and QuerySet interfaces help make supported Django integration points easier to reason about. Check typing behavior against your models and tooling.
Inspect implementation ↗nova.validation
Shared validation
Connect Pydantic schemas to the Nova validation lifecycle. Validation guarantees depend on the operation and configured integration.
Inspect implementation ↗nova.cache
QuerySet caching
Cache query results and connect invalidation to supported model events. Review bulk writes, transaction timing, and external updates.
Inspect implementation ↗nova.tasks
In-process async tasks
An asyncio backend executes coroutine tasks within the application process. Review restart behavior and move blocking computation out of the event loop.
Inspect implementation ↗nova.db
Migration utilities
Helpers for concurrent index creation and batched data changes. PostgreSQL lock behavior and transaction restrictions still apply.
Inspect implementation ↗Integrations
Optional adapters
Explore DRF, FastAPI, and observability integration points. Install only the extras you need and verify their documented configuration.
Inspect implementation ↗05 / SUPPORTED BEHAVIOR & LIMITATIONS
Know where the guarantees end.
Use these boundaries as an integration checklist. Confirm release-specific behavior with documentation and tests.
| Area | Intended integration scope | Boundary to verify |
|---|---|---|
| Validation | The Nova model save path invokes the configured validation lifecycle. | Do not assume bulk operations, raw SQL, or external writers use the same path. |
| Typing | Typed interfaces support static checking at integration boundaries. | Static analysis does not validate untrusted runtime data or replace database constraints. |
| Caching | Model-event hooks connect supported writes to invalidation. | Check bulk writes, external updates, related models, and transaction timing for your use case. |
| Async tasks | The asyncio backend runs coroutine tasks in the application process. | An in-memory queue is not durable across process loss. CPU-bound code can block the event loop. |
| Migrations | Concurrent index creation and batching address specific migration needs. | ALTER TABLE can acquire exclusive locks. Review transaction boundaries, rollback, and lock timeouts. |
06 / PHILOSOPHY
Principles that guide the implementation.
Prefer inspectable behavior, reusable contracts, and clear responsibilities at framework boundaries.
Shared validation rules
Keep reusable data rules in Pydantic schemas and connect them through documented integration points.
Early checks, explicit runtime validation
Use static analysis to catch supported type errors and runtime validation to check incoming data.
Async with defined boundaries
Use coroutine-based APIs where appropriate, while accounting for blocking work and process lifetime.
Operationally informed changes
Plan schema changes around actual database behavior, deployment sequencing, and recovery requirements.
07 / MAINTAINER & CONTACT
Let’s build
something useful.
Artem Alimpiev · Python Backend Developer
Creator & Maintainer of Django Nova
I develop Django and FastAPI applications and open-source developer tools. My work on Django Nova focuses on shared validation, typed integration boundaries, caching, and backend infrastructure.
Based in Uruguay · Open to remote Python backend opportunities
alimpievne@gmail.comFor bugs and feature requests, open a GitHub issue. For hiring or private correspondence, use email.