Moodle and Turnitin plagiarism detection

Turnitin's own Moodle plugin adds similarity reports, grading and feedback to assignments, forums, quizzes and workshops. This page covers the license, supported Moodle versions, setup sequence and the failure points to test first.

On this page

How Moodle Turnitin integration works for academic integrity teams

If your institution runs Moodle and wants Turnitin similarity reports on submitted work, the supported method is Turnitin's own plagiarism plugin, and it requires a Turnitin license. The plugin is the piece that connects Moodle activities to Turnitin's service, so the licence and the plugin version are the two dependencies your academic integrity team needs to confirm before any course is configured.

Once enabled, the plugin brings Turnitin features into the activities where integrity checks are most often needed. In Assignments, it supports similarity reports, grading and feedback on submitted files. In Discussions, Quizzes and Workshops, it extends the same Turnitin capabilities, including peer review in Workshops. Teachers see the report inside the activity workflow rather than in a separate tool, which means the reports, grades and feedback stay tied to the Moodle course record that the institution already keeps.

Turnitin develops and maintains this plugin. DeployOpen does not resell Turnitin licences, does not act as a Turnitin partner, and does not certify Turnitin's service. Our role, where the work is in scope, is the Moodle side: installing and configuring the plugin in infrastructure you control, aligning it with your Moodle version, and documenting how it is set up. Questions about what the Turnitin service does with submitted content, its data retention or its contract terms belong with Turnitin and your procurement or legal team.

Before planning the rollout, confirm the Moodle version you run and the Moodle versions the plugin supports. The public plugin listing states that Turnitin's plugin supports Moodle 4.5 to 5.2. If your site runs a version outside that range, or plans an upgrade that crosses it, the integration may need to wait or be re-tested. Check this against the plugin listing on the Moodle plugins directory and against the release your own platform team is targeting, since the plugin's support statement is the authority for compatibility.

What you need before installing the Turnitin plugin for Moodle

The Turnitin plagiarism plugin depends on a Moodle site, a Turnitin license and a server that can reach Turnitin's services. Each item below is a decision or check to settle before anyone schedules installation work, because a gap in any one of them can stall the rollout.

A Moodle site on a supported version

The Turnitin plagiarism plugin is listed in the Moodle plugins directory as supporting Moodle 4.5 to 5.2, so confirm your current release sits inside that range before planning. If you are on an older release, the upgrade path becomes part of the project and needs its own plan. Check the plugin version that matches your Moodle release, because the directory lists compatibility per plugin release.

A Turnitin license and account

The plugin requires a Turnitin license, and Turnitin supplies the account that the Moodle integration connects to. Ask Turnitin which account type and license tier cover the features you need, such as similarity reports, grading, feedback and peer review in Assignments, Discussions, Quizzes and Workshops. Confirm who signs the agreement and whether your existing Turnitin account can be reused for this Moodle site.

Administrator access to Moodle

Installing a plagiarism plugin and enabling it site-wide requires site administrator rights in Moodle, and the plugin then needs settings for each course or activity. Confirm which named people hold site administrator access, and who will configure course-level use. Keep this access limited, since the plugin handles student submissions and feedback.

A server that meets the Moodle requirements

The PHP version and database engine depend on the Moodle release you run, not on the plugin. For Moodle 5.1, the release notes call for 64-bit PHP 8.2 or later and one of several supported databases, while Moodle 5.3 raises the PHP and database minimums. Check the exact requirements for your chosen version, and confirm that the plugin's own PHP requirements are met by the same server.

Outbound network access to Turnitin

The Moodle server must be able to make outbound connections to Turnitin's services for similarity checks and report delivery. Many regulated networks restrict outbound traffic by default, so ask your network team to allow the endpoints Turnitin specifies for your account. Do not open access from a guess, and confirm the full list with Turnitin before change requests are raised.

A named owner for the Turnitin relationship

Someone must own the vendor relationship, the license renewal and the decisions about which courses use Turnitin. Without a named owner, license changes, account contacts and support escalations tend to fall to whoever notices a problem first. Record this owner, their backup, and the Turnitin contacts in your project documentation before installation.

Which Moodle versions Turnitin supports and what it means for upgrades

Before any Moodle upgrade, check the Turnitin plagiarism plugin's published compatibility range. The plugin's listing in the Moodle plugins directory shows support for Moodle 4.5 to 5.2. Moodle 5.3 was released on 5 October 2026 and receives general support until 4 October 2027. Because the listed range stops at 5.2, a site that plans to move to 5.3 cannot assume the Turnitin plugin will work after the upgrade. The plugin's requirements for each Moodle release come from Turnitin and the plugin page, so the upgrade team should check the current listing on the day the upgrade is scheduled and ask Turnitin in writing for a compatibility statement that names the target version.

Treat that compatibility statement as a gate in the upgrade plan, not as a item to confirm after the upgrade. Record the current Moodle version and the installed Turnitin plugin version, identify the target Moodle release, and obtain Turnitin's statement for that exact pairing. If the statement does not yet cover the target, the options are to wait, to stage the upgrade on a copy of production, or to defer the upgrade. Confirm the Turnitin licence as a separate item, because the plugin requires a licence and the terms should cover the upgraded site and the hosting environment. Ask Turnitin whether any licence or account change is needed when the Moodle version changes.

A Turnitin-dependent site must also meet Moodle's server requirements for the target release. From Moodle 5.1, the web server document root must point to the new /public directory instead of the main Moodle folder, or the site may show directory listings or errors. Web server configuration, reverse proxies and deployment scripts all need to change to match. For Moodle 5.3, the release notes list 64-bit PHP 8.3 or later (8.4 is supported), PostgreSQL 17, MySQL 8.4, MariaDB 11.4 or SQL Server 2019 or later. Sites must also run Moodle 4.4 or later to upgrade to 5.3. Check each database and PHP version against these lists before the plugin question is settled, because the two sets of constraints apply together.

Turn these checks into written items for the upgrade scope. Ask Turnitin which plugin version pairs with the target Moodle release and when that version will be published. Confirm that the database engine, PHP version and document root meet the target's requirements in a staging environment that mirrors production. Decide who signs off the Turnitin statement, and who owns the rollback if the plugin fails after the core upgrade. Also confirm which assignments, forums, quizzes and workshops use Turnitin features, so testing covers similarity reports, grading and feedback on each. If the team cannot get a clear statement for 5.3, plan the upgrade around that answer rather than around the release date.

Setup sequence for connecting Moodle to Turnitin

This sequence connects Moodle to Turnitin's plagiarism plugin on a staging copy first, so licensing, settings and report timing are proven before production changes. Each step closes with a check the team can record. Exact menu names and fields change between plugin versions, so follow Turnitin's current setup documentation alongside these steps.

  1. Confirm the Moodle version and server requirements

    The Turnitin plugin lists support for Moodle 4.5 to 5.2, so confirm that your current Moodle release sits inside that range before anything else. Then check the server requirements for that release, including the PHP version, the database engine and the web server document root. From Moodle 5.1, the document root must point to the public directory, or the site may show directory listings or errors. The Moodle administrator and the platform team complete this check together. It is closed when the Moodle, PHP and database versions are written down and matched against the release notes for that version.

  2. Create a staging copy of the site

    Copy the production code, database and file store to a separate environment that mirrors production's versions and hosting. Keep staging off public access and use test accounts, because test submissions generate similarity reports and may carry student-facing content. Confirm the copy by logging in as an administrator, checking that the Moodle version matches production, and opening a sample course with its uploaded files. Record the backup taken before any change so the production rollback path is known. The step is closed when the staging site matches production and the backup is recorded.

  3. Obtain the Turnitin license and account details

    The plugin requires a Turnitin license, so the organization needs an agreement with Turnitin before configuration begins. Ask Turnitin which account details the plugin needs for your Moodle site, and confirm whether separate credentials are issued for staging and production. Confirm that the license scope covers every Moodle site that will connect. Store the credentials in your secrets process and keep them out of change tickets and shared documents. The step is closed when a named owner holds an active license and both sets of credentials are recorded in the secrets store.

  4. Install the Turnitin plagiarism plugin on staging

    Download the Turnitin plagiarism plugin from the Moodle plugins directory, using the version that matches your Moodle release. Install it on the staging site through the Moodle administration interface and let Moodle complete its upgrade process. Watch the install output for errors and fix any dependency or permission problems before continuing. Confirm that the plugin appears among the installed plagiarism plugins and that the administration pages load without errors. Record the installed plugin version so the production install matches it exactly.

  5. Enter the account and integration settings

    Enter the account identifiers, keys and integration values that Turnitin provides into the plugin settings on staging. Use the field names and formats in Turnitin's current setup documentation, because labels and required fields can change between plugin versions. Once saved, check the connection status the plugin reports and confirm that the Moodle server can reach Turnitin through your network and any outbound proxy. Keep a record of each value and the person who supplied it. The step is closed when the plugin reports a successful connection on staging.

  6. Enable the plagiarism plugin site-wide and per activity

    Enable the plagiarism plugin at site level first so that it becomes available to activities. Then turn it on for each activity type in scope: Assignments, Discussions, Quizzes and Workshops. Each activity has its own plagiarism settings, so enable the Turnitin option in every activity that will use it. Create a test activity of each type and confirm the Turnitin options appear. The step is closed when every activity type in scope shows the Turnitin options on a test course.

  7. Set course and activity options for report timing

    With teaching leads, decide when similarity reports are generated and when students and teachers can view them, then set those options at activity level and review the course-level defaults. These choices determine whether a student sees a report before a final submission and whether teachers see reports before grading. Document the chosen option for each activity type so course designers apply the same rules. Check the settings on a test assignment by viewing it as a teacher and as a student. The step is closed when the teaching policy is signed off and both views match it.

  8. Test each activity type, then repeat on production

    Submit a test file through each activity type on staging: an assignment, a discussion post, a quiz response and a workshop submission. Check that the similarity report is generated, that the teacher and student views match the settings from the previous step, and that grades and feedback flow as expected. Mark or remove the test content afterward. When every activity type passes, repeat the configuration on production using the same plugin version and recorded settings, then run one controlled test submission there. The sequence is closed when production tests pass and the staging record is archived.

Mapping Moodle activities to Turnitin features

This table compares the four Moodle activities that the Turnitin plagiarism plugin can connect to, the Turnitin feature each one offers, what a teacher configures and what a student sees. Support can differ by activity type, so confirm the exact feature set in the plugin documentation for your installed Moodle version. The plugin requires a Turnitin licence and is listed as supporting Moodle 4.5 to 5.2.

Moodle activityTurnitin feature availableWhat the teacher configuresWhat the student sees
AssignmentsSimilarity reports, grading and feedbackEnables Turnitin on the assignment and sets the similarity, grading and feedback options the plugin offers for itSubmits work through the assignment, then sees grading and feedback, plus any similarity report the teacher has allowed
DiscussionsSimilarity checks on forum posts, where the plugin supports themTurns on the check for the forum or discussion, if the plugin supports it for that forum typePosts as usual, with any similarity result visible only if the teacher's settings allow it
QuizzesReview of text responses, where supportedConfirms which question types are included in the review and whether your installed version supports themAnswers questions as usual, with text responses reviewed only where the plugin supports this activity
WorkshopsPeer review featuresEnables the Turnitin peer review options on the workshop, if available for the phases the course usesSubmits work and reviews peers' submissions in the workshop phases, with feedback shown in the workshop flow

How grading and feedback move between Moodle and Turnitin

The most useful thing to map before rollout is the path a piece of student work takes through Moodle and back. When a student submits to an activity where the Turnitin plugin is enabled, the work is passed to Turnitin for processing. The similarity report comes back and is attached to that submission in the Moodle activity, so teachers review the report where they already grade. Teachers then add grades and feedback through Moodle's normal grading tools, and students see their results in the places Moodle already uses for that activity. The exact order of these steps, including timing and where each item appears in the interface, depends on your Moodle version and plugin version. Confirm the full sequence in a test course with a test student account before you publish the configuration.

The first decision is which activities send work to Turnitin. The plugin's listed features cover Moodle Assignments, Discussions (forums), Quizzes and Workshops, and each can be treated differently. Enabling the plugin at site level does not automatically send every activity's content for checking, so confirm how the plugin is turned on for each activity type and course. Write down the rule your institution will apply, for example which assessment types must be checked and which are exempt. Quizzes and forums often produce different kinds of text than file uploads, so test each activity type separately and decide whether the resulting reports are useful for that type of work.

The second decision is whether students can see similarity reports, and when. Moodle activities commonly offer options that control what students see and at which point, but the names, defaults and interaction with grade release differ by activity and version, so confirm them in your environment. Showing a report before the final submission deadline lets students revise and resubmit, which supports learning but may encourage repeated editing to reduce matches. Showing reports only after grading protects the assessment but gives students less chance to correct citation errors. Set one institutional position, document it for teachers, and check that students see grades and feedback in the same place the report appears.

The third decision is how resubmissions are handled. Ask whether each new submission is sent to Turnitin again, whether earlier reports remain visible to teachers, and how draft or unsubmitted work is treated. Also check how the Turnitin licence applies to users and activities, because the plugin requires a licence from Turnitin and your agreement will set the terms. Confirm that your Moodle version is within the range the plugin lists, which is Moodle 4.5 to 5.2 in the plugin directory listing, before testing. Record the answers in a short test script so that teachers, support staff and your Turnitin administrator follow the same process.

Security and data handling for Turnitin in Moodle

Turnitin in Moodle sends student work to an external service, changes assignment grading, and exposes similarity reports to people with the right roles. The cards below cover the contractual, access, secrets, patching, network and visibility controls that a Moodle team should confirm before the integration goes live.

Confirm data processing terms first

Before any student submission is sent to Turnitin, confirm in writing with Turnitin the terms that govern how submitted work is stored, processed, retained and deleted under your licence. Ask which data fields the Moodle plugin transmits, and where Turnitin hosts them. Privacy obligations depend on your jurisdiction, so have your legal and compliance team review those terms against your own rules.

Limit who changes plugin settings

Plugin and account settings control which assignments are sent, when reports are generated and which Turnitin account is used. Restrict the Moodle capabilities that edit these settings to a small administrator group, and review that group whenever staff change roles. Record who made each change so that a configuration drift can be traced back to a person.

Store Turnitin credentials in a secrets process

The Turnitin integration key and account details should live in a controlled secrets store with named owners, access logging and a rotation procedure, not in spreadsheets, shared drives or chat threads. Confirm with Turnitin how a key is rotated and what happens to the integration when it changes. Check that backups of the Moodle database do not expose the credentials in readable form.

Keep Moodle and PHP supported

The Turnitin plugin lists supported Moodle versions, and the plugins directory lists support from Moodle 4.5 to 5.2. Keep the Moodle core, PHP, database and Turnitin plugin on versions that both Moodle and Turnitin support, and apply security updates on a fixed schedule. Check the plugin's compatibility before every Moodle upgrade, because a plugin that falls outside its supported range can block the upgrade path.

Restrict outbound network access

Allow the Moodle server to reach only the Turnitin endpoints that the plugin documentation specifies, and block other outbound destinations by default. Confirm the endpoint list with Turnitin before setting firewall or proxy rules, and retest after any change to the plugin or to Turnitin's service. Log outbound connections so that unexpected traffic from the Moodle host can be investigated.

Review who sees reports and feedback

Similarity reports and grading feedback reach students, teachers, graders and sometimes managers, depending on the Moodle roles and course enrolments. Map each role to the Turnitin capabilities it holds, and confirm that students see only what your policy allows. Review these assignments each term, especially after course copies, role overrides or enrolment sync changes.

How to test Turnitin in Moodle before students submit work

The test plan should answer one question before any student sees the integration: does each Turnitin-enabled activity send work, return a similarity report to the right people, and pass grades and feedback back to the Moodle gradebook? Start in a dedicated test course, not a copy of a live course, so that no real student data reaches Turnitin during testing. Enrol at least one teacher account, one student account and, if your courses use them, a non-editing teacher and a second student. Create these accounts through the same authentication method your students use, so the role checks reflect production. Before the first test, confirm that the Turnitin plagiarism plugin is installed on this site and that your institution holds the licence it requires.

The first set of checks covers submission and the similarity report. Create one test activity for each type you plan to enable: assignment, forum discussion, quiz and workshop, since the plugin supports all four. Submit a document that contains original text and a passage copied from a source you control, so you know what the similarity score should roughly reflect. For each activity, confirm that a similarity report is generated and that the score appears. Then check visibility by role: the teacher should see the full report, and the student should see only what your settings allow, such as a score or no report at all. Record the setting values beside each result, because a visibility rule is only verifiable against the configuration that produced it.

Next, test the grading and feedback round trip. Grade the test submissions in Moodle, add written feedback, and confirm that the grade appears in the gradebook and that the student sees the feedback in the expected place. If you enable Turnitin grading or feedback tools, test each one separately and confirm which tool writes the grade back to Moodle. Then run the resubmission test on an assignment with resubmissions allowed. Submit a second version, confirm that the two reports can be told apart, and check how the first attempt's grade and feedback are handled under your settings. Ask the vendor to confirm how resubmitted papers are counted and stored, because that behavior affects how teachers review repeat submissions.

The test must also prove that disabled activities do not send work. Create one activity with the Turnitin option turned off, submit a file to it, and confirm that no similarity report is created and that no record of transmission appears in the plugin or Turnitin's own records. Confirm with Turnitin how to check transmission logs from your account, since the answer determines what evidence you keep. Finally, back up a test course that contains Turnitin-enabled activities, restore it to a separate course, and check that the restored activities keep their settings and still link to Turnitin. Verify whether existing reports carry over or whether work must be resubmitted, and confirm that the restored copy does not send work anywhere unexpected.

Record every check in a results log before running it. Use columns for check ID, Moodle version, plugin version, settings used, expected result, actual result, tester and date. Writing the expected result first stops the test from being judged against whatever happened. Repeat the full plan after every Moodle point release, plugin update, licence renewal or configuration change. The plugin directory lists support for Moodle 4.5 to 5.2, so if your target Moodle version falls outside that range, including the 5.3 release, confirm compatibility with Turnitin in writing before you upgrade and before you run this plan again.

Common Turnitin Moodle failures and how to fix them

This table lists the failures administrators most often meet when running Turnitin's plagiarism plugin with Moodle, with the likely cause and first fix for each. Use it to narrow a fault before you contact Turnitin or your Moodle host. Confirm every fix against the Turnitin and Moodle documentation for the exact versions you run, because supported versions and settings change between releases.

SymptomLikely causeFix
Plugin does not appear after installPlugin version does not match the Moodle version, or the install was never completed on the serverCheck the plugin's supported Moodle range against your release (the plugin directory lists 4.5 to 5.2). Confirm the upgrade ran in Site administration notifications and that the plugin folder is in place on the server.
Similarity reports do not generateTurnitin account or license not active, or outbound network access from the server is blockedConfirm the license and the Turnitin integration account are active with Turnitin. Allow the outbound connections Turnitin documents for the plugin from your Moodle server, then resubmit a test file.
Plugin disappears or breaks after a Moodle upgradeInstalled plugin version does not support the new Moodle releaseBefore upgrading, check the plugin's supported versions. Install the Turnitin plugin release that matches the target Moodle version, then run the upgrade in a staging copy first.
Site shows directory listings or errors after upgrading to Moodle 5.1 or laterWeb server document root still points to the main Moodle folder instead of the /public directoryChange the web server document root to the /public directory as described in the Moodle 5.1 release notes, then reload the site. Confirm the plugin files are in the expected location after the change.
Grades or feedback do not return to MoodleActivity-level Turnitin settings are not enabled, or user roles lack the capabilities the plugin needsCheck the Turnitin settings on each affected assignment, forum, quiz or workshop. Review role permissions for teachers and the account Turnitin uses, then resubmit one test submission.
Turnitin-enabled course fails after restorePlugin settings or Turnitin configuration are not present on the target siteInstall and configure the same Turnitin plugin version and license on the target site before restoring. Confirm the plugin settings are in place, then restore the course and check each Turnitin-enabled activity.

Questions buyers ask about Moodle Turnitin integration

How much does a Turnitin license cost for Moodle?

Turnitin sets the license price through its own agreement, so Turnitin is the only source of an accurate figure. DeployOpen does not supply the license and does not estimate its price. Ask Turnitin for a written quote that explains how it calculates pricing for your institution, what is included, what renews each year and how costs change if usage grows.

Keep the two costs separate. The license is a recurring fee paid to Turnitin. The integration work is a one-time project for configuration, testing and handover, plus any ongoing support you choose to buy. Ask for the integration scope in writing so you can compare it with the internal effort your team would spend.

What makes a Moodle Turnitin integration take more effort?

Scope and environment drive most of the effort. The main factors are:

  • Activities enabled: assignments, forums, quizzes and workshops each have their own settings and grading flows.
  • Moodle sites or environments: each site needs its own configuration and testing.
  • Moodle version: the plugin lists supported versions, and each upgrade path adds testing.
  • Existing course data: past submissions, grades and activities need a decision on how Turnitin applies to them.
  • Privacy review: your institution's review of student data handling adds documentation and sign-off work outside the technical build.

Ask for each driver to be stated in the written scope so that any change can be assessed against it.

How long does it take to add Turnitin to Moodle?

The timeline depends on the agreed scope and on the Turnitin account steps, so no fixed duration applies to every institution. A typical sequence covers account setup by the institution's Turnitin account owner, plugin configuration in a test environment, acceptance testing by staff, and then the production change.

Several of these steps wait on people outside the build team, so calendar time often runs longer than working time. DeployOpen agrees a timeline in writing after scoping. It should name who must act at each step and what happens if a Turnitin step is delayed. Ask Turnitin what its account setup currently requires before you commit to dates.

What does our institution need to provide for the work?

Five inputs are needed before the work starts:

  • Moodle administrator access: to install and configure the plugin on each site in scope.
  • A Turnitin account owner: a named person who can complete account setup and manage the license with Turnitin.
  • A test course: a non-production course where staff can try each activity type before live use.
  • Acceptance testing staff: instructors and administrators who check grading, feedback and similarity reports against your process.
  • A decision on activities: which activity types will use Turnitin and which will not.

Confirm these in the written scope, including who on your side owns each one and how long reviews are expected to take.

Can our own Moodle team install the Turnitin integration?

Yes, if your team has Moodle administration skills and follows Turnitin's documentation for the plugin. Your team would handle the account setup, configuration, test course, acceptance testing and change control.

An outside partner can cover the parts your team lacks, such as hardening a production site, testing across several environments or documenting the setup for future upgrades. Whichever route you choose, decide who owns the Moodle upgrade checks, since the Turnitin plugin must be verified against each new Moodle version you plan to run.

Does DeployOpen supply the Turnitin license itself?

No. The Turnitin license comes from Turnitin under Turnitin's own agreement. DeployOpen plans, configures, tests and documents the integration on your Moodle sites, but it does not sell, resell or hold the license for you.

Before scoping, confirm with Turnitin that your account and agreement cover the Moodle sites and activity types you plan to use. The license terms set what the institution may do with the plugin, so review them with your procurement and legal teams.

Which Moodle versions does the Turnitin plugin support?

The Turnitin plagiarism plugin is listed in the Moodle plugins directory as supporting Moodle 4.5 to 5.2. Check that range against the version you run before you plan the work.

Moodle 5.3 is the next long-term support release, released on 5 October 2026, and it falls outside that listed range. Confirm current compatibility with Turnitin before you plan an upgrade to 5.3, and ask whether a newer plugin version is needed. Also check the minimum PHP and database versions for your Moodle release in the Moodle release notes.

What should we check before turning Turnitin on in live courses?

Confirm four things before enabling Turnitin for students:

  • Privacy review: that your institution has approved how submitted work is sent to and stored by Turnitin.
  • Activity settings: that each enabled activity type behaves as your grading policy requires in the test course.
  • Backups: that you have a tested backup of each Moodle site before the production change.
  • Staff readiness: that instructors know how similarity reports, grading and feedback appear and who handles questions.

Record the decisions in the written scope so the production change can be checked against them.

How DeployOpen scopes and delivers a Turnitin integration for Moodle

DeployOpen plans and delivers the Turnitin plagiarism plugin inside a Moodle site that runs in your own infrastructure. Before any build starts, we confirm the Moodle version, the Turnitin licence and the activities that will send work for similarity checking, then record the result in a written scope. Engagements are fixed-scope, and ongoing support is available as a retainer.

How we scope

  • Confirm your Moodle version against the Turnitin plugin's supported range of 4.5 to 5.2
  • Confirm the Turnitin licence, who holds it and which activities it must cover before build starts
  • Agree in writing which assignments, discussions, quizzes and workshops will send submissions to Turnitin

How we build

  • Install and configure the Turnitin plugin on a staging copy of your Moodle site first
  • Test similarity reports, grading and feedback on sample assignments, discussions, quizzes and workshops
  • Document server configuration and plugin requirements, and confirm them before production cutover

How we hand over

  • Provide a written runbook covering plugin settings, licence details and how each course enables Turnitin
  • Run a walkthrough for teachers on reading similarity reports and leaving grades and feedback in Moodle
  • Supply upgrade notes that check each planned Moodle release against the plugin's supported versions

How we support

  • Offer ongoing support as a retainer covering plugin updates and Moodle upgrade testing
  • Recheck plugin compatibility as Moodle point releases and new major versions are published
  • Investigate failed submissions, licence errors and delayed similarity reports under the agreed support terms

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.