Stop asking AI to rebuild the same SaaS foundation
SpeedPy gives your coding agent a working Django product with the difficult integrations already joined—and enough repository context to keep new code consistent with the system around it.
Spend prompts, tokens, and review time on the part customers pay for—not another authentication flow, billing state machine, or team permission model.
MIT-licensed. No paid SpeedPy edition. Deploy anywhere Django runs.
Already resolved by the foundation
- ✓Subscription webhook edge cases
- ✓Tenant and role boundaries
- ✓API auth, scopes, and replay safety
- ✓Background jobs and delivery retries
- ✓UI primitives and visual conventions
Your agent focuses here
The product logic that makes customers subscribe.
Backend
Django + DRF
Frontend
HTML + HTMX + Alpine
Runtime
Docker or uv
Ownership
MIT · your codebase
Why the starting point matters
The expensive bugs live between features
AI can generate a login page or checkout endpoint quickly. The real work is making identity, billing, permissions, background work, and public APIs agree under retries, stale events, and hostile input.
Billing state
Risk: access drifts from payment reality.
Duplicate, delayed, and out-of-order provider events are normal—not edge cases you can ignore.
SpeedPy starts with verified Stripe and Paddle webhooks, idempotent event logs, stale-event protection, reconciliation, grace periods, and a provider-neutral state model.
Tenant isolation
Risk: one team sees another team’s data.
A team dropdown is not multi-tenancy. Every query, write, invitation, role, and API endpoint must preserve the boundary.
SpeedPy starts with teams, memberships, invitations, role checks, team-owned base models, scoped API examples, and explicit isolation tests.
Public API behavior
Risk: clients depend on accidental behavior.
Authentication is only one layer. Scopes, schemas, pagination, throttling, request IDs, CORS, and safe retries become part of the contract.
SpeedPy starts with DRF and OpenAPI, JWT/OAuth2/PAT authentication, scopes, rate-limit headers, idempotency support, health endpoints, and schema tests.
Generated UI drift
Risk: every prompt invents a new product.
AI happily creates the fifth button style, a different form pattern, or a layout that fails in dark mode and on mobile.
SpeedPy starts with a documented UI system, reusable components, canonical forms and CRUD screens, responsive rules, dark-mode tokens, and a live component catalogue.
No boilerplate eliminates engineering risk. SpeedPy removes repeated design work, makes important invariants explicit, and gives your tests and reviews a much better baseline.
Two layers of leverage
Working code below. Engineering context above.
Prebuilt features save implementation time. Repository guardrails save the prompts, corrections, and review cycles that come after.
Instructions, examples, skills, and tests for AI agents
The repository tells an agent where code belongs, which patterns are canonical, how tenant isolation works, which UI classes to reuse, what to test, and how to prepare the project for production.
Integrated accounts, billing, teams, APIs, jobs, and UI
Your agent extends real, connected flows instead of generating isolated snippets and asking you to discover the integration gaps later.
What is already integrated
The foundation is broader than a login screen and pricing table
These are connected subsystems with models, views, templates, configuration, and tests—not a checklist of packages for you to wire together.
Identity and security
Users can sign in. Integrations can authenticate.
- Email-first accounts and social login
- Multi-factor authentication and encrypted fields
- Personal access tokens with scopes and access logs
- JWT and OAuth2 provider flows
Teams and tenancy
B2B account boundaries are part of the data model.
- Teams, memberships, roles, and invitations
- Team-scoped models and API resources
- Owner-only lifecycle controls and deletion safeguards
- Subscription ownership by user or team
Subscription billing
Payment events become dependable application state.
- Stripe and Paddle provider adapters
- Checkout, billing portal, and catalog commands
- Signature verification, event deduplication, and reconciliation
- Trials, grace periods, cancellation, and downgrade handling
API and integrations
External clients get a deliberate contract.
- Versioned DRF API with generated OpenAPI schema
- Scopes, throttling, pagination, CORS safeguards, and request IDs
- Replay-safe writes and integration health manifest
- CLI and MCP starter implementations
Async work and webhooks
Slow or unreliable work leaves the request cycle.
- Celery workers and scheduled tasks with Redis
- HMAC-signed outbound webhooks with retries and delivery logs
- Reusable async job status infrastructure
- Server-sent events and long-polling patterns
Product UI and operations
The application already behaves like one product.
- Server-rendered UI with Tailwind, HTMX, and Alpine.js
- Responsive light/dark design system and component catalogue
- Canonical forms, dashboard layouts, CRUD, and product tours
- Email delivery, object-storage option, health checks, and Docker setup
Built for AI-assisted engineering
More control without hand-writing every line
The difference between “AI wrote it” and “AI extended the system correctly” is context. SpeedPy gives the agent concrete constraints and examples before it makes architectural guesses.
No instruction file makes generated code automatically correct. It reduces ambiguity, exposes invariants, and makes review more focused.
- 1
Architecture map
AGENTS.mdexplains where models, views, APIs, forms, tasks, templates, and shared utilities belong—and which tempting shortcuts to avoid. - 2
Reference implementations
The agent can copy known patterns for CRUD, team-scoped APIs, authentication, webhooks, forms, pagination, and async jobs instead of improvising.
- 3
UI vocabulary
SpeedPy UI defines tokens, components, layouts, responsive behavior, and dark mode. New screens have something exact to reuse and compare against.
- 4
Workflow skills and checklists
Bundled skills cover setup, adding an integration API, removing demo content safely, and deploying through Appliku. The production checklist and machine-readable demo manifest define the finish line.
- 5
Tests encode the contract
Billing state, tenant permissions, API schema, OAuth2, CORS, idempotency, request IDs, throttling, webhooks, and UI behavior have existing tests for the agent to run and preserve.
TASK
“Add team-scoped reports.”
CONTEXT
Read architecture and canonical team API.
BUILD
Reuse scopes, permissions, UI, and file layout.
VERIFY
Test isolation, schema, roles, and responsive UI.
Compare the work you inherit
AI makes both paths faster. They are still different paths.
| Decision | Bare Django + AI | SpeedPy + AI |
|---|---|---|
| Architecture | Your prompts gradually invent it. | The layout and extension rules are explicit before generation starts. |
| Cross-cutting flows | Generated separately, then integrated and debugged. | Accounts, teams, billing, API, jobs, and UI already run together. |
| Review burden | Review architecture, integration choices, and implementation at once. | Review product-specific changes against known patterns and contracts. |
| Visual consistency | Depends on every prompt carrying enough design context. | A documented component system and live catalogue give the agent a target. |
| Production cleanup | You create the checklist while discovering what was missed. | Demo manifest, strip workflow, and production checklist ship in the repository. |
Inspect the proof
These screens ship in the repository
Use the live component catalogue to inspect states, responsive behavior, dark mode, and the markup your agent will reuse.
Open the live UI catalogue
Inspect it, run it, change any part
Clone the complete repository. Docker gives you Postgres, Redis, Celery, and media serving; local mode uses uv, SQLite, and eager background tasks.
Prefer a guided setup? Use the beginner-friendly Docker path and starter skill.
Developer questions
Know what you are adopting
Why not start with bare Django and let AI build the rest?+
You can. AI reduces typing time, but you still own every architectural decision, interaction between subsystems, security boundary, generated migration, and test gap. SpeedPy starts after much of that integration work and gives the agent patterns to extend.
Is every included feature mandatory?+
No. The codebase is yours. SpeedPy includes a production checklist, a machine-readable manifest of demo artifacts, and an audit-first removal skill so you can strip examples without deleting reusable infrastructure by accident.
Does “production-ready” mean no review is required?+
No. SpeedPy is a production-oriented foundation, not a substitute for your threat model, product-specific tests, provider configuration, monitoring, or code review. It reduces repeated foundation work and documents the remaining production steps.
Am I locked into Appliku?+
No. SpeedPy runs anywhere Django runs. It includes an Appliku configuration and deployment skill because SpeedPy and Appliku are designed and tested together, making that the supported low-friction path.
What does “free forever” include?+
The entire SpeedPy repository is free under the MIT license. There is no separate paid codebase or feature tier. Appliku is a separate paid deployment service and is how continued SpeedPy development supports the business.
A better first commit
Start with the foundation working
Let your coding agent extend a coherent Django product instead of assembling one subsystem at a time.