How do a create an array subdocument that references "guests" from another model at a future date?

I have an events model where guests can "signup" and join the event. Each event is a contest so it has a max amount of "guests" for each as certain slots are labeled as "winners". To ensure prizes aren't over allocated during the guest signups, I'd like to pre-built the embedded guests array as the event is created.

However, when doing so I receive cast error Cast to ObjectId failed for value "{}" (type Object) at path "guests" because I don't have objectIds for each guest yet...

This is by design as the placeholders are built with the "winner" or "loser" status so guests can immediately be notified as they sign up and are slotted into the array.

Is there a way to get my events model to reference guests and still control for:

1. The number of winners
2. Providing immediate feedback (winner/loser) to each guest as they sign up

Event.js

const eventSchema = new Schema({
  qr_name: {
    type: String,
    required: [true, 'Enter a name for your QR code'],
  },
  event_name: String,
  location_name: String,
  description: String,
  conversions: [ conversionsSchema ],
  image: [ImageSchema],
  address: String,
  geometry: {
    type: {
      type: String,
      enum: ['Point'],
    },
    coordinates: {
      type: [Number],
    }
  },
  user: {
    type: Schema.Types.ObjectId,
    ref: 'User'
  },
  qr: {
    type: Schema.Types.ObjectId,
    ref: 'Qr'
  },
  guests: [
    {
      type: Schema.Types.ObjectId,
      ref: 'Guest',
      default: null,
    },
    {
      giveaway_interest: {
        type: String,
      },
      redeemed: {
        type: String,
        default: "No",
        date: {
          type: Date,
          default: Date.now,
        },
        updatedBy: String,
        comments: String,
      },
      notified: {
        type: String,
        default: "No",
        date: {
          type: Date,
          default: Date.now,
        },
      },
      winner: {
        type: Boolean,
        default: 0,
      },
    },
  ],
  created: {
    type: Date,  // Captures both date and time
    default: Date.now
  },
  event_start: {
    type: Date,
    required: [true, 'Date & time of event start required']
  },
  event_end: {
    type: Date,
    required: [true, 'Date & time of event end required']
  },
}, opts);

Guest.js

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const guestSchema = new Schema({
    email: {
        type: String,
        default: null
    },
    firstName: {
        type: String,
        default: null
    },
    lastName: { 
        type: String,
        default: null
    },
    age: {
        type: Number,
        default: 0
    },
    gender: {
        type: String,
        enum: ['m', 'f'],
        default: null
    },
    phone: {
        type: Number,
        default: 0
    },
    zip: {
        type: Number,
        default: 0
    },
    dateAdded: {
        type: Date,
        default: Date.now
    },
    event: {
        type: Schema.Types.ObjectId,
        ref: 'Event',
        attended: String
    },
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
    }
});

You have 2 documents in the guests definition. Considering your description I believe you meant to have:

  guests: [
    {
      guest: {
        type: Schema.Types.ObjectId,
        ref: 'Guest',
        default: null,
      },
      giveaway_interest: {
        type: String,
      },
      redeemed: {
        type: String,
        default: "No",
        date: {
          type: Date,
          default: Date.now,
        },
        updatedBy: String,
        comments: String,
      },
      notified: {
        type: String,
        default: "No",
        date: {
          type: Date,
          default: Date.now,
        },
      },
      winner: {
        type: Boolean,
        default: 0,
      },
    },
  ] 

See https://mongoosejs.com/docs/schematypes.html#arrays and https://masteringjs.io/tutorials/mongoose/array#document-arrays

I don't believe "prebuilding" of the array is an ideal solution "to ensure prizes aren't over allocated", as array items are not that convenient to manipulate from one hand, and having "empty" subdocuments doesn't solve anything without extensive logic on application side.
I'd go with a separate lookup collection, unless you have any other reasons to keep your schema.