SiSi Documentation › Product Development Process
Product Development Process
This is how a feature moves from an idea to production at SiSi. It covers who does what at each stage, which ClickUp fields to set, and what is automated.
Related pages
- QA Checklist: the interactive checklist QA uses on Main Staging
- Staging Instances: how to claim, deploy, and release a staging slot
Who's involved #
These people are always part of the flow:
- Henry and Jett create the backlog, the roadmap, and the spec.
- The designer designs it and gets sign-off from Florence.
- The designer hands it off to the developer.
- The developer builds it and gets sign-off from the designer. Henry does final review and merges.
- Rico or Cip review it on Main Staging, by module tag.
- Henry releases it.
Consultants #
Anyone in the company can be pulled in for their input, at any stage. Typical moments are design review, the handoff meeting, and spec changes. These are examples, not a fixed list:
| Person | Pull them in for |
|---|---|
| Jett | What schools and users need and want, and how they'll use it |
| Cip | School IT, and anything a school's IT team will handle |
| Rico | Teaching, school leadership, and anything in the LMS or the classroom |
| Henry | Feasibility, architecture, and anything technically complex |
Consultants give input. Sign-off stays with the people in the flow.
At a glance #
| Stage | Weekly Flow status | Who does the work | Who approves | Exit field |
|---|---|---|---|---|
| 1. Spec | backlog → ready for design |
Henry, Jett, Spec Partner | Henry and Jett | Module tags set |
| 2. Design | design → ready for dev |
Designer | Florence | Florence moves the task to ready for dev |
| 3. Development | dev → qa test |
Developer | Designer (build), Henry (final) | Design Approval = Approved or N/A, PR merged |
| 4. QA | qa test |
Rico or Cip (by module tag) | QA owner | QA Approval is set |
| 5. Release | qa test → live |
Henry | Henry | Release commit on main |
backlog ─▶ ready for design ─▶ design ─▶ ready for dev ─▶ dev ─▶ qa test ─▶ live
└── Spec ──┘ └── Design ──┘ └ Dev ┘ └ QA ┘ └ Release (independent track)
How we use ClickUp #
Statuses #
Weekly Flow has seven statuses: backlog, ready for design, design,
ready for dev, dev, qa test, live.
Review steps live in the Stage Status field.
Stage Status #
Stage Status shows what is being done or waited on right now, not what has been done. The only exception is the last value, which means the stage is finished.
- Who updates it: the person currently working the task. That is the designer during design, the developer during development, and the QA owner during QA.
- When: every time the task moves to a new step in this guide. Steps that change it say which value to set.
Fields #
| Field | Values | Set by | Stage |
|---|---|---|---|
| Module tags | academics, admissions, attendance, lms, student portal, and the other module tags | Henry or Jett | Spec (required) |
| Figma link | URL | Designer | Design |
| Staging Instance | Slot URL, such as https://a.sisi.staging.mysisi.app |
Staging deploy workflow (automatic) | Development |
| Design Approval | (blank), N/A, Changes Needed, Reviewed, Approved | Designer | Development |
| QA Approval | (blank), Approved, Blocking Issues Found, Minor Issues Found, N/A | QA owner | QA |
Blank is the default and means "not reviewed yet."
Tags are module scope. They say which part of the product a task touches, and they decide who owns QA. Every task needs them before it leaves the spec stage.
1. Spec #
Status: backlog → ready for design
- Idea. Ideas come from the Feature Request List, a client request, or directly from Henry or Jett.
- Discussion. Henry and Jett agree on scope and priority. Henry checks technical feasibility at this point.
- Spec writing. Henry and Jett use Spec Partner to write the spec. It goes into a ClickUp doc linked on the task.
- Module tags. Set the module tags on the task. This is required. Tags drive QA assignment later, so a task without tags goes to the default QA owner.
- Ready for design. Move the task to
ready for design.
Done when: the task has a linked spec doc with requirements and acceptance criteria, and its module tags are set.
2. Design #
Status: ready for design → design → ready for dev
Steps #
-
Assign a designer. Move the task to
design. The designer sets Stage Status to In Progress. - Set up Figma. The designer creates a page in the module's Figma file and pastes its link into the task's Figma link field.
-
Design the feature. Cover:
- every affected role: admin, teacher, guardian, student
- white-label naming
-
Automated design check (loop). Run the design check tools Jett and Florence are building.
They check that:
- the spec is met
- text overflow is handled
- loading, empty, and error states exist
- the design is responsive
Fix what they flag and run them again. These checks are lighter than development CI. The tools are still in progress; until they are ready, the designer checks these points by hand.
- Design review (loop). Stage Status: In Review. Florence reviews and approves. The designer works through feedback until Florence is satisfied, pulling in consultants as needed.
- Final design review. Florence does the final review. If changes are needed, the task goes back to step 5.
-
Ready for dev. When the final review passes, Florence moves the task to
ready for dev. This is her sign-off. -
Handoff meeting. Required before development starts.
- Always: the developer and the designer
- As needed: a consultant
Spec changes during design #
Spec changes during design are allowed. Use judgment, because every case is different:
| Size of change | Who decides |
|---|---|
| Small | Florence and the designer |
| Larger | Henry and Jett |
| Significant | Back to Spec Partner to update the spec |
Update the linked spec doc when a change is agreed.
Done when: Florence has moved the task to ready for dev and the handoff meeting
has happened.
3. Development #
Status: ready for dev → dev → qa test (development
ends at merge)
The designer reviews the build twice: a detailed review before automated review, and a light check after it. The light check confirms that fixes from automated review didn't change the UI. It is not a second detailed review.
Steps #
-
Initial development. Move the task to
dev. The developer sets Stage Status to In Progress. -
Open a draft PR. Open a draft pull request against
mainearly, as a home base for the work. Fill out the PR template checklist as you go: link the ClickUp task or tasks, and tick items off as you finish them.- Automatic:
pr-clickup-link.ymlcopies the PR URL to the ClickUp task. -
A PR stacked on another PR's branch gets the same checks. Retarget it to
mainbefore merging: tasks are handed off to QA only when their PR merges intomain.
- Automatic:
-
Deploy to a staging slot. Claim a slot and deploy your branch to it. See
Staging Instances.
-
Automatic: the staging deploy workflow records the slot's URL, such as
https://a.sisi.staging.mysisi.app, on the PR and in the task's Staging Instance field. It finds the PR by matching the deployed commit to an open PR's head commit. If that fails, enter the PR number in the workflow's optional input. Main Staging is never recorded.
-
Automatic: the staging deploy workflow records the slot's URL, such as
-
Detailed design review (loop). Stage Status: Design Test. The designer
checks the build on the staging slot against Figma and sets Design Approval:
- Reviewed: the build matches the design.
- Changes Needed: the developer fixes, redeploys, and asks again.
- N/A: backend, build, or infra work with no design.
Rule: if a task has a Figma link, it needs design approval.
-
Automated review (loop). Stage Status: Dev Test. When the PR template
checklist is done, mark the PR ready for review; review jobs do not run on drafts. AI review, Bugbot, and
regular CI (format, translations, types, tests) then run on the PR. Fix findings until they pass.
-
After each fix you push, comment
bugbot runand/or/reviewto rerun the AI reviews. One comment can do both ifbugbot runcomes first:bugbot run /review. See PR review checks.
-
After each fix you push, comment
-
Light design check. Stage Status: Design Check. The developer redeploys
the latest commit to the staging slot. The designer takes a quick look and moves Design Approval from
Reviewed to Approved, or sets Changes Needed if something
drifted.
-
After Design Approval changes, comment
/design-approvalto rerun the Design Approval check.
-
After Design Approval changes, comment
-
Final review. Stage Status: Final Test. Henry reviews
only after automated review and the light design check have passed, then merges. If Henry
asks for a UI change, the task goes back to step 6.
-
Automatic:
pr-merged.ymlmoves linked tasks toqa testand assigns each one a QA owner (see QA). - Henry may bypass required checks on
mainwhen needed.
-
Automatic:
PR review checks #
The required PR review checks are PR Checklist, AI Review, and Bugbot. The Design Approval check joins them once it becomes required.
-
Bugbot is the check that records Cursor Bugbot. When Cursor Bugbot succeeds on the current
commit, the PR gets the
bugbot-passedlabel. -
A push that doesn't change the patch, such as a clean rebase, keeps
ai-review-passedandbugbot-passed. -
skip-ai-reviewandskip-bugbotwaive those checks when an allowed maintainer applies them.
Design Approval check #
A separate CI check reports design approval on every PR. It is plain code, not AI, and runs independently of AI review so it can rerun whenever the field changes.
- What it reads: the ClickUp task IDs in the PR description, and the Design Approval field on each linked Weekly Flow task. Tasks without a Figma link are skipped.
-
When it runs: on PR open, edit, and every push, drafts included
(
pr-design-approval.yml). After the designer changes the field, comment/design-approvalon the PR to rerun it. The command can share a comment with others:bugbot run /review /design-approval. - Blocking: informational at first. It becomes a required check after one to two weeks.
Labels (for PRs with one or many tasks; only tasks with a Figma link count):
| Label | When |
|---|---|
design-approved |
At least one linked task is Approved, and the rest are Approved or N/A |
design-reviewed |
The detailed review is done on every linked task, and at least one still needs the light check |
design-changes-needed |
Any linked task is Changes Needed |
design-n/a |
All linked tasks are N/A, or none has a Figma link |
| (no label) | Any linked task still awaits the detailed review (blank) |
Pass or fail:
- Passes when every linked task with a Figma link is Approved or N/A, or when none has a Figma link.
- Fails when a task with a Figma link is blank, Reviewed, or Changes Needed.
Done when: the PR is merged and the linked tasks are in qa test.
4. QA #
Status: qa test (QA does not move the task)
QA happens on Main Staging after merge. Main Staging deploys automatically on every push to
main that changes the frontend or backend. Deploys queue rather than cancel each other, so the
latest commit always ends up there.
Ownership #
Every task in qa test gets a QA owner, added to its assignees automatically by
pr-merged.yml from the module tags.
| Module tag | QA owner |
|---|---|
| academics | Rico |
| admissions | Rico |
| attendance | Rico |
| lms | Rico |
| student portal | Rico |
| Any other tag | Cip |
| No tags | Cip |
- Each tag maps to one person. Most tasks get one owner.
- If a task's tags map to both people, both are assigned. Nothing blocks on that.
- A task with no tags of its own, usually a subtask, uses its parent's tags.
-
The mapping is
QA_OWNERSat the top of.github/workflows/pr-merged.yml. Change it with a PR.
Steps #
- Pick up the task. The QA owner sets Stage Status to QA Test.
- Work through the checklist. Open the QA Checklist on the docs site with the task ID. When you're done, copy its summary into a comment on the task.
-
Set QA Approval.
- Approved: it works as specified.
- Blocking Issues Found: at least one bug was filed that must be fixed before release.
- Minor Issues Found: bugs were filed, but none blocks release.
- N/A: nothing user-facing to test, such as pure build or infra changes.
- File bugs as new tasks. For each bug, create a new task linked to the original. Do not reopen the original.
QA approval does not close the task. The task stays in qa test until a release
moves it to live.
Done when: QA Approval is set and any bugs are filed and linked.
5. Release #
Status: qa test (or any status) → live
Release is an independent track. It is not tied to a single PR; one release usually covers several merged PRs.
-
Release commit. Henry pushes a commit to
mainwhose message starts withRelease. -
Tasks close automatically. On push,
released.yml:- finds every PR merged since the previous release commit
- reads their ClickUp task IDs
- moves those Weekly Flow tasks to
live, whatever their current status
- Release notes. Henry approves the release notes (drafted from the git log) and publishes them in Sanity.
-
Deploy to production. Production deploys stay manual, through
deploy/production.
A release commit counts as "live" for ClickUp, even before production is deployed. The release commit also
deploys Main Staging like any other push to main.
Deploys #
| Environment | How it deploys |
|---|---|
| Main Staging |
Automatically on every push to main that changes its side: the frontend deploy for
frontend/, the backend deploy for backend/ or schema.srsl.
Release commits change both. Runs queue with cancel-in-progress off.
|
| Feature staging slots |
Manually, from deploy/staging/<letter> branches. See
Staging Instances.
|
| Production | Manually, from deploy/production. |