Capability reference
Print Studio is a hosted client platform built on a print-first design engine. An admin spins up client accounts — each with its own users, roles, template access, and quotas — and every client gets an Order page, a Projects workspace, and the full studio editor. This page walks through the whole product, from the multi-tenant controls down to the CMYK render pipeline. Several sections include a live demo you can play with.
01 — Client platform
Print Studio is multi-tenant. A super-admin creates a client account for each customer or team, and everything that client does — designs, orders, members, usage — is scoped to that account. Nobody sees anyone else's work.
Each client lives in its own account with its own users, template access, and quotas. Jobs and stored designs carry the account ID, and every list view — orders, projects, usage — is filtered to the signed-in account. There is no shared bucket of data to leak across.
Clients log in with a username and password and get a signed ps_session cookie. The middleware verifies it at the edge; API routes re-check it against the auth store on every call. First login forces a password change from the admin-issued temporary one.
The env-var super-admin runs everything from /dashboard/accounts: create accounts, set permissions and quotas, curate template access, add or suspend users, and watch per-account usage — all from one place.
02 — Accounts & roles
Within an account, every user has a role and a precise set of permissions. Owners run the team; members do the work. Access is decided per action — creating an order, editing in the studio, exporting a PDF, deleting a design, managing people — so each client gets exactly the surface they should have.
Permissions are fine-grained: order:create, studio:edit, pdf:export, designs:delete, and users:manage. A user’s effective set is the intersection of their role and what the account permits — so the admin can dial access up or down per account.
Try it
Create orders
Submit jobs from the Order page
Edit in Studio
Open and save designs in the canvas
Export PDF
Render and download print-ready files
Delete designs
Remove stored projects
Manage team
Invite and configure members
Effective permissions are the intersection of the member’s role and what the account allows — pick a role to see what unlocks.
Owners hold the users:manage permission and can invite members, set each one’s permissions, reset passwords, and remove people — all from inside their own account, no admin ticket required. Members focus on designing and ordering.
Templates stay global, but each account’s templateAccess is either all or an explicit allowlist of template IDs. A client only sees — and can only order from — the templates you’ve granted them, enforced server-side on every template route.
03 — Quotas & rate limiting
Every account has caps — renders per month, a per-minute burst ceiling, and a maximum number of stored designs. They keep one busy client from starving the render queue, and they give the admin a clean lever for plan tiers.
Each account gets a monthly render allowance and a per-minute burst limit, tracked in Redis. When a client hits the cap, the order returns 429 with { code: "QUOTA_EXCEEDED" } and the limit, usage, and reset time — so the UI can explain exactly what’s happening instead of just failing.
Try it
Renders this month. At the cap, the API returns 429 QUOTA_EXCEEDED until the monthly reset.
Accounts also have a ceiling on saved projects. Past it, saving returns 409 DESIGN_LIMIT_REACHED — the client clears space or the admin raises the cap. Login attempts are throttled per username on the same Redis backing.
Both the client and the admin can see live usage: GET /api/me returns the session, permissions, and current usage, and the admin’s per-account usage view shows where each tenant sits against its limits. Rate limiting fails open if Redis is unreachable, so an outage never blocks a legitimate order.
04 — Client workspace
A client never touches infrastructure. They get three surfaces — an Order page to produce print-ready PDFs from a form, a Projects workspace for their designs and shared templates, and the full studio editor — plus team controls if they're an owner.
The fastest path to a finished file: pick a template the account has access to, fill in the auto-generated form, submit, and watch the job stream to a print-ready PDF. No canvas knowledge needed — it’s a form in, a PDF out.
Every client has a Projects view that gathers their own saved designs alongside the templates they’ve been granted. Designs are stored in a per-account index with their PSTs in the account’s own storage prefix — reopen, duplicate, or (with permission) delete them from one place.
Clients aren’t limited to forms. With studio:edit, they open the same canvas editor described below, save designs back to their account, and — with pdf:export — render print-ready output directly.
Owners manage their own roster: invite members, grant or revoke individual permissions, reset a member’s password, and remove people who leave — without ever contacting the platform admin.
Members can change their own password from /api/auth/change-password, and a forced reset on first login means admin-issued temporary credentials never linger. Revoking a session is a single sessionVersion bump.
05 — The studio
The studio is where templates and designs are built. The canvas is page-aware — it knows the paper size, bleed, and safe zones — and everything you place on it is laid out as if it were already on the press.
Every template is built at 300 DPI on a page-sized canvas (A4, Letter, or any custom size you configure). Bleed and safe-zone guides are drawn on the canvas, so designers don’t need to remember to leave room — the boundaries are visible as they work.
The viewport zooms and pans like you’d expect. Undo and redo are unlimited inside a session.
The Layers panel shows everything on the canvas as a tree. Layers can be renamed, locked, duplicated, hidden, or grouped. Right-click any layer for the full set of actions.
Groups have a dedicated edit mode — double-click in to tweak a child without losing the group’s overall position. Clip masks are first-class: any group can be turned into a mask so a photo can be cropped to a circle, a logo shape, or any custom path.
Full text editing on canvas. Pick from a curated set of typefaces (Inter, Outfit, Anton, Playfair, Roboto, and the rest of the loaded library) and adjust weight, size, line height, and tracking inline.
The color picker is CMYK-aware — the value you set is the value that ends up on the printed page. You can also bind any text’s color to a palette role (primary, secondary, tertiary) so it picks up whatever color is chosen at order time.
Drop an image on the canvas, drag the corner handles to resize, or replace it with another in one click. The interactive crop mode (Adobe Illustrator style) dims the rest of the canvas and gives you a draggable overlay that crops without resampling.
Each image field has a fit mode (cover, contain, fill, none) and a 9-point anchor — top-left, center, bottom-right, etc. — so when a different photo is swapped in at order time, it always crops to a sensible area. The demo below uses a 4:3 sample image inside a square frame so you can see each combination.
Try it
Fit
Anchor
The image is 4:3 inside a square frame. Switch fit + anchor to see how a swapped photo will crop at order time.
Rectangles, circles, lines, polygons, and arbitrary paths. Each shape has an independent fill and stroke, both with the same CMYK-aware color picker as text. Shapes can also be bound to palette roles for order-time recoloring.
When you drag a layer, the canvas snaps to the visual edges of nearby layers. Text snaps by glyph bounds — meaning two stacked names line up by their visible letters, not by their invisible textbox borders. Same with logos that have whitespace baked into the file.
06 — Layout tools
A template is only as useful as the way it adapts. These tools let designers describe how the layout should behave, not just how it looks once — so a template still composes correctly when names get longer or photos change shape.
Magic Align records a recipe of alignments — for example, “the logo’s right edge stays aligned to the title’s right edge.” Once recorded, the recipe replays automatically every time the template is rendered.
The result: even when the title text is replaced with something longer or shorter, the logo follows. No manual realigning per order.
Try it
Compose Card is a small pipeline a designer can attach to a stack of layers. It runs a sequence — trim empty space, group, distribute (either fixed gap or auto-spaced to fill), align, and offset by a chosen edge distance.
Use it for stacked text blocks where the line lengths vary by order: addresses, multi-line names, contact details. The stack stays evenly spaced no matter what gets typed in.
Double-click a group to enter edit mode. You can move, resize, or restyle child layers while the group’s overall transform stays intact. Click outside to exit. It’s the same model used by Illustrator and Figma — designers don’t need to learn anything new.
Mark any text field as Magic Text and it will shrink its font and width at render time to fit whatever string was supplied — within designer-set limits. Names that wouldn’t otherwise fit get a smaller font; short names stay at full size. No manual per-order adjustment.
07 — Dynamic fields
Any layer in the studio can be marked as a dynamic field. That tells the system: when this template is ordered, this layer should be replaced. The collection of all tagged layers becomes the template's order form.
Select any layer in the studio and give it a tag — usually something descriptive like name, phone, headshot, or logo. The tag is the handle the order form uses.
Text, image, and shape layers can all be tagged. The tag panel shows everything that’s tagged in the current template at a glance.
Shapes and text can be assigned a palette role: primary, secondary, or tertiary. When the template is ordered, the chosen brand palette flows into every layer that uses that role.
One palette change per order, not a per-layer recolor. And because roles are assigned at design time, a designer can guarantee the brand colors land in the right places.
Each image field carries its own fit mode and anchor. So if “headshot” is set to cover, top-center, every photo swapped in at order time will crop the same way — heads stay above the fold, no awkward chins or foreheads.
As you tag layers, the studio maintains a manifest of every dynamic field — the tag, the type (text / image / color / shape), the constraints (max length, image fit, palette role). This manifest is what the order form reads to decide which inputs to show.
Designers don’t build forms. The form is the manifest, rendered.
08 — Templates
Templates are saved as .pst files — a single portable format that bundles the canvas, every embedded image, the dynamic-field manifest, and a thumbnail. One file = a complete, self-contained template.
A .pst is a single archive containing the canvas as JSON, every embedded image asset, the dynamic-field manifest, the page configuration (size, color profile, bleed), and a thumbnail. Nothing is referenced by external URL — the file is portable on its own.
The studio has Save and Load buttons that work directly with the .pst format. Save uploads the file to cloud storage; Load pulls it back down and reconstructs the canvas exactly as it was — same layers, same tags, same recipes.
Templates can also be downloaded and re-uploaded between environments — useful for moving work between staging and production.
Templates live in AWS S3 object storage. They’re accessible from any session, and the bucket retains previous object versions when a save overwrites a template — so an earlier state can be recovered from storage if it’s ever needed.
09 — Ordering
Once a template has been designed and tagged, the order form is generated automatically. This is where most non-design users spend their time — picking a template, filling in a form, and getting a print-ready PDF back.
Open any template’s order page and you get a form with one input per dynamic field. The fields appear in front-first layer order — the same order you see them stacked on the design — so the form mirrors what the eye sees on the canvas, not whatever order they were created in.
Each input matches its field type: text fields take a string and a color picker, image fields accept a URL (with size and format validation), shape fields get separate fill and stroke pickers.
Drop a brand logo URL into the order form and the system extracts the dominant colors and pre-fills every palette role. The operator can still tweak the result, but the starting point is one click — the brand’s actual colors, lifted straight off the logo.
Every successful order delivers three things:
After submitting, the order page shows the job moving through stages — queued, building the layout, rendering the PDF, converting color, done. No need to refresh; updates stream in as they happen.
Try it
10 — Print accuracy
The hard part of any print tool is making sure the colors on screen end up the same colors on paper. Print Studio takes color management seriously — and verifies the output before delivery.
When a template is set to a CMYK color profile, the final PDF is converted with a real ICC profile (USWebCoatedSWOP by default) — not just an RGB file labeled as CMYK. The ink values in the file match the values the designer chose on screen.
Designers can set explicit CMYK values on individual elements — for example, a rich black at 60/40/40/100 — and those values survive the entire pipeline. They’re tracked as “CMYK intents” and applied verbatim in the final PDF, not regenerated from RGB.
The canvas works in logical units (so designers can move things in pixels), but the renderer scales everything to 300 DPI before producing the PDF. Vector shapes stay vector; rasterized output is at the resolution a press needs.
Before any PDF is delivered, the system inspects it to confirm it actually shipped CMYK (or RGB, depending on the template setting). Files that fail the check are flagged rather than handed off — so a press-bound order doesn’t silently ship in the wrong color space.
11 — Tracking
Orders aren't fire-and-forget. Operators can watch jobs run, see what's happened recently, and intervene when something doesn't go to plan. And orders that never finish at all aren't lost either — the next section covers how they become leads.
Every order page shows live status as the job moves through the pipeline: queued, template loaded, layout built, PDF rendered, color converted, done. The percentage ticks up as each stage completes.
The dashboard gives the team a system-wide view: how many jobs are active right now, what’s queued, which jobs failed and why, and how the template cache is performing.
It’s where someone running operations would start their day to see if anything needs attention.
Every job is logged with its inputs and outputs, including failures. If something fails — bad image URL, transient network error, missing asset — operators can fix the underlying issue and retry the job from its history entry without re-entering the form.
12 — Lead capture
Plenty of customers start an order and walk away — the tab closes, a render fails, a quota bites. Lead capture turns those half-finished forms into CRM leads with a one-click way back, instead of letting them vanish. It ships switched off; the admin flips it on from the dashboard.
As a customer fills in the order form — on the client Order page or inside a partner embed — the platform quietly autosaves a sanitized snapshot of their progress as a draft. The same browser picks the draft back up automatically on return.
Capture is deliberately best-effort: it’s rate-limited, size-capped, and fail-open, so a busy queue or even a storage outage never slows down or blocks the order itself.
A background sweeper marks drafts abandoned after a configurable idle window, and failed submissions are tracked with the reason attached — the form reports validation and quota errors, and the render pipeline reports jobs that didn’t make it. Both flow into Zoho CRM as leads, so sales sees who almost ordered and why they stopped.
If the customer later completes the order, the lead is updated to recovered — the funnel knows the save worked.
Every draft has a resume link at /resume/{draftId} that drops the customer straight back into their half-finished order — fields, palette, and logo intact. Send it from Zoho as a follow-up and the customer continues where they left off; partner-embed drafts reopen inside the partner’s branded embed.
The admin runs the whole feature from /dashboard/leads: a live started → submitted / abandoned / failed / recovered funnel, per-draft detail, manual re-push to Zoho, and one-click deletion that fully erases a draft’s personal data. The enable switch, idle window, Zoho module, and retention period all live here too.
13 — Storage
Every PDF, every snapshot, and every thumbnail lands in a known location. Nothing is ephemeral — finished work stays available.
Final PDFs are uploaded to an AWS S3 bucket organized by job ID and date. Each finished output gets a stable public URL that can be shared, downloaded, or piped into a downstream system without going back through Print Studio.
Alongside each PDF, the system also saves an editable .pst of exactly what was rendered. That means any finished card can be reopened in the studio later — to tweak a color, fix a typo, or use it as the basis for a new design — without starting over.
A small WebP preview is saved with each output, sized for fast scanning in lists. Useful for picking a recent order out of a history view at a glance, without needing to open the full PDF.
14 — Programmatic ordering
If orders need to be submitted from somewhere else — a CRM, a spreadsheet, a partner system — there's a programmatic endpoint that runs through the same pipeline as the order form.
The endpoint at /api/process accepts a template ID, a set of field values, and any image assets. It validates the inputs, queues the job, and returns a job ID. From there, the same progress stream and same outputs (PDF, thumbnail, .pst) are available as for a manually-placed order.
Authentication is a single scoped bearer token held by the calling system — tokens carry permissions like render, templates:read, and jobs:read. Full request and response shapes are documented at /api-doc.
The platform itself is API-driven too: sessions go through /api/auth, a client reads its own session, permissions, and usage from /api/me, designs are managed at /api/designs, order drafts are captured at /api/drafts, and the admin drives everything under /api/admin/accounts and /api/admin/drafts.
15 — Approach
Most design tools you've used are screen-first. Print Studio is built on a different premise — the file is going to ink on paper. That changes which tradeoffs are worth making.
What they’re good at: getting one design out the door fast, mostly for screens — social posts, decks, web graphics. The default color space is RGB, fonts are presets, and exports prioritize file size and screen rendering.
“Print-ready” usually means a PDF with bleed marks. That’s enough for a one-off poster; it isn’t enough for a production line that ships the same template hundreds of times with different content.
Built around the premise that templates are reusable production assets, not one-off designs. The defining features — color management, CMYK rendering, dynamic fields, output verification, an editable snapshot per order — exist because the work ends up on paper, where mistakes are expensive to fix.
Designers spend more time setting a template up properly. In return, every order that follows is a form fill, not a redesign.