I'm going to expand a little on the subject to help a complete beginner as I started.

Boot process

First hard drive is typically split into 2 sections :

one for boot process (the section read by the computer when you power it up) typycally called /dev/sda1 under most linux distribution
one for all the other things (like system and user files) nammed /dev/sdb1. (system and user files can be on different sections)

On the boot sector there is a kernel image, which is actually an initramfs image. An intramfs is "the smallest" functionnal system that is loaded into the RAM. It can be seen as a small version of your linux system : you will find modules, some directories that you see on your habitual system but with a different content. That small linux system is used to look at your computer configuration (what type of storage device you use, what are your compenents, etc) to load correct modules that will be used by your real system AND figure out where on your storage device is your real system files to make it accessible for later. In other words, when you power up your computer it reads the /dev/sda1 partiion and try to find the partition /dev/sdb1 for a later use. But to understand how your files are accessible you need to understand mount points

Mountpoint

Under linux, all directories are accessible under a single one called the root, which is /. Do not mixe root user storage /root with the root of the filesystem/. When you plug an external storage device, like an USB drive, your system will create a new directory and use it as the root for that device. In other words, under that directory you can access all files that are store on it. That directory is called a mountpoint. To create a mountpoint you need to have a device (an USB for example), a directory and an filesystem (a program that is used as an interface between your userspace programs and the physical memory of your device) and then use the following command :

mount -t name_filesystem name_device name_directory

Technically when you plug something you need to manually mount the device. But linux do it automatically when you plug a common device (like an USB). All the internal devices of your computer are automatically mounted during the boot thanks to the file file /etc/fstab which contains all the needed informations to mount them (like the partitions of your harddrive, cd-ROM reader, ...) To see all the other mountpoints currently used by the system you can see /proc/mounts

Mounting root filesystem at boot

Back to the boot process, when the initramfs image is loaded into the memory, it check which parition of your hard drive is used to store your files (like /dev/sdb1) and mount it under the root of your filesystem commonly called /root. That /root is not the same as the /root under your userspace (when your system is completly loaded). Under that /root you will have access to all your files and the /root you know :

/root <--- initramfs
   /home
      /myName
        ... all my files
   /root <--- super user

The root filesystem is mounted as read-only during boot and then remount as read-write over a virutal filesystem (which is just a way of dealing with different devices, thus different filesystems related to each device, with same commands for programs in your userspace)

Initrd vs Initramfs

Initramfs is the sucessor of initrd which was loaded into the memory with all the needed tools to then mount the real filesystem and finally unload itself from the memory. But an initramfs stays in memory and all the system is based around the root filesystem that is mounted by the initramfs. That difference also implies different commmands (for example pivot_root became switch_root)

Edit initramfs

The kernel image that is used for the boot process can be edit whithin the system. That image is store on /boot. You can edit it by uncompressing it. The process you want to edit is the init of your image (which is the first script executed) and precisly the part when the real filesystem is mounted under /root which look like :

log_begin_msg "Mounting root file system"
# Always load local and nfs (since these might be needed for /etc or
# /usr, irrespective of the boot script used to mount the rootfs).
. /scripts/local
. /scripts/nfs
. /scripts/${BOOT}
parse_numeric ${ROOT}
maybe_break mountroot
mount_top
mount_premount
mountroot

Note that ${ROOT} contains the name of the device used for your system files (for example /dev/sdb1 but it can be different)

But that is a messy solution because when the image will be update by your system (for some reasons) your modifications will be lost. But linux has the solution to keep your modifications into all the kernel images, even after updates : initramfs-tools. All the modifications you will have to make will be done under /etc/initramfs-tools Then after you have edited your image use the following command to update the kernel image :

update-initramfs -u

That image will be used after the next reboot. Thus to avoid crashing your system use a virtual machine as virtualBox or

Once built, you'll want to install your new kernel alongside your old one, and configure the bootloader to make the kernel selectable at boot time. This way even if something goes horribly wrong, you can still boot your system using your existing kernel.

Overlay

To mount overlay over an existing directory use :

mount -t overlay -o lowerdir=/overlay/lower,upperdir=/overlay/upper,workdir=/overlay/work overlay /myDir

Note that there is absolutly no space between lowerdir=..,upperdir=...,workdir=... and the last overlay can be replace by none (because you mount nothing, no device over /myDir; you just mount overlay). And when you do something bad (if a directory does not exists or you put spaces in the options for mounting -o ... the result will be "there is no such device under /etc/fstab" (overlay manages terribly errors during mounting). You can look at that link and that one to find more help.

Under /myDir you will see all files that are in /overlay/lower and all modifications that you made (which are stored in /overlay/upper) :

/overlay/lower      /overlay/upper          /myDir (mountpoint)
   /file1  ---------->  /file1   --------->   /file1
      'abcdef'            'abOdef'               'abOdef'
   /file2 -------------------------------->   /file2

tmpfs

tmpfs is a filesystem that can manipulate the RAM as a standard memory. To create a ram-disk (a piece of the RAM that act like a piece of an hard drive) use :

mount -t tmpfs none /myDir
           or
mount -t tmpfs tmpfs /myDir

Then all operations made into /myDir will be saved into the RAM.

Solution

Modules

Add overlay module to the kernel image (so the module can be used during the boot process). Add overlay into the file /etc/initramfs-tools/modules

Hooks

Add the following script into /etc/initramfs-tools/hooks (as an executable)

#!/bin/sh

#set kernel functions file as sources (so these functions can be used)
. /usr/share/initramfs-tools/scripts/functions
. /usr/share/initramfs-tools/hook-functions

#If you want to use a custom package into the initramfs use 
#copy_exec path_to_package
#For example if you want to use whiptail add : copy_exec /usr/bin/whiptail

Script

Add the following script into /etc/initramfs-tools/scripts/init-bottom (as an executable)

#!/bin/sh

PREREQ=""
prereqs()
{
   echo "$PREREQ"
}

case $1 in
prereqs)
   prereqs
   exit 0
   ;;
esac

DIR=/overlay
UPPER_DIR=$DIR/upper
LOWER_DIR=$DIR/lower
WORK_DIR=$DIR/work

mkdir $DIR
#create temporary filesystem in RAM
mount -t tmpfs tmpfs $DIR
if [ $? -ne 0 ]; then
    fail_err "Fail to mount tmpfs on $DIR"
    exit 1
fi

#create lower, upper and workdir for overlay
mkdir $UPPER_DIR $LOWER_DIR $WORK_DIR

# move root mountpoint to the lower layer
mount -n -o move ${rootmnt} $LOWER_DIR
if [ $? -ne 0 ]; then
    fail_err "Cannot move ${rootmnt} to $LOWER_DIR"
    exit 1
fi

#mount overlay on to the root
mount -t overlay -o lowerdir=$LOWER_DIR,upperdir=$UPPER_DIR,workdir=$WORK_DIR overlay ${rootmnt}
if [ $? -ne 0 ]; then
    fail_err "Cannot mount overlay on ${rootmnt} [lowerdir=$LOWER_DIR, upperdir=$UPPER_DIR, workdir=$WORK_DIR]"
    exit 1
fi

#mount virtual filesystem over the lower dir (as it's donne for the root with /proc and /sysfs which are mounted on to the root at the end of the init)

#uncomment that section if you want to access the layers of overlay whithin userspace
#mkdir -p ${rootmnt}$DIR
#mount -n -o rbind $DIR ${rootmnt}$DIR
#if [ $? -ne 0 ]; then
#    fail_err "Cannot remount ${rootmnt} and its sub mountpoints on ${rootmnt}$DIR"
#    exit 1
#fi

# edit fstab to match the actual modifications

#get the device that is mounted on the rootfilesystem
root_device="$(awk '$2 == "/" {print $0}' ${rootmnt}/etc/fstab)"
#check if that device exists
blkid $root_device
if [ ! $? -gt 0 ]; then
    target=${rootmnt}/etc/fstab
    target_c=$target.orig
    #create a copy of the file (that will be accessible later)
    cp $target $target_c
    #remove the root device from the file
    grep -v "$root_device" $target_c > $target

    #add overlay on root as a device in the file
    awk '$2 == "'${rootmnt}'" { $2 = "/" ; print $0}' /etc/mtab >> $target
fi

Update

Update the kernel image with : update-initramfs -u