Apr 07, 2026 · by Tim Kamanin
A few years back, a healthcare professional association reached out to me. They regulate and support thousands of practitioners across their region: licensing, insurance, events, the whole deal. Their website couldn't keep up.
What they needed was a platform that could handle member applications, renewals, payments, event registrations, an online shop, insurance tracking, exam management, and a public-facing content site. All under one roof. And they didn't want a team of specialists passing tickets around. They wanted one developer who could hold the whole thing and move fast.
That developer turned out to be me.
I built a full membership management platform on top of Django and Wagtail CMS. It handles the entire member lifecycle: from the moment someone applies to join, through annual renewals, insurance verification, and everything in between.
Here's what's running in production right now.
Memberships with status tracking. Members move through states (active, lapsed, expired, resigned) and the system handles transitions automatically. When a membership expires, the platform knows. When their insurance is about to lapse, it sends reminders. None of this requires someone in the office clicking buttons. The state machine handles it.
Members manage their own practitioner profiles, which feed into a public directory searchable by location, specialization, and language. There's also a job board where employers post positions and members browse opportunities. Listings go through a moderation workflow before going live, and only logged-in members can see them.
Events. The association runs conferences, workshops, and training sessions throughout the year. Non-technical staff create and manage events through the CMS themselves, with ticket sales, variant pricing, waitlists that auto-promote when spots open up, and temporary ticket reservations so people don't lose their spot while filling out payment forms. Events can also track attendance automatically.
Exams. Members need to pass professional exams, so there's a question bank organized by category, timed exam sessions, score calculation, and history tracking. Staff can configure exam templates (how many questions from each category, time limits) without touching code.
E-commerce. Products, variants, dynamic pricing rules, discount codes, shopping cart with expiry, order tracking, Stripe for payments. It's not bolted on as an afterthought. When a member renews, the cart knows their membership type and adjusts pricing accordingly.
The insurance integration was one of the trickier pieces. The platform syncs member data with an external underwriting API in near real-time. Dedicated sync queues process updates every minute, handling edge cases like email changes, membership lapses, and renewal timing. If something fails, it retries. If it keeps failing, it alerts.
For communication, the platform sends emails through Mailgun, SMS through Twilio, and manages newsletter subscriptions through MailChimp, including webhook handling for unsubscribes on the MailChimp side. There's an internal email template system with scheduled sending, so the office can queue up renewal reminders, event announcements, and follow-ups without waiting for me.
The public-facing website runs on Wagtail with custom page types and content blocks: hero sections, accordion FAQs, multi-column layouts, news feeds, tables. Staff publish and update content themselves. No tickets to me for text changes.
The platform runs over twenty automated background jobs. Some fire every minute: processing event queues, ticket reservations, syncing data with external providers. Others run hourly: checking for lapsed memberships, cleaning up abandoned carts, canceling unpaid orders. Daily jobs send renewal reminders, nudge applicants who haven't completed their registration, and clean up stale applications.
The association's office is small. Nobody is manually checking "did everyone renew?" or "are the insurance records up to date?" The system handles all of that.
The platform is built with Wagtail CMS that was a natural fit here. Because Wagtail is built on Django, the CMS isn't a separate system bolted onto the platform — it's part of it. The CMS pages and the business logic (memberships, payments, exams) all live in the same Django project, sharing the same database and ORM. When a content page needs to pull member data or display event listings, it's a queryset away, not an API call. Staff manage events, news, and page content through Wagtail's admin, but they also manage exams, email campaigns, and product listings through custom admin panels that sit right next to it. One admin interface, one login, one codebase. No syncing data between "the website" and "the app" because they're the same thing.
The rest of the stack: PostgreSQL and Redis for storage, Celery for background processing, server-rendered Django templates with Vite for asset bundling. Deployed via Docker with a multi-stage build (Python deps, then Node assets, then a minimal runtime image), behind Nginx and Gunicorn.
It's a Django monolith, and I mean that as a strength. Everything lives in one codebase, one deployment, one database. When the event system needs to check a member's status before applying a discount, it's a function call, not an API request to another service. When insurance data changes, the membership module knows immediately. For a platform this interconnected, a monolith is the right call.
The codebase is split into around twenty focused modules, each one handling a specific domain (memberships, events, exams, shop, insurance, communications, and so on). They share a common foundation of base models and utilities, but each module owns its own logic. Keeps things maintainable even as the platform has grown.
The frontend follows the same keep-it-simple principle: Web Components and custom CSS, no fancy JavaScript framework. The pages load fast and there's nothing to upgrade when React decides to reinvent itself.
I built this from scratch and I'm still the only developer. The arrangement works, so it stuck.
Over six years, the platform evolved from a basic membership site into everything I just described. Features were added when the association actually needed them: first memberships and content, then events, then the shop, then exams, then the insurance integration. Nothing was built for a hypothetical roadmap.
Being the sole developer for this long means I know every line of code, every business rule, every edge case. When the client says "we need to change how renewal reminders work for members who have insurance but haven't renewed yet," I don't need a week of onboarding. I already know which cron job handles it, which email template it uses, and what side effects to watch for.
The codebase stays clean too. No archaeological dig through five different coding styles. When something needs refactoring, I refactor it, because I'll be the one maintaining it next year.
I build platforms from scratch and then I stay. I maintain them, improve them, year after year. My clients don't churn through developers and they don't lose institutional knowledge every time a contract ends.
This project alone touches membership management, e-commerce, insurance APIs, exam systems, event ticketing, CMS, email/SMS automation, and background job orchestration. All one person.
I work primarily with Django and Wagtail CMS, and I'm comfortable across the full stack: codebase and database design, background job architecture, frontend templates, deployment pipelines, and AI integrations.
If you're looking for a developer who can own your platform — not just build features, but truly own it — let's talk.
Hey, if you've found this useful, please share the post to help other folks find it: