How to create a customer support assessment

What you'll need

• A SkillCort workspace with permission to create items and assessments
• A written summary of what your support role actually handles day to day
• Two or three anonymized real tickets to base scenarios on
• Agreement with the hiring manager on which competencies matter most

Step 1: Map the role to competencies

Before touching the builder, name what you are measuring. For most support roles the load-bearing competencies are tone, accuracy, prioritization, and de-escalation. Write one sentence per competency describing what strong performance looks like in your queue — for example, "acknowledges the customer's frustration before proposing a fix, and never promises a date we cannot keep."

These four competencies become the spine of the whole assessment: each task you build will target one or two of them, each rubric criterion will map back to one, and section weights will reflect how much each matters for this specific role. Doing this on paper first keeps the assessment honest — you build tasks to measure competencies, not competencies to justify tasks.

• Tone: warmth and professionalism matched to the situation
• Accuracy: says only what is true; no overpromising
• Prioritization: handles a queue in a defensible order
• De-escalation: lowers the temperature without giving away the store

Step 2: Build the ticket simulation in the items library

Open the items library and create a folder for this role — for example "Support hiring" — with folder-scoped tags like "ticket", "triage", and "de-escalation" so you can filter later. Create the first item manually: a rich-text response task that presents a realistic customer ticket and asks the candidate to write the actual reply they would send.

Use a side-by-side stimulus layout so the ticket, the relevant policy excerpt, and any order details sit on one side while the candidate drafts on the other. Base the ticket on a real, anonymized case: a partially legitimate complaint with one missing detail forces the candidate to show judgment, not just template recall.

Step 3: Add the inbox prioritization and difficult-customer tasks

For prioritization, create a task that shows a small inbox — six to eight short tickets of mixed urgency — and asks the candidate to order them and briefly justify the top two choices. A table input works well for the ordering, paired with a short text input for the rationale. The rationale is where the evidence lives; the order alone can be guessed.

For de-escalation, write a difficult-customer scenario: an angry message that includes a factual error on the customer's side. The candidate must correct the record without inflaming the situation. A rich-text response captures the reply; if voice matters in your channel, an audio recording item lets you hear tone directly.

Step 4: Write a rubric for each task

Attach a rubric to every task before anyone responds. For the ticket simulation, a level-based matrix works well: criteria for tone, accuracy, and clarity, each with anchored behavior descriptions — what a strong, acceptable, and weak reply concretely looks like. Anchors are what keep two evaluators aligned; "good tone" means nothing without them.

Weight criteria by importance: accuracy might carry more weight than formatting polish. When you attach a rubric it freezes into a snapshot, so later edits to the rubric will not silently change how in-flight candidates are scored. If you want candidates to see the standard they are being held to, mark the rubric candidate-visible.

Step 5: Assemble sections and set weights in the builder

Create the assessment and structure it as sections, pages, and blocks. A clean layout for this role: Section 1 "Ticket handling" (the simulation), Section 2 "Queue triage" (the prioritization task), Section 3 "De-escalation" (the difficult-customer scenario). Import your items through the picker modal, filtering by the folder and tags you set up earlier and multi-selecting what you need.

Set section scoring weights to match the role. If de-escalation is what separates your best agents from the rest, weight that section accordingly — the weights flow directly into the role-fit score your Decision Board will show later. Add candidate instructions that set expectations honestly: a short, realistic slice of the job, not a trick.

Step 6: Set timing, preview, and publish

Set a total time limit proportional to the work — a focused support assessment rarely needs more than 30 to 40 minutes. If you want the triage task done under mild realistic pressure, add a per-page time limit to that page; when it expires the candidate is moved on and the page locks, so say so plainly in the instructions.

Use "Preview as candidate" from the builder header and take the whole assessment yourself. Check that stimulus layouts read well, timing feels fair, and nothing is ambiguous. The publish checklist will block Publish until required setup is complete — resolve anything it flags, then publish.

Step 7: Deliver, evaluate, and decide

Create a delivery with a name and time window, and keep integrity controls proportional to the stakes: for most support hiring, copy/paste blocking is plenty, and candidates see exactly what is monitored at the consent gate before they start. Invite candidates by email.

As responses arrive, evaluators score against the shared rubrics. AI drafts summaries and score suggestions with the model and version logged, but a named human confirms every score — the suggestion is support, never the decision. On the Decision Board, weighted role-fit ranks candidates and every number drills down to the underlying evidence, so the shortlist conversation is about what candidates actually wrote, not who interviewed warmly.