Competency and Logbook Data Model

Purpose

This page separates four records that are often confused:

the curriculum competency and its completion rule;
the learner’s logbook entry;
evidence contributed by that entry or another authoritative source; and
the decision that certifies the learner’s competency.

No entry can define its own competency, required count, reviewer, or certification standard.

Ownership map

academic.curriculum_version                              Setup
├── academic.competency                                  Setup
├── academic.logbook_requirement_definition              Setup
│   ├── course, posting, elective, or longitudinal home
│   ├── permitted evidence and completion rule
│   └── review and certification authority rule
│
└── competency.student_logbook                           Competency and Logbook
    ├── competency.logbook_section
    ├── competency.logbook_entry
    │   ├── context and evidence
    │   └── faculty review tasks and decisions
    ├── competency.learner_competency
    │   ├── evidence timeline
    │   └── certification decisions
    ├── remediation requirements and attempts
    └── section-completion reviews

Course delivery, clinical-posting delivery, attendance, and assessment remain authoritative in their owning modules. This module stores typed references to those sources rather than copying their facts into editable logbook fields.

Curriculum-owned definitions

Logbook requirement definition

Every learner entry begins from academic.logbook_requirement_definition.

Field	Meaning
`curriculum_version_id`	Exact published curriculum version owning the requirement
`code`, `name`	Stable identity and learner-facing title within the version
`stage_id`	Phase in which the requirement is expected or reviewed
`component_type`	Course, Clinical Posting, Elective, Longitudinal, Foundation, or another supported type
`course_placement_id`	Responsible curriculum course placement when course-owned
`clinical_posting_requirement_id`	Posting requirement when posting-owned
`curriculum_requirement_id`	Longitudinal or standalone requirement where applicable
`activity_type`	Case record, procedure, skill, reflection, visit, presentation, observed activity, or another controlled type
`evidence_rule`	Required learner fields, attachments, observation, reflection, or source evidence
`required_count`	Number of accepted entries or successful performances where applicable
`completion_method`	Exposure, Faculty Verification, Repeated Performance, Assessment, Portfolio, or Combined
`mandatory_state`	Mandatory, conditional, elective, or enrichment
`source_reference`	NMC, university, or approved institute source

Exactly one primary curriculum home is required. Optional contribution relationships can connect the requirement to other courses or postings without changing its owner.

Competency relationship

One logbook requirement may contribute to several competencies, and one competency may receive evidence from several requirements.

academic.logbook_requirement_competency
- logbook_requirement_definition_id
- curriculum_competency_id
- relationship_type
- evidence_weight_or_purpose

The relationship type can identify Primary Evidence, Contributing Evidence, Required Performance, or Exposure Only.

Review and certification rule

The curriculum defines the eligibility rule, not named faculty members.

Field	Meaning
`entry_verifier_context`	Actual supervisor, assigned course faculty, assigned unit faculty, or another supported context
`verifier_department_scope`	Responsible, contributing, or assigned department
`certification_authority_type`	Course Coordinator, designation-authorised unit/department faculty, or configured longitudinal coordinator
`same_verifier_may_certify`	Whether one eligible person may perform both decisions
`direct_observation_required`	Whether certification requires a directly observed activity
`successful_performances_required`	Accepted performances needed before certification
`multiple_certifiers_required`	Number of independent certification decisions where applicable

Eligible designations are stored in typed relationships:

academic.competency_verifier_designation
academic.competency_certifier_designation

Changing the actual faculty member does not change the curriculum. Changing a published academic certification standard requires a successor curriculum version.

Operational records

Record	Purpose
`competency.student_logbook`	One learner logbook for one programme enrolment and curriculum version
`competency.logbook_section`	Phase, course, posting, elective, or longitudinal section within the learner logbook
`competency.logbook_entry`	One learner submission or supported system-created entry against a defined requirement
`competency.logbook_entry_context`	Connects the entry to an actual course delivery, posting occurrence, department, unit, supervisor, or elective activity
`competency.logbook_entry_evidence`	Stores permitted learner evidence metadata, file references, reflection, or structured response
`competency.logbook_entry_competency`	Connects the entry to one or more curriculum competencies through the definition’s permitted mappings
`competency.logbook_review_task`	Routes a submitted entry to a resolved eligible faculty reviewer
`competency.logbook_review_decision`	Stores verification, return, repeat, remediation, or invalid-context decision and feedback
`competency.learner_competency`	Maintains the learner’s current state for one competency in the pinned curriculum version
`competency.competency_evidence`	Normalised evidence from logbook, delivery, attendance, or future assessment sources
`competency.competency_certification_task`	Routes an eligible learner competency to the permitted certification authority
`competency.competency_certification`	Stores the final certification or return decision and its supporting evidence snapshot
`competency.remediation_requirement`	Defines a named deficiency, required corrective work, reviewer, and due state
`competency.logbook_section_review`	Stores submission, return, completion, or exception decision for a course or posting section
`competency.competency_event`	Preserves every material state change, actor, authority, reason, and time

Learner logbook identity

One learner receives one logbook for the programme enrolment and the curriculum version pinned to the cohort.

competency.student_logbook
- tenant_id
- institute_id
- student_id
- programme_enrolment_id
- curriculum_version_id
- opened_at
- status

The logbook contains many sections. A course or posting workspace presents its own section, while My Logbook presents all permitted sections together.

A later curriculum version does not silently change the learner’s requirements. An approved curriculum migration must state how incomplete, completed, and certified items are treated.

Logbook entry record

Field	Meaning
`student_logbook_id`	Learner and curriculum identity
`logbook_section_id`	Course, posting, phase, elective, or longitudinal section
`requirement_definition_id`	Exact curriculum-owned requirement
`attempt_number`	First, repeat, or remediation attempt number
`activity_date`	Date on which the claimed activity occurred
`entry_source`	Learner, System Exposure, Verified Import, or another controlled source
`state`	Draft, Submitted, Under Review, Returned, Verified, Withdrawn, or Superseded
`submitted_at`	Time at which the learner declared the evidence ready for review
`row_version`	Prevents one action from overwriting another user’s work

The entry cannot link to an arbitrary competency. Its competency relationships must be allowed by the selected requirement definition.

Context and privacy

competency.logbook_entry_context records why the learner and reviewer are connected to the activity.

It may reference:

cohort course offering and course delivery record;
clinical-posting assignment and dated occurrence;
department and unit;
actual supervising faculty assignment;
elective block or longitudinal activity; and
authorised individual exception.

Clinical evidence uses controlled educational categories and de-identified content. Where the hospital source must be traceable, MedCES stores a protected external reference rather than recreating the complete patient record.

Evidence sources

competency.competency_evidence provides one evidence timeline regardless of source.

Evidence type	Authoritative source	Meaning
Teaching Exposure	Conducted course delivery plus finalised attendance	Learner attended teaching in which the competency was actually covered
Observed Activity	Verified logbook entry	Faculty accepted that the learner completed the activity
Successful Performance	Verified entry with successful performance decision	Counts toward a repeated-performance requirement
Assessment Evidence	Assessment outcome	Learner achieved a defined mapped assessment result
Remediation Evidence	Completed remediation entry or activity	Learner completed named corrective work
Certification	Competency-certification decision	Authorised faculty confirmed the required competency

Teaching Exposure can be created automatically only when:

the session was actually conducted;
faculty confirmed that the competency was covered;
attendance was finalised; and
the learner’s final status qualifies under the evidence rule.

Exposure never creates Certification.

Entry review authorisation

When an entry is submitted, the process layer resolves an eligible reviewer from its retained context.

Entry context
  -> actual supervisor or assigned course faculty
  -> active Faculty role
  -> eligible designation
  -> department or unit association
  -> effective course or posting assignment
  -> no blocking conflict
  -> review task

The task stores both the resolved user and why that user was eligible. If reassigned, the earlier assignment and reason remain in history.

An administrator may route work but cannot acquire academic verification capability through reassignment.

Course certification

A course-based competency identifies one responsible curriculum course placement. Evidence may come from lectures, practicals, assessments, and contributing courses.

When the completion rule is satisfied, MedCES creates a certification task for the current Course Coordinator. The coordinator sees the retained evidence snapshot, missing-data state, previous remediation, and any contributing-source results.

Bulk certification is permitted only when every selected learner satisfies the same rule and the coordinator explicitly confirms the action. Each learner receives an individual certification record.

Clinical-posting certification

For posting-linked competency evidence:

the actual supervisor is the preferred entry verifier;
another eligible faculty member in the same unit is the first fallback;
eligible senior faculty in the unit is the next level;
eligible faculty in the responsible department is the department fallback; and
a configured department authority may decide an exception or reassignment.

Every step applies the allowed designations, effective assignments, dates, and department or unit scope stored by the curriculum rule and Setup records.

Competency state

competency.learner_competency is a projection over immutable evidence and decisions.

Supported states are:

Not Started;
Exposed;
Evidence Accumulating;
Assessed;
Eligible for Certification;
Certification Pending;
Certified; and
Remediation Required.

The projection records the calculation time and source versions. It can be rebuilt without changing historical evidence.

Section completion

A logbook section belongs to one curriculum home and applicable learner period.

Course section closure checks:

mandatory entries;
required verified evidence;
course-owned competency certification;
unresolved returns or remediation;
future assessment evidence where required; and
the configured logbook assessment state.

Posting section closure also checks posting delivery, attendance, required cases or procedures, unit evidence, and clinical competency certification.

If a required source is missing or unfinalised, the result is Unable to Evaluate, not Failed or Complete.

Process-layer responsibilities

The process layer must:

create one learner logbook from the exact pinned curriculum version;
create required sections and definitions without duplicating them;
prevent unrestricted blank entries or arbitrary competency links;
prefill course, posting, unit, supervisor, and learner context from authoritative records;
enforce evidence fields, file rules, privacy declarations, and submission requirements;
retain attempts rather than overwriting unsuccessful work;
resolve reviewers using role, designation, scope, assignment, dates, and curriculum rules;
keep entry verification separate from competency certification;
normalise evidence from delivery, attendance, logbook, and future assessment sources;
create teaching exposure only from conducted, covered, and finalised activity;
prevent teaching exposure from becoming automatic certification;
count successful performances without counting duplicates or invalidated evidence;
route course-owned certification to the Course Coordinator;
route posting certification through the unit and department designation chain;
support safe bulk decisions with one result per learner;
create, monitor, and reconcile remediation;
calculate course and posting section readiness with plain explanations;
expose stable completion facts without making eligibility or progression decisions; and
preserve every submission, assignment, review, feedback, correction, certification, and section decision.

Module boundaries

Setup owns competency definitions, course and posting relationships, logbook requirements, completion methods, evidence rules, and eligible designations.
Academic Planning and Delivery owns course sessions, actual delivery, posting occurrences, supervisors, units, sites, and attendance handoff.
Attendance owns attendance facts and calculations.
Competency and Logbook owns learner evidence, reviews, competency state, certification, remediation, and logbook-section completion.
Assessment and Examination will own assessment events, marks, results, and assessment-based evidence.
Student and Cohort Management consumes completed academic facts for progression and lifecycle work.

No module may update another module’s source fact merely to obtain a desired competency or completion result.