MongoDB document not persisting modified subdocument changes

I'm running into a strange issue when updating a Mongoose document.

I'm trying to update a field (paymentType) inside an array of subdocuments (students) in a Teacher document. Both console.log(teacher) and console.log(teacher.students) show the changes correctly, and everything looks fine before the await teacher.save() call.

However, the changes are not persisted to the database — the paymentType field remains unchanged after saving. There are no errors thrown, and the document appears to save "successfully" in the code.

The Route:

// Route 5: Update student payment types
router.put(
  "/api/analytics/students/payment-types",
  passport.authenticate("jwt", { session: false }),
  async (req, res) => {
    const { user } = req;
    const { students } = req.body;

    try {
      const teacher = await Teacher.findOne({ user: user._id });

      if (!teacher) {
        return res.status(404).json({
          message: "Teacher not found",
        });
      }

      // Validation
      if (!Array.isArray(students)) {
        return res.status(400).json({
          message: "'students' must be an array",
        });
      }

      // Updating
      for (const studentUpdate of students) {
        if (
          !studentUpdate.studentId ||
          !mongoose.Types.ObjectId.isValid(studentUpdate.studentId)
        ) {
          return res.status(400).json({
            message: `Invalid or missing studentId: ${studentUpdate.studentId}`,
          });
        }

        if (
          studentUpdate.paymentType &&
          !mongoose.Types.ObjectId.isValid(studentUpdate.paymentType)
        ) {
          return res.status(400).json({
            message: `Invalid paymentType for student ${studentUpdate.studentId}`,
          });
        }

        const studentIndex = teacher.students.findIndex(
          (s) => s.studentId.toString() === studentUpdate.studentId
        );

        if (studentIndex !== -1) {
          teacher.students[studentIndex].payment =
            studentUpdate.paymentType || null;
        }
      }

      teacher.markModified("students");
      console.log(teacher.isModified());
      console.log(teacher.students);
      await teacher.save();

      res.status(200).json({
        message: "Student payment types updated successfully",
        success: true,
      });
    } catch (error) {
      console.error("Error updating payment types:", error);
      res.status(500).json({
        message: "Error updating student payment types",
      });
    }
  }
);

The Model:

const TeacherSchema = new mongoose.Schema(
// other fields
students: [
      {
        studentId: {
          type: ObjectId,
          ref: "User",
          required: true,
        },
        payment: {
          type: ObjectId,
          required: false,
        },
      },
    ],
)

Here’s what I’ve tried:

• Confirmed that the student is being found and modified in the array.

• Added teacher.markModified("students") before saving.

• Logged the document before saving — the updates are clearly present.

• Verified the schema definition includes paymentType in the students subdocument.

Still, the database document doesn’t reflect the change.

Has anyone encountered something like this? Any ideas on what could cause teacher.save() to silently fail to persist a subdocument change?

Your subdocument array is not being treated as fully nested subdocuments, but rather as plain objects due to missing Schema.Types.ObjectId declaration in the payment field — and/or you're not using a subdocument schema. When arrays of subdocuments are just plain objects (not actual Mongoose subdocs), changes to their fields often aren't tracked properly, even with markModified().

Create a StudentSchema separately and use it in your TeacherSchema
This ensures each item in students is a Mongoose subdocument with change tracking
Now teacher.students[0].payment = xyz will work without hacks
Saves will persist properly without needing markModified() in most cases

const mongoose = require("mongoose");
const { Schema, Types } = mongoose;

const StudentSchema = new Schema({
  studentId: {
    type: Types.ObjectId,
    ref: "User",
    required: true,
  },
  payment: {
    type: Types.ObjectId,
    ref: "PaymentType",
    required: false,
  },
});

const TeacherSchema = new Schema({
  // other fields...
  students: [StudentSchema],
});

module.exports = mongoose.model("Teacher", TeacherSchema);