Pottery Studio Management Software

Pottery studio software that follows every piece from wet clay to pickup.

Your studio runs on a clipboard by the kiln, a shelf chart on the wall, and whoever remembers which pieces are in which load. We turn the piece journey into one record every member can read, so the queue stays honest and the front counter stops answering the same question all week.

See our work

Bring one stuck piece flow. Leave with a buy, repair, build, or wait recommendation.

Trusted by

Perceptional logoMusgrave GroupUrShipper logoBrux Dental SolutionsBella Skin Institute LogoEnergia RewardsDraftly logoTuneClub LogoSekou LMS logoLogo of food order management app gulaSnelwegDealsGrubly logoPSi logoInstantor Rewards logologo of Mobile app for events, membership clubs, and communitiesAldiFest retail campaign logoVidmattic logoEMS Connect logoWorx Squad logologo of Online Web App For Making Intrologo of Referral and Viral Marketing PlatformConcurrences logoGE logoTicketstop logo

The brief

Start with what is not working.

Good software decisions begin with the constraint, not a list of features or a preferred technology.

01

The kiln queue lives on a clipboard, and the clipboard stops matching the shelves by Tuesday.

02

Members keep asking when their pieces are ready, and every answer interrupts something else.

03

Firing fees get worked out by hand, piece by piece, and the tab never quite adds up.

Plain answer

Pottery studio management software keeps every piece in one record, from wet clay on the shelf to the finished work at pickup. It tracks the piece, its bisque and glaze firings, the firing fee, the shelf it sits on, and the date it is ready, and it lets members check that status themselves instead of asking staff.

What to remember

  • Use this when members keep asking where their pieces are and the paper queue by the kiln is no longer the source of truth.
  • One piece file should carry the member, the stage, the load, the firing fee, the shelf, and the pickup date, so staff and members see the same piece.
  • Quote the studio's own screens as their own scope: piece intake, the kiln queue, shelf assignments, firing fees, and the member tab are a second product, not a single admin-panel line.
  • Buy a maintained studio product when it handles your piece flow with reasonable setup; build custom when your firing rules, fees, or member portal need to work your way.
  • Firing fees should follow one rule the whole studio can explain: by size, by weight, or by shelf space, applied the same way to every piece.

The first decision is not what to build.

It is whether software is the right answer at all. We use four possible recommendations before discussing a development scope.

  • 01

    Buy

    Choose a maintained product when it handles the piece flow and the remaining gaps can be solved with configuration, a connector, or a small process change. Paying for software you do not have to maintain is often the better trade.

    Run the build-vs-buy numbers

  • 02

    Repair

    Keep the existing product when members still get value from it and the code can be understood safely. Start with evidence: where the code lives, how the data is organized, what is tested, which outside services it depends on, who can access what, and how updates go live.

  • 03

    Build

    Own the system when the piece flow shapes margin, member experience, speed, or a service members pay for. Start with one complete path and the system connections that path cannot work without.

  • 04

    Wait

    Do not turn a changing studio policy into permanent software. Stabilise the rules, name the piece-flow owner, and measure the cost of the current process before paying for a product.

Not sure which path is yours? Bring it to a 30-minute call. Leave with the answer in writing.

Fit

Studio software should earn its maintenance burden.

A feature request is not enough. The case is real when the same constraint shows up in time, errors, margin, or member experience.

A fit

A repeatable piece flow crosses the shelf, the kiln, and the till, and creates measurable delay, error, or labour.

The studio can name a piece-flow owner and what 'done' looks like for the first release.

Members ask the same firing question often enough that answering it has become part of the job.

Not a fit

A maintained studio product fits with reasonable configuration and process change.

The team wants software to settle an unresolved studio policy, such as who pays for breakage.

The brief is a feature list with no member, piece, or business result attached.

Not sure which side you are on? Use the first call to make that decision. A useful answer may be to buy, connect, repair, or wait.

Start with the shelf, not the software.

A pottery studio problem usually starts as a shelf problem. Staff log the same piece twice. Members wait for someone to move work forward. One person remembers every exception. The key question is whether that friction repeats, can be measured, and costs enough to justify owning the fix.

Take a community studio that uses a sign-up sheet, a spreadsheet, email, and a billing system for one member. The visible complaint may be "we need a dashboard." The real cost may sit elsewhere. No one can see what is in the kiln. Staff apply firing rules in different ways. Members only get an update after they ask.

A second product hides inside the first. Members see one screen; your team lives in another: piece intake, the kiln queue, shelf assignments, firing fees, managing members, and a record of who did what. Quotes that squeeze all of that into an "admin panel" line item are where budgets most often break. On a real platform, your team's screens are routinely the most underestimated part of the build, so we quote them as their own job, with their own users, from the start.

Pottery studio management software makes sense when one owned system can remove that constraint better than a product, connector, or process change. The first release should take the smallest useful path from trigger to result. It should not replace every tool at once.

We start where it hurts.

The interface is only one part of the job. The real scope includes the rules, the data, the connections to your other systems, what happens when things fail, who can see and change what, and who runs it after release.

The kiln queue lives on a clipboard

The clipboard by the kiln stops matching the shelves by Tuesday. Loads get written down twice or not at all, and nobody can say with confidence which pieces are in the kiln right now.

Members keep asking where their pieces are

Every firing-status question arrives at the counter, by email, or by message, and each one interrupts something else. Members have no way to check for themselves, so they ask a person instead.

Firing fees get worked out by hand

Each piece is measured, priced, and added to a tab by hand, and the tab never quite adds up. Members see the charge late, or not at all, and the studio chases money it already earned.

Shelves with no owner and no end date

Two members share one bay, or a shelf still holds work from someone who left months ago. It sours the room fast, and the studio has no list to clear from, only a walk around the shelves.

Memberships, classes, and firing charges live in different places

The member record sits in one tool, the class roster in another, and the firing tab on paper. Nobody sees the whole member, so renewals, wheel time, and charges drift apart.

Which one is yours?

Bring it to a 30-minute call. Leave with a buy, repair, build, or wait recommendation in writing. Free, whether or not we ever work together.

The piece journey

One record follows the piece.

The same record carries the piece from the shelf to the kiln to the pickup table. Each stage below is one job the software does, not a separate system.

Intake

One file per piece at the door: the member, a photo, the clay, the size or weight, and the shelf it sits on. A piece with no record is a piece nobody can find, so intake is the step that makes the rest of the system work.

Bisque

Pieces are ticked into a bisque load with the cone and the target unload date. The load list shows how full the kiln is, so the studio can say honestly why a piece waits for the next firing instead of guessing.

Glaze

Glazed pieces move into a glaze load the same way, with the glaze noted on the record. The queue shows which pieces are glazed and waiting, and which are still drying, so nothing goes in the kiln wet.

Pickup

When a load is unloaded, the piece moves to the ready shelf and the member gets a message that their work is cool and ready to collect. Unclaimed work follows the studio's written pickup deadline, not whoever remembers to chase it.

Billing

Clay, glaze, and firing charges post to the member's running tab from the piece record and settle with the next membership charge. The member sees the charge before the firing, and the studio stops working out fees by hand at the counter.

Proof

The fifth attempt became a product customers could keep using.

UrShipper had already worked with four development vendors. Its founder describes the communication and decisions during the recovery.

The case study documents a 14-week recovery, five carrier connections, a Shopify fulfilment workflow, and client-reported results. It is one comparable project, not a promise that every inherited codebase can follow the same plan.

Read the UrShipper case study

Which piece flow is costing you the most right now?

Bring it to a 30-minute call. Leave with a buy, repair, build, or wait recommendation in writing. Free, whether or not we ever work together.

Let the work pick the shape.

The way people work should decide the form of studio software. Start with where the member checks status, which device staff carry on the floor, whether the signal drops near the kiln, what data they need, and how fast the system must respond. Those facts tell us what belongs in the first release.

One product may need several surfaces. Each one should support the same complete piece flow, not start another feature list.

How it works

Close one expensive risk before opening the next.

Each stage answers a buyer question and leaves behind a decision you can inspect. The next stage only opens when the expensive uncertainty in the current one is small enough to accept.

  1. 01
    Understand

    Trace the real piece flow

    Where is the cost or failure actually coming from?

    Follow one piece and one member from intake to pickup. Include the workarounds, manual judgement, duplicate entry, waiting, and failure paths that a tidy process diagram usually misses.

    Decision produced

    A map of the piece flow, exceptions, owners, systems, and the baseline cost or delay worth changing.

    Risk closed

    Paying to automate the visible symptom while the expensive constraint remains.
  2. 02
    Shape

    Choose the first useful release

    What needs to exist together for one useful result to work?

    Choose the shape from the way the work happens, not from a preferred technology. Name the member, the device, the data, the system connections, who can access what, the exceptions, and the result the first release must complete.

    Decision produced

    The right mix of web, mobile, desktop, browser extension, connected device, wearable, or behind-the-scenes connection work, with the first-release boundary and a clear definition of done.

    Risk closed

    A small-looking feature list that quietly depends on several interfaces, systems, and owners.
  3. 03
    Prove

    Review working software

    Will it hold up outside a controlled demo?

    Review the product against the agreed piece flow, not a tour of finished screens. Record changed assumptions and test what happens when data is missing, access is wrong, or a connected system fails.

    Decision produced

    Working checkpoints tested with realistic data, real user types, system connections, recovery plans, and the people who will use or run the system.

    Risk closed

    Discovering the important gaps during migration or after members depend on the release.
  4. 04
    Transfer

    Release, measure, and hand over

    Did the new piece flow improve the original constraint, and can another capable team operate it?

    Move a controlled set of members or pieces first. Compare time, errors, completion, or another agreed measure with the starting point before adding the next piece flow.

    Decision produced

    A controlled release, comparison with the baseline, operating notes, account ownership map, and a recommendation for what should happen next.

    Risk closed

    Measuring development activity instead of the business result, or depending on the original vendor to keep the system running.

What stays out of the black box

These are operating conditions to put in the engagement, not claims to take on faith.

The scope names one complete piece flow

The member, the trigger, the decisions, the data, the exceptions, and what 'done' looks like. A screen list is not enough, and a feature list with no member attached is not a scope.

Progress is visible in working software

Reviews against the product at agreed checkpoints, while there is still time to act.

A scope change has a price before it has code

A new piece flow or system connection shows its effect on cost and timing before anyone approves it. You see the effect in writing, not as a surprise on the next invoice.

Ownership exists throughout, not only at handover

Code, cloud, data, and provider access stay visible and under your control from day one.

The work is checkable without being technical

Checkpoints are working software you use yourself, reported in plain language.

Pottery studio software by area.

Start from your domain. Each area below is a working practice with shipped products behind it.

What it costs

Every project starts at $10000.

The first phase turns the costliest patched piece flow into a scoped build with written acceptance criteria.

Starting investment

Starts at $10000

Workflow complexity, systems to connect, moving your data over, and who does what set the scope. After a 30-minute call, you get a written buy, repair, build, or wait recommendation plus first-phase direction. Free, whether or not you build with us.

Build or buy

Buy an existing productBuild custom software
Best fitHandles your piece flow with reasonable setup, and its pricing makes senseThe way your studio works is itself the advantage
Manual workConfiguration and process changes can remove the constraintRepeated manual work has a measurable cost
ConnectionsExisting connections work with reasonable setupA critical connection to your other systems cannot be done cleanly any other way
Studio routeConfigure a maintained studio product when its class, member, kiln, and fee model fitsOwn custom software only when the differentiating piece flow, fee rule, member portal, or cost of constraint justifies build and support

Work with us

Bring one stuck piece flow. Leave with a decision.

In a 30-minute call, we will help you decide whether to buy, connect, repair, build, or wait. If custom software is not the sensible next move, that is still a useful answer.

  • One named piece-flow owner and one complete path for the first phase.
  • Scope, price, what 'done' looks like, and exclusions agreed before paid work starts.
  • Code, cloud, data, and provider access remain under your control.
  • Post-launch warranty cover for defects in the agreed scope.

Common questions

Pottery studio management software runs the piece journey in a ceramics studio. It takes a piece from the moment a member leaves wet clay on the shelf, through the bisque load and the glaze load, to the day the member picks up the finished work. It keeps the piece, the member, the firing stage, the firing fee, the shelf, and the pickup date in one record. It can also cover memberships, class rosters, wheel bookings, and the member tab, so the studio stops running on a clipboard, a wall chart, and whoever remembers.

Every piece gets its own file at intake, with the member, a photo, the clay, the size or weight, and the shelf it sits on. The record moves through the same stages for every piece: wet clay, dry and ready for bisque, in the bisque load, glazed, in the glaze load, fired and cooling, ready for pickup. When a piece is loaded, it is ticked into that load with the cone and the target unload date. Staff see the queue; members see their own pieces. A piece with no record is a piece nobody can find, so intake is the step that makes the rest of the system work.

Members check the queue themselves. Each load shows its type, its cone, its load date, and its expected unload date, and each piece in it is tied to its member. When the load is unloaded and the piece is on the ready shelf, the member gets a message that their work is cool and ready to collect. The front counter stops being the status desk. That only works if the queue is updated when the load moves, not at the end of the week, so loading and unloading are part of the job, not extra admin after it.

Firing fees follow one rule the whole studio can explain. Studios commonly charge by volume, by weight, or by size band, and the same rule applies to bisque and glaze loads. The fee is worked out from the piece record at intake, so the member sees the charge before the piece goes in the kiln, and the charge lands on the member tab instead of being worked out by hand at the counter. The rule itself is the studio's call: the software applies it the same way to every piece, and the studio can change it without rebuilding the system.

The queue is a list of loads, not a pile of notes. Each load has a type, bisque or glaze, a cone, a load date, and an expected unload date. Pieces are added to a load until it is full, and the load moves through loading, firing, cooling, and unloading. Members see the next firing date and where their pieces sit in the queue. A full kiln fires better and wastes less heat than a half-empty one, so the queue also shows how full the next load is, which is the honest reason a piece sometimes waits for the next firing.

Each shelf bay is numbered, assigned to one member, and given an end date that matches their membership. Nobody shares a bay by accident, and nobody holds a shelf after leaving. When a shelf goes past its date, it lands on a clearing list with the member's contact details already attached, instead of becoming an argument at the counter. Unclaimed finished work follows the same rule: a pickup deadline, a reminder, and a written studio policy for what happens after it. The software enforces the dates; the studio sets them.

Breakage is recorded against the piece, and the member sees it. The record shows which load the piece was in, what stage it reached, and what happened, so the conversation starts from the facts instead of from a search through the shelves. The software does not decide who pays or whether a piece gets remade: that is the studio's policy, written down before the first firing, and the record is what makes the policy enforceable. A piece that was never logged cannot be explained, which is why intake matters even for small work.

Buy a maintained studio product when it handles your piece flow with reasonable setup: class booking, memberships, piece tracking, kiln loads, firing fees, and pickup messages. Maintained products such as KilnSeat and Ceramik cover exactly that, and a studio with standard work should start there. Build custom when your workflow breaks the template: firing rules or fee structures the maintained products cannot express, shelf and kiln capacity your floor plan makes unusual, a member portal your members will actually use, or connections to systems the maintained products do not cover. If your piece flow is standard, buying is the better trade.

The first paid phase may cover a bounded audit, a proof of concept, a recovery plan, or a small first release. The final price depends on how deep the piece flow goes, how many members and staff it serves, what it needs to connect to, whether data needs moving over, whether phones or tablets are involved, and the condition of existing code. The agreed phase is priced in writing before it starts.

Timing depends on scope: a bounded audit or proof of concept is a smaller engagement, while a system with several connections to other systems, data to move over, mobile apps, or formal compliance controls takes longer. The schedule is set once the first piece flow and what 'done' looks like are clear.

Yes. Takeover is a common first engagement, and it always starts with an audit: where the code lives, how your data is organized, what is tested, which outside services it depends on, who can access what, and how updates go live. Code that is understandable and fit for the next release stays; only the parts blocking reliability get replaced. And if you already paid another vendor and have nothing working, the audit tells you which story you have before you spend more: the most expensive version is the product that looks finished, clean screens and clicking buttons, while underneath nothing is tested and the security checks run in the browser, where anyone can tamper with them, instead of on the server where they hold.

You judge what you can see, not the code. Every checkpoint is working software you click through yourself, tested against the piece flow agreed at the start: a piece is logged, it moves through the loads, the member sees the status, the fee matches the rule, the pickup message goes out. Progress is reported in plain language: what changed, what's next, and what it costs. Because you own the code, the accounts, and the operating notes throughout, nothing about the work is locked inside our heads. Our job is to make the work checkable; your job is to check it against your studio.

We need one person who owns the piece flow, access to the relevant users and systems, timely answers on studio rules, and someone who can accept or reject each milestone. A weekly working session is usually enough once the scope is stable. Your team should not have to manage developers day to day. The team that scopes your project is the team that does the work: no handoff to another vendor after you sign, and you can talk to the people doing the work directly.

You own the code built for you and control where it lives, the cloud accounts, the data, analytics, and third-party subscriptions. Outside services and open-source pieces keep their own licence terms. The operating notes and handover material stay current so another capable team can take over.

Every launch includes post-launch warranty cover for defects in the agreed scope, release support, and small screen corrections. After that, work can continue as another fixed phase or an ongoing product engagement. The code and accounts stay under your control either way.

It can handle all of them, but the first release should not try to. Classes, memberships, wheel bookings, and the kiln queue share one member record, so a member's plan, their wheel time, their shelf, and their firing tab all stay in one place. The first release picks the path that costs the most today, usually the kiln queue and firing fees, and the rest joins once that path works. A studio that starts with everything at once gets a bigger system and a slower first win.

A drop-off piece gets the same record as a studio piece, with the owner, the clay and cone, the size or weight, the fee, and the pickup date. The difference is only at intake: the piece arrives finished and ready for the shelf instead of being made in the studio. After intake, it follows the same queue, the same loads, and the same pickup message. The studio decides whether it fires outside work at all, and the record is what makes that decision workable instead of a favour tracked on a sticky note.