Weighted final two-part grade
Coursework 72 at 40% and an exam 64 at 60% combine into a module mark of 67.2: each mark is multiplied by its weight and divided by the total weight. Percent weights or relative ones such as 2 and 3 give the same result. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Coursework
- 72
- Coursework weight
- 40
- Exam
- 64
- Exam weight
- 60
- Total weight
- 100
- Coursework weight share
- 0.4
- Exam weight share
- 0.6
- Coursework contribution
- 28.8
Many university modules publish a two-part assessment: coursework worth one stated share of the module, and a final examination worth the complementary share. Combining those two marks is not a simple average unless the weights happen to be equal. This calculator applies the standard weighted-module identity: multiply each mark by its weight, add the products, and divide by the sum of the weights. The result is a single module grade on the same scale as the two inputs. You can enter percent weights such as forty and sixty, or any pair of positive relative weights; the engine renormalizes automatically.
What a two-part weighted module grade is
A large share of undergraduate and taught-postgraduate modules split assessment into exactly two published parts: a coursework component (essays, labs, problem sets, a project) and a final examination. The handbook states each part as a weight — forty and sixty, thirty and seventy, twenty-five and seventy-five — and the official module mark is the weight-average of the two scores, not their arithmetic mean. The identity is module equals coursework times coursework weight plus exam times exam weight, all divided by the sum of the two weights.
Example: coursework seventy-two at forty percent and exam sixty-four at sixty percent. The coursework contributes twenty-eight point eight points to the module; the exam contributes thirty-eight point four; the combined module grade is sixty-seven point two. The same identity accepts relative weights that do not look like percents: two and three, or zero point four and zero point six, produce the same shares and the same module mark.
That is the search people type as weighted final two-part grade, coursework and exam module mark, or combine coursework and exam grade. It is not the inverse question “what do I still need on the final,” which solves for an unknown exam score given a target. It is not an N-category weighted score out of a chosen total, and it is not a generic statistical weighted mean of an arbitrary list.
Those landings answer different queries. Here the only moving parts are the two marks you already have and the two weights the syllabus printed next to them.
When combining coursework and exam marks matters
Programme offices and personal tutors hear “what is my module mark if I got seventy-two on the coursework and sixty-four on the exam?” more than any other arithmetic question at the end of term. A shared oracle with a published formula stops spreadsheet drift between office hours, student group chats, and departmental calculators that quietly treat weights as if they already sum to one.
Students who already know both scores — the coursework is back and the exam script is published — want the combined module number, not an inverse “what do I still need” solver. Failed validation does not consume balance. When the syllabus is a long list of uncombined categories or a remaining-exam target, use the dedicated tools for those intents; this page stays on the four-number coursework-plus-exam identity printed in most university handbooks.
What you can do with it
End-of-module mark from two published parts
Enter the coursework mark, the exam mark, and the two syllabus weights to see the official combined module grade.
FAQ
Do the two weights have to add up to 100?
No. Weights are relative. Forty and sixty, four and six, or 0.4 and 0.6 produce the same shares and the same module grade because the engine divides by the sum of the weights.
Is this the same as “what grade do I need on the final”?
No. This tool combines two marks you already have. The inverse question — the exam score still required to hit a target — is a different search and a different calculator.
What if a mark or a weight is missing, negative, or zero?
Marks must be non-negative; each weight must be strictly positive so the denominator is never zero.
Why is my module mark not the average of my two marks?
Because a plain average only works when both parts weigh the same. With coursework at 40% and the exam at 60%, the exam pulls the result closer to its own mark, so 72 and 64 give 67.2 instead of landing halfway between them.
Do both marks need to be on the same scale?
Yes. Enter both marks on the same scale, for example both as percentages from 0 to 100, and the module mark comes out on that scale too. Mixing a percentage with a mark on a different scale gives a meaningless result.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/edu/weighted-final-two-parts \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"coursework":72,"coursework_weight":40,"exam":64,"exam_weight":60}'const res = await fetch("https://api.kit.forhosting.com/edu/weighted-final-two-parts", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"coursework": 72,
"coursework_weight": 40,
"exam": 64,
"exam_weight": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/weighted-final-two-parts",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"coursework": 72,
"coursework_weight": 40,
"exam": 64,
"exam_weight": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/weighted-final-two-parts", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"coursework":72,"coursework_weight":40,"exam":64,"exam_weight":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"coursework":72,"coursework_weight":40,"exam":64,"exam_weight":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/weighted-final-two-parts", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"coursework": 72,
"coursework_weight": 40,
"exam": 64,
"exam_weight": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.weighted_final_two_parts",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Missing fields and non-positive weights fail with invalid_input instead of inventing a mark. A successful request is billed at the published $0.002; failed validation is not charged.
Input contract, renormalization, and error behaviour
Numeric strings and a trailing percent sign are accepted so a form that submits “40%” still parses. Weights are treated as relative shares: they need not sum to one hundred, because the engine divides by their total. POST a JSON body with four required finite numbers: coursework (non-negative mark on the module scale), coursework_weight (strictly positive), exam (non-negative mark on the same scale), and exam_weight (strictly positive). Aliases coursework_mark, coursework_grade, cw, assignment, and assignment_mark map to coursework; cw_weight, coursework_percent, and assignment_weight map to coursework_weight; exam_mark, exam_grade, final, final_exam, and final_mark map to exam; final_weight, exam_percent, and exam_percent_weight map to exam_weight. Optional decimals is an integer from zero to six inclusive and defaults to two; alias precision is accepted. Forty and sixty, four and six, and zero point four and zero point six all yield the same coursework_weight_share and the same module_grade. On success the body echoes the inputs, total_weight, both weight shares, both contributions to the module, module_grade rounded half-up to decimals, module_grade_raw at full working precision, plus formula and method weighted_final_two_parts for stable clients. Missing fields, non-finite values, a negative mark, a non-positive weight, and decimals outside zero through six fail with invalid_input naming the field; those validation failures are not billed. Example: coursework eighty at twenty-five percent and exam ninety at seventy-five percent yields module_grade eighty-seven point five, with contributions twenty and sixty-seven point five.
Where a two-part module-grade API earns its keep
Keep requests small, pin module_grade and the two contributions in tests, and you get reproducible two-part module marks for LMS plugins, edge workers, and classroom demos without standing up a custom grading spreadsheet of your own.
Integration use cases
Forty–sixty and twenty-five–seventy-five handbooks
Renormalized weights mean percent pairs and relative shares produce the same module_grade, so departmental schemes stay consistent.
Advising and LMS automation
Call the same deterministic API from portals or exam-board scripts so every client agrees on the two-part module mark.
Technical questions
How do I combine a coursework mark and a final exam into one module grade?
Enter coursework, coursework_weight, exam, and exam_weight. The API computes module = (coursework × coursework_weight + exam × exam_weight) / (coursework_weight + exam_weight) and returns module_grade.
What does the two-part weighted module grade calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.