Score Event Software Demos

Creates a weighted demo scorecard and per-vendor question list, then combines your team's scores into a recommendation that keeps failed Musts and disagreements visible.

Example prompts

Once the skill is added, start a chat with one of these and attach your file if you have one.

  • Make a demo scorecard for our 3 finalists with weights we agreed on.

  • Combine these 6 people's scorecards and tell me where we disagree.

  • What should we ask each vendor in the demo that their website doesn't answer?

What this skill does

This skill turns your requirements into a demo scorecard: Must-haves as pass or fail gates, and weighted criteria for fit, ease of use, integrations, support, security and three-year cost, each with 1 to 5 anchors so everyone scores the same way. It also writes the questions each finalist still needs to answer.

After the demos, it combines everyone's scores, recomputes weighted totals, keeps any failed Must in plain view and flags criteria where scorers disagree by two points or more. You get a short recommendation memo with dissenting views and open questions.

When to use it

  • Before event platform demos with several finalists
  • Comparing vendors after demos
  • Running a software selection committee
  • Combining scores from events, marketing ops, IT and finance
  • Preparing questions vendors must answer in writing

How it works

  1. 1Set criteria and weightsTurns Musts into pass or fail gates and proposes weights that total 100, frozen before the first demo.
  2. 2Script the demosAsks vendors to run your real use cases live and lists each vendor's open questions.
  3. 3Collect scoresGives each scorer the same sheet with 1 to 5 anchors and space for evidence.
  4. 4ConsolidateComputes means, spreads and weighted totals, and flags failed Musts and disagreements.
  5. 5RecommendRanks vendors that pass every Must and records dissenting views by role.

What you'll need

  • Requirements or criteria
  • Finalist vendors and demo dates
  • Scorers and their roles
  • Completed team scores (after demos)

What you get

A scorecard sheet for each scorer, a question list per vendor, a consolidated results table with Musts passed, criterion means, weighted totals and the biggest disagreement, and a recommendation memo with risks, open questions and next steps.

Tips

  • Agree on weights before the first demo, then don't change them.
  • Have scorers fill in their sheet right after each demo, before talking it over.
  • Score roadmap promises as missing until they ship.
  • Let the people who'll use the tool every day score ease of use.

What's in the download

  • demo-scorecard/SKILL.md6.8 KB
  • demo-scorecard/assets/sample-team-scores.csv5.4 KB
  • demo-scorecard/assets/sample-weights.csv287 B
  • demo-scorecard/references/scoring-rubric.md1.7 KB
  • demo-scorecard/scripts/consolidate_scores.py2.9 KB
Read the SKILL.md
---
name: demo-scorecard
description: Builds weighted scorecards for event software demos and consolidates the team's scores. Turns the requirements list into criteria, scores Must-haves as pass or fail, weights fit, ease of use, integrations, support, security and total cost, writes vendor-specific questions to ask in each demo, and combines everyone's scores into a summary recommendation that keeps dissenting views visible. Use when watching event platform demos, comparing vendors after demos or running a software selection committee.
license: MIT
metadata:
  author: eventmarketingsoftware.com
  version: "1.0"
  category: choosing-software
  source: https://eventmarketingsoftware.com/skills/demo-scorecard
---

# Demo Scorecard

Keeps event software demos honest and comparable. Every vendor is scored on the same criteria and weights, Must-haves are pass or fail, and the team's disagreements stay visible instead of being averaged away. Strictly vendor-neutral: score only what the team saw and was told; never add outside opinions about a product.

## Intake

If the user has an `event-context.md` file or a requirements sheet, read it first.

Ask for whatever is missing in ONE message:

1. Requirements or criteria (ideally a Must, Should, Nice list with IDs) and the top use cases.
2. Finalist vendors (names as the user gives them) and demo dates.
3. Who's scoring and their role (events, marketing ops, IT, sales, finance).
4. Agreed weights, or permission to propose them.
5. Later: each person's completed scores, notes and any vendor answers received after the demo.

## Data sources (connectors optional)

- If a Google Sheets connector is available, create the scorecard as a sheet with one tab per scorer (preview first) and read completed scores back from it.
- If a Slack connector is available, you may draft a summary for the selection channel (post only after a yes).
- Otherwise return the scorecard as CSV and Markdown, and accept completed scores as pasted tables or uploaded CSV/XLSX.
- Never require a paid service. Never fetch vendor sites or review sites.

Sample completed scores: [assets/sample-team-scores.csv](assets/sample-team-scores.csv), with weights in [assets/sample-weights.csv](assets/sample-weights.csv). The sample includes a missing score, a 3-point disagreement and a failed Must, so check that all three show up in your output.

## Method

### Before the demos

1. **Set criteria.** Must-haves become pass or fail gates (one row each). Group the rest into weighted criteria. Default groups and weights (adjust to the team's priorities, total 100):
   - Fit to our use cases: 30
   - Ease of use for the people who'll run it: 20
   - Integrations and data (CRM, marketing automation, SSO): 20
   - Support, onboarding and services: 10
   - Security, privacy and accessibility: 10
   - Total cost over 3 years: 10
   Get the weights agreed BEFORE the first demo and freeze them.
2. **Write the score anchors** (1 to 5) per criterion so scorers mean the same thing. Use [references/scoring-rubric.md](references/scoring-rubric.md).
3. **Script the demo.** Ask each vendor to run the team's top use cases with the team's data, not a standard tour. Ask for live actions (register a test attendee and show the CRM record) over slides.
4. **Write vendor-specific questions.** For each finalist, list 5 to 10 questions their pitch or materials didn't answer, based on the requirements and anything the user pasted from the vendor. Typical gaps: exact CRM sync behavior and timing, what's native vs via a third-party connector, what costs extra (modules, overages, onsite support, implementation), contract terms (renewal uplift, auto-renew, exit and data export), security documents, support hours during live events, roadmap items they're counting as features. Mark questions they must answer in writing.

### After the demos

5. **Collect scores.** One row per scorer, vendor and criterion: score 1 to 5, or pass or fail for Musts, plus a note. Remind scorers to score right after each demo and before discussing with others.
6. **Consolidate.** If code execution is available, run `python3 scripts/consolidate_scores.py scores.csv weights.csv` (formats in the script header). Otherwise compute in-chat:
   - Mean score per criterion per vendor, and the spread (max minus min).
   - Weighted total out of 100 = sum of (criterion weight x mean score / 5).
   - Any Must failed by any scorer is shown as `Fail (n of N scorers)`; a Must failed by the majority, or confirmed by the vendor's written answer, disqualifies the vendor even if its weighted total is highest.
   - Disagreement flag where spread is 2 or more points.
7. **Recommend.** Rank vendors that pass all Musts by weighted total. State the margin; if the top two are within about 5 points, call it a tie and say which criterion should break it. List open questions and what would change the result. Record dissenting views by role, in the scorer's own words.

Domain rules that matter:
- A failed Must stays visible. Never let a high weighted total hide it.
- Roadmap answers don't count as features. Score what exists today.
- Score total cost on the user's real program priced for 3 years, including implementation and add-ons, not list price.
- Ease of use should be scored by the people who'll do the work daily, not only by managers.

## Output templates

**Scorecard sheet** (one per scorer, CSV)

`scorer, role, vendor, criterion_id, criterion, type (must or weighted), weight, score_1_to_5_or_pass_fail, evidence_or_note`

**Questions per vendor**

| Vendor | # | Question | Linked requirement | Must answer in writing |
|---|---|---|---|---|

**Consolidated results**

| Vendor | Musts passed | Failed Musts (scorers) | Fit | Ease of use | Integrations | Support | Security | Cost | Weighted total | Biggest disagreement |
|---|---|---|---|---|---|---|---|---|---|---|

**Recommendation memo** headings: Recommendation, Why, Failed Musts and risks, Where we disagree, Open questions before contract, Next steps (references, security review, pricing negotiation).

## Validation checklist

- [ ] Weights total 100 and were set before the demos.
- [ ] Every scorer scored every vendor on every criterion, or gaps are listed.
- [ ] Failed Musts shown for every vendor, even the leader.
- [ ] Weighted totals recomputed and match the per-criterion means.
- [ ] Disagreements of 2 or more points are listed with both views.
- [ ] Recommendation uses only the team's scores and vendor answers; no outside product claims.

## Approval gates

- Show the sheet before creating it in Google Sheets. Draft any Slack post or vendor email and send only after a clear yes.

## Optional research

If the team wants neutral background before demos, they can compare vendors on eventmarketingsoftware.com (for example the /compare and /shortlist pages). That's optional reading for the user; never fetch it or rely on it.

FAQ

How do I score software demos fairly?
Use the same criteria, weights and 1 to 5 anchors for every vendor, agree on weights before the first demo, and ask vendors to run your own use cases instead of a standard tour. Have each person score alone right after the demo, then compare. The skill sets this up and combines the results.
What weights should an event software scorecard use?
A common starting point is fit to use cases 30, ease of use 20, integrations 20, support 10, security 10 and three-year cost 10. Adjust to your priorities, for example raising integrations if CRM data is your biggest pain, but keep the total at 100 and freeze it before demos.
What if the highest-scoring vendor fails a Must-have?
It stays disqualified unless the team agrees the Must wasn't really a Must. The skill always shows failed Musts next to the weighted total so a high score can't hide a dealbreaker, and lists it as a risk in the recommendation memo.
How do we handle disagreement between scorers?
The skill flags any criterion where scores differ by two points or more and records each person's reason. Often the gap is about role: a manager may find a task easy that the daily user doesn't. Resolve it with a sandbox trial or a follow-up question to the vendor.