How to Export AI Rubrics to Microsoft Teams

Microsoft Teams for Education handles rubrics differently than almost any other classroom platform: instead of attaching a rubric as a static file, you can rebuild its criteria directly inside an Assignment as a structured, scorable object that students see before they submit and you use directly during grading.

Quick Answer: For point-based, criteria-driven rubrics, recreate the structure inside Teams' native Assignments rubric builder rather than attaching a file. For narrative-heavy rubrics with lengthy descriptor language, attach an AI-generated PDF or DOCX as a reference alongside the assignment instead. The two approaches solve different problems, and most classrooms end up using both at different times.

A rubric attached as a plain PDF is visible but static — students read it, and a teacher grades against it manually, referencing a separate document while scoring each submission. Teams' native rubric closes that gap directly.

This distinction — a file versus a structured, in-platform object — is the core decision this guide walks through, along with the mechanics of building it correctly the first time.

This guide covers:

• How Teams' native rubric builder actually works, and where a file-based rubric still fits
• A step-by-step workflow for both paths
• What breaks when a file-based rubric moves into Teams, and how to fix it
• Calibrating rubric language with a grading team before it goes live
• Accessibility and data considerations specific to Teams

For where this connects to the broader export landscape, see AI Content Formats & Export for Teachers: The 2026 Guide.

Native Rubric vs. File-Based Rubric

Teams' Assignments feature includes a built-in rubric tool, and understanding what it actually does — and doesn't — is the decision point everything else in this guide depends on.

What the Native Rubric Builder Does

When creating an Assignment, selecting "Add rubric" opens a structured builder where a teacher defines criteria as rows and performance levels as columns, assigns point values to each cell, and attaches the finished rubric directly to that assignment. Students see it before submitting, and a teacher scores directly against it during grading — the rubric and the grade book are the same object, not two things kept in sync manually.

What It Can't Do

The native builder is built for point-based, grid-style criteria. A rubric with long narrative descriptors, footnoted context, or a format that doesn't map cleanly onto rows and point-valued columns doesn't translate well into the native tool's structure, and forcing it usually produces a worse version of the original.

Step-by-Step: Building the Native Rubric

This sequence assumes the rubric's criteria and descriptors already exist from your content-generation tool, and treats rebuilding it inside Teams as a deliberate transcription step, not a copy-paste shortcut.

1. Generate the rubric, including all criteria, performance levels, and descriptors, in your content tool of choice.
2. Open the Assignment you're creating (or an existing one) and select "Add rubric," then "New rubric."
3. Add each criterion as a row, using short, clear labels that match the source rubric.
4. Define performance levels as columns, with point values assigned to each cell.
5. Enter a condensed version of each descriptor into its corresponding cell — Teams' grid has less room than a full document, so trim language to its clearest form.
6. Set the rubric to "Show to students" so it's visible before they submit, not just during grading.
7. Save the rubric as reusable if your Teams tenant supports it, so future assignments with similar criteria don't require rebuilding from scratch.

Say you teach Grade 9 and generate a five-criteria persuasive-essay rubric with four performance levels. Rebuilding it inside Teams' native tool means each of the twenty cells needs a condensed descriptor — a five-minute trimming pass that pays off every time you grade, since scoring happens directly against the visible grid instead of switching between a submission and a separate document.

Step-by-Step: Attaching a File-Based Rubric

For rubrics that don't fit the native tool's grid format, attaching a finished file remains the more practical path.

1. Generate the rubric and export it as PDF (for a locked, final version) or DOCX (if it may still need light edits).
2. Create or open the Assignment, and attach the rubric file alongside the assignment's other materials.
3. Confirm the file previews correctly inside the Assignment view — Word Online renders DOCX attachments directly, while PDFs open in Teams' built-in viewer.
4. Reference the rubric explicitly in the assignment instructions, since an attached file is easy for students to overlook without being pointed to it directly.
5. Grade using the attached rubric as a manual reference, since points won't populate automatically the way they do with the native tool.

Formatting Fidelity for File-Based Rubrics

A rubric attached as a file still needs a fidelity check, since Teams renders DOCX and PDF attachments through its own preview tools, which don't always match the source document exactly.

None of these are difficult once identified — checking the attachment inside Teams itself, from a student-view preview, catches most of them before the assignment goes live.

Calibrating Rubric Language Before It Goes Live

Because the native rubric tool is used directly during grading, getting the language right before publishing matters even more than with a file a teacher can quietly revise later.

Research from Heidi Andrade on rubric use in the classroom has found that students who understand a rubric's criteria before starting an assignment tend to produce stronger work than students who only see it after submitting — which is exactly what Teams' "Show to students" setting is built to support, provided the language is calibrated before that toggle goes on.

• Draft and calibrate in an editable document first, using the same independent-scoring approach used for any rubric: two or more colleagues score the same sample and compare results.
• Only transcribe into Teams' native builder once the language is stable, since editing a live rubric mid-assignment after students have already seen it creates confusion about which version applies.
• Grant Wiggins and Jay McTighe's work on backward design emphasizes starting from what evidence of understanding actually looks like — a useful lens when deciding which criteria genuinely belong in a rubric grid versus which are better handled through direct feedback instead.

Accessibility and Data Considerations

A rubric built or attached inside Teams still needs the same structural and privacy attention as any other classroom document, adapted to where Teams actually stores things.

Screen Reader Support for the Native Rubric

Teams' native rubric grid is read by screen readers as a structured table, provided criteria and level labels are entered as plain text rather than pasted from a source with unusual formatting. This is generally more reliable than a file-based rubric, since there's no conversion step between the source and what students see.

CAST's Universal Design for Learning Framework

CAST, the organization behind the Universal Design for Learning framework, recommends offering multiple ways for students to access the same criteria — which supports using both the native rubric (visible directly in the assignment) and a downloadable file version for students who prefer reading it outside the platform.

Where Student Data Fits In

Scores entered against the native rubric are stored within your school's Teams for Education tenant, backed by Microsoft 365 Education's data-handling agreements, rather than a personal account — consistent with FERPA's expectations for where student performance data belongs.

Exporting Scored Rubric Data for Record-Keeping

Grade data scored against a native rubric can typically be exported from Teams' gradebook view into a spreadsheet for a department's own record-keeping or for import into a separate student information system. Keep that exported file within the same school-managed storage as everything else tied to identifiable student performance, rather than a personal downloads folder that might sync to a personal device.

Reusing a Rubric Across Multiple Sections

A rubric built once inside Teams' native tool is worth applying consistently across every section of a course, rather than rebuilding it each time a new assignment goes out.

Applying One Rubric to Several Class Teams

When an assignment is created and shared across multiple class teams at once — the same feature covered for worksheets in How to Export AI Worksheets to Microsoft Teams — any native rubric attached to it carries over automatically, keeping grading criteria identical across every section without a separate rebuild.

Say you teach Grade 10 across four sections of the same English course. Building the persuasive-essay rubric once and applying it to an assignment shared across all four sections means every student, regardless of section, is scored against the exact same criteria and point values.

Tracking Grade Distribution With Insights

Teams' Insights tab, available inside a class team, surfaces grade distribution for assignments scored with the native rubric, which can highlight whether a specific criterion is consistently scoring lower across the class — a signal worth addressing with re-teaching before the next assignment, rather than treating each low score as an isolated case.

Tool Comparison for Rubric Generation and Teams Export

The generation tool matters here mainly in how much condensing and reformatting it leaves for you to do once you start transcribing into Teams' native grid.

A rubric that already arrives with clearly separated criteria and performance levels, rather than a single block of prose, is considerably faster to transcribe into the native builder's row-and-column format.