DEV Community: Vaishnav Ghenge

django-silky: A Modern Fork of django-silk with Dark Mode, D3 Charts, and N+1 Detection

Vaishnav Ghenge — Wed, 18 Feb 2026 19:22:13 +0000

If you've ever profiled a Django app, you've probably used django-silk. It's invaluable — every HTTP request recorded, every SQL query captured with timing and a stack trace, and
code profiling with decorators or cProfile.

The problem? The UI hasn't changed meaningfully in years. It's functional, but it's dated.

I spent the last few days forking it into django-silky — same full feature set, completely redesigned interface.

What changed

Light / dark theme

The original has a fixed dark nav bar with a light body — not a real theme, just inconsistent styling. django-silky uses CSS custom properties throughout so the entire UI toggles cleanly between light and dark, persisted in
localStorage.

D3 analytics dashboard

The summary page now has a full analytics section built with self-hosted D3.js v7 (no CDN):

Request activity — area chart over time (hourly or daily buckets depending on range)
Status code breakdown — donut chart (2xx / 3xx / 4xx / 5xx)
HTTP method distribution — horizontal lollipop chart
Response time histogram — 6 fixed buckets with gradient fill
Latency percentiles — gradient area chart annotated at p25, p50, p75, p95, p99 for both request time and SQL query time

All charts re-render when you toggle the theme, and they read colours from CSS custom properties so they always match the active theme.

N+1 query detection

This was my favourite thing to build. Silk already captures every SQL query per request, so it has all the data needed to detect N+1 patterns automatically.

The algorithm:

For each query in a request, compute a fingerprint — strip single-quoted string literals → ?, strip numeric literals → ?, normalize whitespace, lowercase
Group queries by fingerprint
Flag any group with ≥ 3 occurrences

When N+1 is detected you get:

A warning pill in the request hero bar linking to the SQL list
A banner on the SQL list page showing the repeated pattern count and the actual query text
Highlighted rows in the SQL table for every flagged query

The key implementation detail: only strip single-quoted string literals (values). Double-quoted identifiers like "table"."column" are kept intact so the fingerprint remains human-readable.

Requests list

The requests list now uses:

A table layout instead of a card grid — much easier to scan 25+ requests
Inline collapsible filter bar replacing the old 300 px slide-out drawer
Multi-column sort chips — click to add/remove/toggle sort columns, persisted in session
Real Django Paginator with prev/next/page numbers instead of a raw LIMIT N slice
Sort + per-page encoded in the URL so you can share a specific filtered view

Detail pages

Every detail page (request, SQL, profile) now has a hero bar at the top with:

Method badge (colour-coded: GET green, POST blue, PUT amber, DELETE red)
Status code badge (2xx green, 3xx blue, 4xx amber, 5xx red)
Timestamp
Timing pills: total time, DB time, query count

Icons

Replaced Font Awesome loaded from a CDN with Lucide icons, self-hosted at silk/static/silk/lib/lucide.min.js. Zero external network requests from the UI.

Installation

pip install django-silky

It's a drop-in replacement for django-silk — same silk app label, same database schema (migrations 0001–0008), no manage.py migrate needed.

pip uninstall django-silk
pip install django-silky

settings.py

MIDDLEWARE = [
  ...
  'silk.middleware.SilkyMiddleware',
  ...
]

INSTALLED_APPS = [
  ...
  'silk',
]

urls.py

urlpatterns += [
  path('silk/', include('silk.urls', namespace='silk')),
]

Visit /silk/ and you're in.

SQL inspection

Every SQL query is captured with:

Execution time (colour-coded: green < 100 ms, amber 100–500 ms, red > 500 ms)
Tables involved
Number of joins
Full Python stack trace so you know exactly where the query was triggered
EXPLAIN plan (when SILKY_ANALYZE_QUERIES = True)

Configuration highlights

# Authentication
SILKY_AUTHENTICATION = True
SILKY_AUTHORISATION = True  # is_staff required

# Sampling on high-traffic sites
SILKY_INTERCEPT_PERCENT = 50  # record only 50% of requests

# Query analysis
SILKY_ANALYZE_QUERIES = True

# Garbage collection
SILKY_MAX_RECORDED_REQUESTS = 10_000

Code profiling

The decorator and context manager APIs are unchanged from django-silk:

from silk.profiling.profiler import silk_profile

@silk_profile(name='Get farm visits')
def get_visits(request):
  return Visit.objects.select_related('farmer').all()

cProfile integration with call-graph rendering is also still there:

SILKY_PYTHON_PROFILER = True

Modern Django & Django REST Framework Complete Roadmap

Vaishnav Ghenge — Tue, 12 Aug 2025 06:55:57 +0000

Getting Started

Installation & Setup

Request-Response Cycle

Understanding the fundamental architecture of Django's HTTP handling:

Core Django Concepts

Settings & Configuration Management

Django settings file is a Python module with module-level variables containing all configuration:

Key Configuration Areas:

ALLOWED_HOSTS - Security configuration
DATABASES - Database connections
DEBUG - Development vs production mode
INSTALLED_APPS - Application registry
MIDDLEWARE - Request processing pipeline
SECRET_KEY - Cryptographic signing
TEMPLATES - Template engine configuration
STATIC_ROOT & STATIC_URL - Static files
MEDIA_ROOT & MEDIA_URL - User uploads
TIME_ZONE - Timezone configuration

Environment-Based Configuration:

Django Settings Best Practices
Environment Variables with python-decouple
Multiple settings files (dev, staging, production)

Models & ORM (Object Relational Mapping)

Model Fundamentals

A model is the single, definitive source of information about your data:

Model Relationships

Foreign Keys - One-to-many relationships
Many-to-Many - Many-to-many relationships
One-to-One - One-to-one relationships
Related Name - Reverse relationship naming

Database Queries & QuerySets

QuerySet Evaluation

Methods that return new QuerySets:

filter() - Filter records
exclude() - Exclude records
annotate() - Add calculated fields
order_by() - Sort results
distinct() - Remove duplicates
values() - Return dictionaries
values_list() - Return tuples
select_related() - Join related tables
prefetch_related() - Prefetch related objects

Methods that execute queries:

get() - Get single object
create() - Create new object
get_or_create() - Get or create object
update_or_create() - Update or create
bulk_create() - Create multiple objects
bulk_update() - Update multiple objects
count() - Count objects
exists() - Check existence
first() - Get first object
last() - Get last object

Field Lookups:

Field Lookups Reference
Common lookups: exact, iexact, contains, icontains, in, gt, gte, lt, lte, startswith, endswith, range, date, year, month, day, isnull

Query Performance Optimization

Custom Managers

Managers Documentation
Custom QuerySets and Managers
Adding extra manager methods

Database Migrations

Migrations propagate model changes to your database schema:

Advanced Migration Topics:

Data migrations
Custom migration operations
Database-specific migrations
Zero-downtime migrations

Django Admin Interface

Django provides a customizable admin interface out of the box:

Basic Admin Registration:

ModelAdmin Customization Options:

exclude - Hide fields
fieldsets - Group fields
form - Custom forms
list_display - List view columns
list_filter - Filter sidebar
list_select_related - Optimize queries
search_fields - Search functionality
ordering - Default ordering

Inline Administration:

Admin Performance Optimization:

Custom Management Commands

Create CLI commands for maintenance and automation:

Writing Custom Commands
Command structure and argument parsing
Scheduling and automation integration

Middleware

Request/response processing pipeline:

Middleware Documentation
Writing custom middleware
Security middleware
Performance middleware

URL Configuration

URL Dispatcher
URL patterns and regex
Named URLs and namespacing
Include patterns for app organization

Views & Templates

Function-Based Views
Class-Based Views
Template System
Context processors and template tags

Forms (Optional—not used in REST based setups)

Working with Forms
ModelForms and form validation
Form rendering and customization

User Management & Authentication

Authentication System
Custom User models
User profiles and permissions
Password management

File Handling

File Uploads
Static files configuration
Media files handling
File storage backends

Signals

Django's signal dispatcher for decoupled applications:

Signals Overview

Common Signals:

pre_init - Before model init
post_init - After model init
pre_save - Before model save
post_save - After model save
pre_delete - Before model delete
post_delete - After model delete
m2m_changed - Many-to-many changes

Aggregations

Aggregation Documentation
Count, Sum, Avg, Max, Min
Group by operations
Complex aggregations

Localization (i18n) (Optional-not used for REST setups)

Internationalization
Translation and localization
Multiple language support
Date, time, and number formatting

Django REST Framework

Getting Started with DRF

Complete tutorial series covering all essential concepts:

Serializers

Transform data between complex types and Python datatypes:

Core Serializer Concepts:

Serializers Overview
ModelSerializer
Field validation and custom validation
Nested serialization
SerializerMethodField for computed fields

Advanced Serialization:

Custom serializer fields
Dynamic serializers
Serializer inheritance
Write-only and read-only fields
Validation best practices

ViewSets & Views

Organize API endpoints efficiently:

ViewSet Types:

ViewSets Overview
ModelViewSet - Full CRUD operations
ReadOnlyModelViewSet - Read-only operations
Generic ViewSets - Custom combinations

Generic Views:

ListAPIView, CreateAPIView, RetrieveAPIView
UpdateAPIView, DestroyAPIView
ListCreateAPIView, RetrieveUpdateAPIView
RetrieveUpdateDestroyAPIView

Custom Actions:

@action decorator for custom endpoints
Detail vs list actions
Custom routing

Authentication

Secure your API endpoints:

Authentication Classes:

Advanced Authentication:

JWT Authentication (with djangorestframework-simplejwt)
OAuth2 integration
Custom authentication classes
Multi-authentication support

Permissions

Control access to your API:

Built-in Permissions:

Permissions Overview
IsAuthenticated, IsAuthenticatedOrReadOnly
IsAdminUser, DjangoModelPermissions
DjangoObjectPermissions

Custom Permissions:

Writing custom permission classes
Object-level permissions
Permission composition
Dynamic permissions

Filtering, Searching & Ordering

Make your APIs more flexible:

Built-in Filtering:

Filtering Overview
DjangoFilterBackend with django-filter
SearchFilter for text search
OrderingFilter for sorting

Advanced Filtering:

Custom filter classes
Multiple filter backends
Filter validation
Complex query filtering

Pagination

Handle large datasets efficiently:

Pagination Styles:

Pagination Overview
PageNumberPagination
LimitOffsetPagination
CursorPagination for performance

Custom Pagination:

Custom pagination classes
Pagination metadata
Frontend integration patterns

Routers

Automatic URL routing for ViewSets:

Router Types:

Routers Overview
DefaultRouter with trailing slashes
SimpleRouter without API root
Custom routers for specific needs

URL Patterns:

Nested routing
Custom action URLs
API versioning with routers

API Versioning

Manage API changes over time:

Versioning Overview
URL path versioning
Header versioning
Accept header versioning

Error Handling

Provide consistent error responses:

Exception Handling
Custom exception classes
Global exception handling
Validation error formatting

Content Negotiation

Support multiple response formats:

Content Negotiation
JSON, XML, and custom renderers
Content-Type handling
Accept header processing

Testing Framework

Django Testing Fundamentals

Comprehensive testing approach for Django applications:

Test Structure:

Testing Overview
Writing Tests
Test discovery and organization
Test database setup and teardown

Test Types

Unit Tests:

TestCase Classes
Model testing with Django TestCase
Isolated component testing
Fast test execution

Integration Tests:

Testing model relationships
View integration testing
End-to-end workflow testing
Database transaction testing

API Testing:

Testing REST APIs
APITestCase for DRF
Authentication in tests
Response validation

Test Fixtures & Data

Manage test data efficiently:

Fixture Types:

Fixtures Documentation
JSON fixtures for static data
YAML fixtures (more readable)
SQL fixtures for complex data

Dynamic Test Data:

Factory Boy for model factories
Faker for realistic fake data
Model Mommy/Model Bakery alternatives
SetUp and tearDown methods

Database Management:

TransactionTestCase for transaction testing
Database flushing strategies
Test database optimization
Parallel test execution

Mocking & Patching

Isolate units under test:

Mock Strategies:

unittest.mock integration
Patching external dependencies
Mock return values and side effects
Assert mock calls and arguments

Common Mock Patterns:

Mocking database queries
Mocking external API calls
Mocking file system operations
Mocking email sending
Mocking time and datetime

Django-Specific Mocking:

Mocking Django settings
Mocking request objects
Mocking authentication
Mocking signals

Test Utilities & Helpers

Django Test Client:

Test Client for view testing
GET, POST, PUT, DELETE requests
Session and authentication testing
File upload testing

Assertion Helpers:

Custom assertion methods
Response content assertions
Database state assertions
Email and message assertions

Test Organization:

Test mixins for reusable functionality
Base test classes
Test utilities module
Test settings configuration

Performance Testing

Ensure your application performs well:

Database Query Testing:

assertNumQueries
Query count optimization
N+1 query detection
Database performance profiling

Load Testing:

Integration with locust or artillery
API endpoint performance
Concurrent user simulation
Response time monitoring

Test Coverage

Measure and improve test coverage:

Coverage Tools:

Coverage.py integration
HTML coverage reports
Branch coverage analysis
Coverage thresholds

Coverage Best Practices:

Meaningful coverage metrics
Testing critical paths
Edge case coverage
Regression test strategies

Continuous Integration

Automate your testing pipeline:

CI Setup:

GitHub Actions for Django
Docker-based testing
Multiple Python/Django versions
Database service setup

Quality Gates:

Test coverage requirements
Code quality checks
Security scanning
Performance benchmarks

Asynchronous Django

Django Channels

Real-time communication with WebSockets:

Core Concepts:

Introduction to Channels
ASGI vs WSGI
WebSockets vs HTTP comparison
WebSocket Basics

Channels Components:

Consumers - WebSocket handlers
Channel layers for message passing
Routing for WebSocket URLs
Installation Guide
Complete Tutorial

Celery Integration

Asynchronous task processing:

Architecture:

Celery Overview
Broker, Workers, and Result Backend
Django Integration

Task Management:

@shared_task decorator
Task execution methods (delay, apply_async)
Task signatures
Task chains
Immutable signatures

Periodic Tasks:

Third-Party Integrations

Database Configuration

Modern database setup and optimization:

PostgreSQL Integration:

psycopg2 vs psycopg3
Connection pooling
Database optimization
PostGIS for geographic data

MySQL Integration:

mysqlclient configuration
Character set and collation
Performance tuning
Full-text search

CORS (Cross-Origin Resource Sharing)

Enable cross-origin requests:

django-cors-headers
CORS policy configuration
Preflight request handling
Security considerations

API Documentation

Auto-generate comprehensive API docs:

Swagger/OpenAPI:

drf-spectacular for OpenAPI 3
Schema generation
Interactive API documentation
Custom schema extensions

Alternative Documentation:

django-rest-swagger (legacy)
Custom documentation generation
API versioning in docs

Email Integration

Configure email sending:

Email Backends:

SMTP configuration
SendGrid integration
Amazon SES setup
Development email backends

Email Features:

HTML email templates
Attachment handling
Email queuing with Celery
Email testing strategies

Caching

Improve application performance:

Cache Backends:

Redis configuration
Memcached setup
Database caching
Local memory caching

Caching Strategies:

Template fragment caching
View-level caching
ORM query caching
API response caching

Logging & Monitoring

Track application behavior:

Logging Configuration:

Django Logging
Structured logging
Log aggregation
Error tracking with Sentry

Monitoring Tools:

Application performance monitoring
Database query monitoring
API endpoint monitoring
Health check endpoints

Security & Best Practices

Security Fundamentals

Protect your Django application:

Built-in Security:

CSRF protection
SQL injection prevention
XSS protection
Clickjacking protection

Security Headers:

HTTPS enforcement
Security middleware
Content Security Policy
HSTS configuration

Authentication Security:

Password policies
Two-factor authentication
Rate limiting
Session security

Performance Optimization

Optimize your application:

Database Optimization:

Query optimization
Index management
Connection pooling
Database profiling

Caching Strategies:

Application-level caching
Database query caching
Static file caching
CDN integration

Code Optimization:

Profiling tools
Memory usage optimization
Async view support
Background task optimization

Deployment & DevOps

Deploy your application:

Deployment Strategies:

Docker containerization
Environment configuration
Static file serving
Database migrations in production

Monitoring & Logging:

Application monitoring
Error tracking
Performance monitoring
Log aggregation

Advanced Architecture Patterns

App Structure & Organization

Scale your Django project:

Modular App Design:

App responsibility separation
Inter-app communication
Shared utilities
Plugin architecture

Project Structure:

Settings organization
URL configuration patterns
Template organization
Static files structure

Custom Exceptions

Implement robust error handling:

Exception Hierarchy:

Custom exception classes
Business logic exceptions
API error responses
Exception middleware

Design Patterns

Apply common Django patterns:

Model Patterns:

Abstract base classes
Model mixins
Manager patterns
Custom field types

View Patterns:

Generic view customization
Mixin composition
Decorator patterns
Context processor patterns

Additional Resources

Community Packages

Essential third-party packages:

Development Tools:

django-debug-toolbar
django-extensions
ipdb for debugging

Admin Enhancements:

django-admin-interface
django-grappelli
django-jet

API Tools:

drf-extensions
django-filter
drf-yasg

Utilities:

django-environ
django-model-utils
django-guardian for object permissions

Learning Resources

Continue your Django journey:

Documentation:

Official Django documentation
Django REST Framework documentation
Django packages directory

Books & Tutorials:

Two Scoops of Django
Django for Professionals
Real Python Django tutorials

Community:

Django Discord community
Django forums
DjangoCon conferences

Advanced Django Topics

Custom Management Commands

Create CLI commands for maintenance and automation:

Writing Custom Commands
Command structure and argument parsing

Custom Middleware

Request/response processing pipeline:

Middleware Documentation
Writing custom middleware

Advanced Model Techniques

Custom model managers
Model inheritance patterns
Custom field types
Database constraints

Advanced Serialization

Custom serializer fields
Dynamic serializers
Nested serialization patterns
Performance optimization

API Documentation

Auto-generate API documentation:

drf-spectacular for OpenAPI 3
Schema generation
Interactive API documentation

Background Tasks

Asynchronous task processing:

Celery Overview
Django Integration
Task management and scheduling

Real-time Features

WebSocket integration:

Django Channels
WebSocket consumers
Real-time notifications

Project Examples

Blog Platform

Core Features:

User authentication and profiles
Post creation and editing
Comment system
Category and tag management
Search functionality

E-commerce API

Core Features:

Product catalog management
Shopping cart functionality
Order processing
Payment integration
User reviews and ratings

Social Media API

Core Features:

User profiles and authentication
Post creation and sharing
Follow/unfollow system
Like and comment functionality
News feed generation

Task Management System

Core Features:

Project and task organization
User collaboration
File attachments
Progress tracking
Notification system

DEV Community: Vaishnav Ghenge

django-silky: A Modern Fork of django-silk with Dark Mode, D3 Charts, and N+1 Detection

What changed

Light / dark theme

D3 analytics dashboard

N+1 query detection

Requests list

Detail pages

Icons

Installation

settings.py

urls.py

SQL inspection

Configuration highlights

Code profiling

Links

Modern Django & Django REST Framework Complete Roadmap

Getting Started

Installation & Setup

Request-Response Cycle

Core Django Concepts

Settings & Configuration Management

Models & ORM (Object Relational Mapping)

Model Fundamentals

Model Relationships

Database Queries & QuerySets

Query Performance Optimization

Custom Managers

Database Migrations

Django Admin Interface

Custom Management Commands

Middleware

URL Configuration

Views & Templates

Forms (Optional—not used in REST based setups)

User Management & Authentication

File Handling

Signals

Aggregations

Localization (i18n) (Optional-not used for REST setups)

Django REST Framework

Getting Started with DRF

Serializers

ViewSets & Views

Authentication

Permissions

Filtering, Searching & Ordering

Pagination

Routers

API Versioning

Error Handling

Content Negotiation

Testing Framework

Django Testing Fundamentals

Test Types

Test Fixtures & Data

Mocking & Patching

Test Utilities & Helpers

Performance Testing

Test Coverage

Continuous Integration

Asynchronous Django

Django Channels

Celery Integration

Third-Party Integrations

Database Configuration

CORS (Cross-Origin Resource Sharing)

API Documentation

Email Integration

Caching

Logging & Monitoring

Security & Best Practices

Security Fundamentals

Performance Optimization

Deployment & DevOps

Advanced Architecture Patterns

App Structure & Organization

Custom Exceptions

Design Patterns

Additional Resources