SiSi

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

Who's involved #

These people are always part of the flow:

  1. Henry and Jett create the backlog, the roadmap, and the spec.
  2. The designer designs it and gets sign-off from Florence.
  3. The designer hands it off to the developer.
  4. The developer builds it and gets sign-off from the designer. Henry does final review and merges.
  5. Rico or Cip review it on Main Staging, by module tag.
  6. 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.

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

  1. Idea. Ideas come from the Feature Request List, a client request, or directly from Henry or Jett.
  2. Discussion. Henry and Jett agree on scope and priority. Henry checks technical feasibility at this point.
  3. Spec writing. Henry and Jett use Spec Partner to write the spec. It goes into a ClickUp doc linked on the task.
  4. 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.
  5. 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 #

  1. Assign a designer. Move the task to design. The designer sets Stage Status to In Progress.
  2. 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.
  3. Design the feature. Cover:
    • every affected role: admin, teacher, guardian, student
    • white-label naming
  4. 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.

  5. 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.
  6. Final design review. Florence does the final review. If changes are needed, the task goes back to step 5.
  7. Ready for dev. When the final review passes, Florence moves the task to ready for dev. This is her sign-off.
  8. 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 #

  1. Initial development. Move the task to dev. The developer sets Stage Status to In Progress.
  2. Open a draft PR. Open a draft pull request against main early, 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.yml copies the PR URL to the ClickUp task.
    • A PR stacked on another PR's branch gets the same checks. Retarget it to main before merging: tasks are handed off to QA only when their PR merges into main.
  3. 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.
  4. 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.

  5. 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 run and/or /review to rerun the AI reviews. One comment can do both if bugbot run comes first: bugbot run /review. See PR review checks.
  6. 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.
  7. 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.yml moves linked tasks to qa test and assigns each one a QA owner (see QA).
    • Henry may bypass required checks on main when needed.

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.

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.

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:

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

Steps #

  1. Pick up the task. The QA owner sets Stage Status to QA Test.
  2. 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.
  3. 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.
  4. 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.

  1. Release commit. Henry pushes a commit to main whose message starts with Release.
  2. 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
  3. Release notes. Henry approves the release notes (drafted from the git log) and publishes them in Sanity.
  4. 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.