I’m currently working on a project called “Membership Anywhere”, where I’m building a system to generate digital membership cards with QR codes for users.
The idea is to:
Dynamically generate membership cards (PDF/image with QR)
Store them on a TrueNAS system
Allow secure access and printing from multiple devices
I’m facing a few challenges and would love some guidance:
What’s the best way to store and manage these generated files on TrueNAS?
Should I use SMB shares, Nextcloud, or any specific app/plugin for access control?
Any recommended workflow for handling bulk card generation + sharing securely?
Best way to handle print access across network devices?
If anyone has worked on a similar setup (file generation + NAS storage + user access), I’d really appreciate your suggestions.
That’s really going to depend on the form your project takes and how you’re going to deploy it, and really doesn’t have much at all to do with TrueNAS itself:
If you’re going to deploy it as a Docker container, mount a dataset to that container as a host path, and store your data there (in whatever form it takes, on which, more below).
If you’re going to put it in a VM, and it’s just a small amount of data, you could just store it in the VM’s virtual disk.
If it’s a larger amount of data, or you want the VM to be relatively disposable, share a dataset using whichever file-sharing protocol you or the guest OS prefer, and mount that to the VM. Tell your software to store the data there.
How to store the data? Again, lots of options, including:
For a relatively small number of users, flat-file may be the simplest option–just store the digital membership cards on disk in whatever file format you prefer (PNG, PDF, BMP, etc.), and retrieve them as necessary to print.
For a larger number of users, some kind of database system is probably a better plan. Again, there’s a range here; smaller installations could use a SQLite database; larger installations will probably call for a full RDBMS (MariaDB, PostgreSQL, MS-SQL, etc.). The idea here is that the member data (name, expiration date, member number, whatever else is relevant) would be stored in the database, and your application would generate the “card” dynamically as needed. At some point, this will be more space-efficient than storing the cards as flat files, and it will almost certainly be more performant.
Isn’t that what you’re writing software to do (I’m assuming that what you mean by “working on a project”)? Neither of these questions has anything at all to do with TrueNAS; they’d entirely be handled by the software you’re writing or implementing.
Now, without having looked yet, I’m pretty confident that there’s software already out there that could handle this for you. Let’s see what the AI has to say, given this prompt:
please recommend a few options for a self-hosted membership management system. It should be deployable via Docker, and allow members to log in and print membership cards with barcodes or QR codes containing membership information.
AI response
You’ll probably get the smoothest experience by pairing a membership-focused app with a generic barcode/QR generator, but there are a couple of projects that already cover most of what you want and are Docker‑friendly. portalzine
Option 1: MemberMatters
MemberMatters is an open‑source membership, billing, and access‑control portal built for makerspaces and community groups, shipped as an official Docker image (AMD64 and ARM64). Members can register, log in, manage their profile, and it handles recurring payments, access permissions, and integrates with hardware (RFID, doors, tool interlocks). You’d likely add a small custom view or report that renders a printable “card” page with a QR or barcode generated server‑side, then let members print that from their portal profile.
For your stack, this is probably the best starting point: it’s already designed for physical spaces, and the data you’d put in the QR (member ID, expiry, access level) is already modeled in the system. You’d just bolt on a QR/barcode component in the Django/Vue codebase and expose it behind your existing Caddy/Docker‑proxy setup.
Option 2: Zenbership
Zenbership is an older open‑source membership CRM with subscriptions, invoicing, events, and a full member portal. It’s PHP/MySQL and not actively maintained (no updates since 2018), but it is still downloadable and designed as a general membership hub. You could containerize it yourself (PHP‑FPM + Nginx + MariaDB) and then add a module/template for printable cards with embedded QR or barcodes tied to member records.
The trade‑off here is more work and technical debt versus flexibility: as an unmaintained project you’d be on the hook for security hardening, modern PHP versions, and any custom card/QR logic you add, but you’d gain a very customizable CRM‑style system.
Option 3: Membership app + QR generator combo
If you’re fine composing your own solution, you can combine:
A self‑hostable membership/CRM app that runs in Docker (for example, MemberMatters with billing and access control features enabled).
A self‑hosted QR/Barcode generator container (e.g., generic QR code generators like those surveyed in Docker‑ready QR services, or a small Python/Node microservice that takes member ID and returns PNG/SVG). portalzine
Members would log in to the main portal, hit “View/Print Card,” and that page would call the QR service (or render via a JS library) and show a printable card layout. From your perspective this keeps the membership logic, auth, and payments in a mature app while treating QR/barcode as a stateless sidecar service. portalzine
Quick recommendation
Given your Docker and reverse‑proxy setup, I’d start by:
Standing up MemberMatters via its official Docker image and wiring it through Caddy.
Implementing a simple “Membership Card” view that renders a QR containing a member’s UUID or numeric ID plus an HMAC (for tamper‑resistance), and styling it to a printable credit‑card format.
If you like, offloading QR generation to a tiny dedicated container or doing it in‑app with a QR library.
If you want, I can sketch a sample docker-compose.yml plus a proposed data format for the QR payload and how you’d validate it at the door/check‑in.
Thanks everyone for the suggestions so far really helpful. I did a bit more digging and I’m currently leaning toward a hybrid approach:
A. Use SMB on TrueNAS for storage, but avoid exposing it directly to users
B. Handle access through the .NET API layer, where I can control authentication and generate secure, time-limited links for each digital membership card
For bulk generation, I’m thinking of using a background worker (maybe a queue-based system) to generate and store cards asynchronously instead of doing everything in real-time.
Best way to handle printing across devices
trigger downloads and let clients print
or try some centralized print service
Would love to hear how others have handled the print side of things, especially in multi-device environments.
