Twenty-eight systems, described honestly.

Django 5.2, PostgreSQL and MariaDB, server-rendered, no SPA. Around 120 models across fourteen apps and 170 templates. Deployed to shared hosting under Passenger, with cron rather than Celery because no background process survives there.

Server-side Conversions API with browser-Pixel deduplication on a shared event id, hashed PII, fired on a background thread and failing open. Fiscal-printer drivers with a null-driver degraded mode, so an unreachable device marks a receipt pending instead of blocking the sale. A bearer-token API for an out-of-repo Windows time-tracking client uploading per-minute activity snapshots. A priority-resolved role system - superuser, then group, then clinic-staff record - driving ten different dashboards off one codebase.

Django 5.2, PostgreSQL, Stripe, GrapesJS page builder in the admin. Twenty-five models across four model-bearing apps.

The AI backend sits behind a single normalised result type with three interchangeable implementations - mock, hosted API and self-hosted - selected by one environment variable, so the entire product runs end to end with no AI vendor attached and no code changes. A clinical output pipeline of upload → analysis → findings → treatment plan → line items, each finding carrying its own confidence band. First-touch attribution middleware capturing four ad-platform click ids into a lead-to-paying funnel report.

Django 5.2, MySQL, modeltranslation across three apps, CKEditor 5, GrapesJS landing builder.

An appointment request-to-approval state machine: a visitor request stays pending until staff approve, at which point a patient record is created or matched and a real appointment materialised. Every lead stores its answers twice - as JSON and as individual rows - alongside IP, user agent, referrer, geography and the full UTM and Meta click-id set. Campaign landing pages are mounted outside the language-prefix routing, so paid traffic never lands on a locale redirect.

Django 5.2 with DRF and JWT, PostgreSQL, Celery and Redis, Argon2 hashing, forty-nine local apps. React with Vite and Tailwind on the front, Flutter for mobile. Sentry, gunicorn with gevent.

A recommendation engine that grades seven nervous-system states from a check-in, applies hard eligibility gates, compresses priority into a six-point band so context beats popularity, and then samples by softmax rather than taking the argmax - so the whole catalogue stays reachable instead of collapsing onto the same twenty items. A fourth slot is reserved for discovery and sampled by recency. It runs on raw driver queries rather than the ORM because it executes on every screen. Retrieval is grounded in roughly thirty thousand structured solutions extracted from about ninety-five books, with a prompt that forbids the model from answering out of its own general knowledge and an explicit crisis branch. A Monte Carlo harness runs the real engine over synthetic sessions - fifty thousand check-ins in one run, seventy thousand balanced sessions in another - asserting that no crisis state receives an inappropriate card and that no card is unreachable. It also surfaced a genuine detection gap, which is what a harness is for. Provider choice and every API key resolve from an admin-editable table before falling back to environment, so vendors and keys rotate without a deploy.

Django 5.1, MySQL in production with PostgreSQL and SQLite fallbacks for development, Celery and Redis with an eager fallback, django-axes lockout, Silk profiling, GrapesJS builder. Forty models across six apps.

Payment finalisation is deliberately doubled and idempotent - the same routine runs from the Stripe webhook and from the return page, returning early if the booking is already paid, so a missed webhook cannot lose a paid booking. The channel manager offers no webhook signature scheme, so the endpoint is authenticated by a secret in the URL path, with a test that sets it empty to prove it fails closed. A booking state machine routes confirmed stays onto the direct channel and blocks onto a separate one; the property with no channel id is matched locally by slug instead. Every outbound email is persisted before delivery by a custom mail backend.

Django 5.1, MySQL, Celery with a Redis-optional eager fallback, Unfold admin with a vendored studio, HTMX and Alpine over Tailwind. Around forty models across ten apps. Flutter for both mobile clients, JWT in secure storage.

An in-progress checkout is held as a temporary booking and only promoted to a real one when Stripe confirms the session, so abandoned checkouts never hold inventory. Six distinct fiscal document types share common party and line mixins rather than being one invoice model with a type flag. Guest records reconcile across channels through a canonical-guest layer, with separate individual and company registries, so the same person arriving from an OTA and from a direct booking is one record. Every integration secret resolves from the database first with a sixty-second cache, so keys rotate live.

Django 5.0, MySQL, modeltranslation across eight languages, Tailwind and Alpine from CDN with no build step. Thirty-eight models.

Booking confirmation by six-digit email code, rate-limited per IP with a five-attempt cap, fifteen-minute expiry and a resend cooldown. Signed time-limited tokens give an anonymous guest access to their own booking page for twenty-four hours without an account. Pricing is recomputed server-side on every save from a five-band day-tier table crossed with insurance level, with discount applied to the rental subtotal only - never trusted from the client.

Django 5.1, MySQL, Redis and Celery, DRF with JWT and OpenAPI, Unfold admin, modeltranslation and parler. A React 19 application built with Vite and shipped pre-built. Fourteen apps, seven languages with full translation catalogues.

Lead scoring by language model with web search: form answers, UTMs, click ids, authentication result and do-not-call status are assembled into a dossier and scored into a band with a rationale and a recommended action, using a per-client key. A three-part compliance stack - full scrub with line-type and wireless detection, litigator check, and reassigned-number lookup against a consent date. Tenancy is resolved from the Host header with a five-minute cache, and every form submission is re-checked against the host's client, so a cross-tenant lead is structurally impossible. The form builder stores an HMAC of each verification code rather than the code, and every consent checkbox writes an immutable record of the exact wording, IP and URL.

Django 5.2 with Wagtail, two datastores - PostgreSQL for operational state and ClickHouse as the tracking firehose - Redis, Celery with beat and Flower, DRF plus a hand-rolled JWT layer for mobile. Forty-six models in the core app alone.

Each vendor maps to one of three sub-scores - reachability, authenticity, intent - run in parallel through a thread pool and averaged into a composite grade with admin-tunable weights. Adapters that error or skip drop out of the denominator rather than scoring zero, and any blocking adapter forces the lowest grade outright. The signal set includes behavioural biometrics, TLS fingerprinting, scroll depth and form cadence alongside three language-model sub-signals. Buyer routing filters on credit, working hours, daily and weekly capacity, vertical and geography, then breaks ties on twenty-four-hour load before priority. Every outbound vendor call writes a log row with endpoint, status and response summary, specifically so per-lead vendor cost can be reconciled.

Flutter with Riverpod, Dio and go-router, secure storage for tokens. A companion Django app exposing the admin registry as REST.

Permissions are not reimplemented: the API maps HTTP verbs onto Django's own view, add, change and delete permissions, and list search, paging and ordering come straight from each admin class's own configuration. Adding a model to the Django admin adds it to the mobile app. A sibling buyer app mirrors the web application's fourteen per-client theme sets, reading the active one at sign-in and caching it so there is no cold-start flash of the wrong brand.

Django 5.2 with Wagtail, MySQL, Redis, Celery with beat, Channels and Daphne for WebSockets, DRF with JWT, pandas and numpy, web3 for the crypto rail. Flutter and Dart for the mobile and desktop clients, one lib/ shared across all three. Seventeen configured languages.

Seven independent indicator reads per timeframe, and a timeframe only agrees when at least five of the seven concur - then multi-timeframe confirmation on top, with optional candlestick and news gates and ATR-derived stops and targets. Every pass writes an audit row whether or not it produced a signal, and dry-run is the default. The crypto payment rail holds no private key on the server: a scheduled task watches the chain for transfers to a receiving address, matches pending deposits by amount and confirms after twelve confirmations. Two stacked middlewares make the product unreachable until onboarding is genuinely complete.

Django 4.2, MySQL, Unfold admin with a Chart.js dashboard, modeltranslation across eight languages, Tailwind and Alpine from CDN. Sixty-two models across nine apps, sixty-three tables.

The fulfilment chain is real rather than declarative: waybill generation logs the full request, response and error against the order, and invoicing issues documents and reversals against it. Dual-currency pricing stores a native and a display amount as a pair rather than one amount and a rate, so a historical order does not silently reprice when the exchange rate moves.

Django 4.2, MySQL, Unfold admin, ReportLab with a custom registered typeface for PDF composition. Fifty-five models.

The contract body is a structured legal template that auto-numbers, snapshots the beneficiary's details at signature, and validates that a contract links to a natural person or a company but never both. Offer PDFs are composed room by room - eight room types, each with its own description, price and photographs - as a laid-out document rather than a template fill. Every monetary figure is stored in both currencies as parallel columns.

Django 5.2, MySQL, Unfold admin with custom calendar and timesheet templates. The desktop client is Tkinter - roughly 1,600 lines - packaged with PyInstaller into a single executable and shipped through an installer.

The auto clock-out logic is the interesting part: a session closes at its last heartbeat only once both the scheduled end of day has passed and no heartbeat has arrived for ten minutes - and a later heartbeat carrying an app-alive timestamp can revive a session that a genuine outage closed. That is a distributed-state problem handled properly rather than a nightly cron that guesses.

Laravel 11 with Breeze, MySQL, Blade with Vite, Tailwind and Alpine, DomPDF. Eleven models, eighteen migrations.

Nothing architecturally unusual, and it should not pretend otherwise: it is a small, correct internal tool. The pipeline dashboard aggregating counts by space type and use, size-band distribution and average budget against total and paid proforma value is the substantive piece.

Django 4.2, MySQL, Unfold admin, modeltranslation across ten languages, Tailwind and Alpine. Around thirty models. A companion design-tool plugin outside the Django runtime.

The pipeline takes pasted source, generates architecture and flow diagrams from it, then builds a screens-and-palette specification that a design-tool plugin fetches and draws as real editable frames. It is a small tool, but it removes the least enjoyable hour of starting any project.

Python standard library only. No framework, no dependencies, no build step, around 920 lines. The server is the standard library's own HTTP server with a threaded job queue.

It handles the provider's two-tier authentication correctly - service credentials to mint customer credentials, then customer credentials for generation, cached and reused - and treats generation as genuinely asynchronous, polling each job on its own thread with a timeout. With no credentials configured the UI disables generation and says so, rather than failing at the point of use.

PHP and Laravel 8 with Jetstream and Livewire, MySQL, Blade templates, Laravel Mix building Tailwind, Bootstrap, jQuery, Alpine and Sass. Thirteen models, twenty-nine migrations, thirty-two controllers, Apache on cPanel.

Translation lives in the schema rather than in a package: the post, shop, gallery and menu models each carry four parallel column sets, one per language, and Romanian arrived five years after launch through migrations that widen every one of them. It is a blunter design than a translations table, and it has one real virtue - reading a translated row is the same query as reading an untranslated one, with no join and no fallback logic to get wrong. Worth saying plainly: this is a conventional CRUD monolith on a stack that has aged. What it demonstrates is not cleverness but that it has been quietly maintained for years after handover.

Django 4.2, MariaDB, Jazzmin admin with nested inlines, modeltranslation and Rosetta for in-browser translation editing, Bootstrap and AOS. Thirty models. Four containers: nginx, web, database and a scheduler.

The campaign sender computes how many intervals have elapsed since the start time and sends the next batch of ten recipients, tracking progress and writing a delivery log with a generated message id per recipient - throttling designed to survive a shared mail host rather than assume a delivery provider. An hourly job then polls IMAP, parses bounce notifications and reconciles them back to those delivery logs by message id. Layered anti-abuse underneath: honeypot URL traps that ban a source IP for thirty days, a bad-bot blocklist and per-view rate limits.

Static HTML with Tailwind compiled to a single stylesheet, vanilla JavaScript modules, a single PHP endpoint for the contact form. Apache on shared hosting.

The mail endpoint speaks SMTP directly - opening a TLS socket and performing the authentication handshake itself, with no mail library - because the host offered no usable alternative. Analytics is genuinely consent-first: the tag is not loaded at all until consent is stored, and it additionally honours Do-Not-Track and refuses to run off the production hostname. Right-to-left is handled in the Tailwind source rather than bolted on as a second stylesheet, and every URL declares its language alternates.

Django 4.2, MySQL, Unfold admin, modeltranslation. PayPal called directly over REST rather than through an SDK.

A singleton-model CMS pattern where each of about twenty page sections auto-creates its row on migration, so an editor never opens the admin onto an empty screen and never has to know what a fixture is. All third-party keys live in a database-backed vault rather than environment files, which is the right trade for a client who changes providers more often than they deploy.

Static HTML. No framework, no database, no build step - the correct answer for a catalogue that changes twice a year and must outlive any framework's support window.

Nothing, and that is the point. Not every brief is a system, and a static site the client can host anywhere for a decade is a better outcome here than a CMS nobody will log into.

Django 4.2 with django-unfold, MySQL via PyMySQL, modeltranslation across eight languages, CKEditor for long-form fields, Tailwind and Alpine loaded from a CDN with no build step, Whitenoise, Passenger on cPanel. Thirty-two models across three apps.

Nothing here is difficult, and the entry earns its place by demonstrating the opposite skill: a site whose owner never needs a developer to change a word of it. The honest flaw is visible in the schema - the portfolio model still carries a surface-area and a location field inherited from the real-estate template it was forked from, and roughly a third of the dependency list is carried over and never imported. That is what forking a working project to save a week actually costs, and I would rather show it than tidy it out of the story.

Vue 3 with the Composition API, Vue Router, Vite with manual vendor chunking, Tailwind, GSAP, Lucide icons. Around six thousand three hundred lines across eight routes, one of which is a design-system page. Apache serving the built output.

Twelve animation components, one per service, written rather than pulled from a library, with intersection-observer and count-up composables underneath them. It is craft work and that is the whole of its ambition. It also carries the clearest example I have of a dependency outliving its purpose: reCAPTCHA v3 loads on every page and guards nothing, because there is no form on the site - the contact route is a mailto link, and the validation library installed for the form that was never built is still in the manifest. A third-party script that runs on every page load and does nothing is a consent liability rather than a harmless leftover, and it is on the list to remove.

Solidity 0.8.24 with OpenZeppelin 5.1 pinned exactly, Hardhat and ethers v6, Node 20 for the relayer and the faucet, Terraform and Docker Compose for the validator fleet, a vendored Blockscout stack behind nginx for the explorer, vanilla JavaScript for the dApps and the wallet, Rust and Anchor for the Solana leg. 3,500 lines of original Solidity, 12,000 of JavaScript, 142 contract tests across four suites.

One allocation file is the single source of truth for the hundred million supply, and the build generates the genesis, the per-role compose directories and the deploy scripts from it for devnet, testnet and mainnet alike - so the three networks cannot drift apart. A preflight step refuses to build a mainnet genesis while any placeholder address remains. The faucet reimplements the node client's own WebSocket protocol so the page needs no special case for local networks. The relayer advances its block cursor only after every message in a range is persisted, because advancing first loses transfers permanently and nothing rescans. Supply conservation is a design invariant rather than a check: exactly one chain escrows and every other mints, the token cap equals the genesis supply, and the deploy scripts mint nothing. The OpenZeppelin version is pinned because 5.2 emits an opcode the node's EVM predates - a newer library would produce bytecode its own validators could not execute. The bridge is a trusted-quorum bridge and is described as one in three separate places rather than being called trustless.

Python 3.11 with pandas and numpy, deliberately version-bounded so prebuilt wheels install on shared hosting without a compiler. SQLite for the trade journal, MySQL for export, the standard library's own HTTP server for the dashboard. 18,000 lines across 94 modules and 541 tests.

The language model runs on its own background clock and writes a cache the trading loop reads instantly, because a one-to-three second round trip on five-second bars means acting on a price that no longer exists - and that failure is silent, since the answer still looks sensible. It can emit a bias and two multipliers; it cannot invent a trade, choose a direction, size a position or move a stop, and it fails open to neutral. The learning layer is hand-written logistic regression precisely so it cannot hide overfitting: in-sample and out-of-sample always reported together, time-ordered splits, and a naive take-every-trade baseline printed alongside. Exits trigger on the underlying price rather than option premium, because premium moves on volatility and time decay. The supervisor uses a file lock after two runs seconds apart slipped past a pidfile check and left two bots trading one account.

Django 4.2, django-unfold, MySQL, modeltranslation across ten languages, CKEditor, Tailwind and Alpine from a CDN, Passenger on cPanel. Thirty models across three apps, plus a companion Figma plugin.

The Figma generator builds its node tree deterministically - frames, rectangles and text laid out by code - and only then offers an optional model pass to beautify it. That order is the whole design: the same project always produces the same layout, and the model can improve the result but is never the reason it exists. The plugin fetches its spec through a signed admin URL, so the Figma desktop app can pull a design without holding a session. Two gaps I will not pretend are finished: the push side of the Figma integration is still a stub, and the OpenAI client is imported without being pinned, so a clean install of that panel fails until it is added.

Python 3.11 and Django 5.2 LTS, django-unfold, MySQL via PyMySQL, Redis, Celery with beat, results and Flower, Strawberry GraphQL with the Django optimizer extension, modeltranslation, Silk in development only, React 18 and Vite for the front-end island. Ten apps, thirty-three models, roughly eight thousand two hundred lines of Python.

Conversion tracking fires twice on purpose: the browser pixel and the server-side API send the same event under the same event id, so the platform de-duplicates them, and the events that blockers would otherwise remove - commonly a fifth to two-fifths of them - survive. Personal fields are hashed before they leave, and a tracking failure is swallowed rather than raised, because a lead is worth more than a perfectly reported one. The form engine is nine models and twelve question kinds over a five-state funnel with an event audit trail; its public endpoints are deliberately exempt from CSRF, because the markup is authored in the admin and served verbatim, and an unguessable server-issued session id does the work the token would have done. Every version constraint in the requirements file carries the reason it exists, including the ones I would rather not need. The weak spot is coverage: twenty-three smoke tests against eight thousand lines, which is not enough and I know it.