diff --git a/src/cmd/cos_customizer/DESIGN.md b/src/cmd/cos_customizer/DESIGN.md
new file mode 100644
index 0000000..50b2430
--- /dev/null
+++ b/src/cmd/cos_customizer/DESIGN.md
@@ -0,0 +1,43 @@
+# COS Customizer Design
+
+The design can be thought of as steps that aren't the `finish-image-build` step
+and the step that is.
+
+## Steps that aren't `finish-image-build`
+
+The start-image and all optional steps are involved in creating and modifying a pair of configs
+called the `prov.config` and `build.config`. Both these configs live on the Cloud Build VM (the builder VM),
+The `build.config` instructs
+[Daisy](https://github.com/GoogleCloudPlatform/compute-image-tools/tree/master/daisy)
+on which resources (disks, vm's) to create and which project to create them in.
+The `prov.config` file is used to instruct the provisioner, a binary that is executed
+on the "preload VM", a VM whose bootdisk is exported as the customized image.
+The provisioner is the binary that executes all optional steps that a user will have
+specified. For example, run-script, install-gpu, seal-oem, and anthos-install are all
+steps that the provisioner has implemented.
+
+## The `finish-image-build` step
+
+This step is implemented in two phases:
+
+1. The preloading phase
+2. The provisioner phase
+
+The *preloading phase* calls a command line tool called 
+[daisy](https://github.com/GoogleCloudPlatform/compute-daisy)
+and is implemented here
+[preloader](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/pkg/preloader).
+The preloader generates a daisy config file based on the buildspec and calls daisy which
+creates all the GCP resources necessary for creating a custom COS image. A few disks
+and a VM are created, and the disks are mounted to the VM. One of these disks is the boot
+disk which is what will eventually be exported as the customized COS image. Another disk is called "cidata"
+which packages the provisioner and the provisioner's configs which will be used in the next step.
+
+The *provisioner phase* calls a command line tool called the 
+[provisioner](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/cmd/provisioner)
+that gets pulled into the preload VM from the previously mentioned "cidata" disk. 
+The provisioner is what executes the optional
+steps that you have specified in your `cloudbuild.yaml` file. It will run any scripts
+install any artifacts, or seal any partitions that were specified prior to this
+step. Once it finishes executing, the preloading phase will proceed to cleanup any left over resources
+and exit the build.
diff --git a/src/cmd/cos_customizer/README.md b/src/cmd/cos_customizer/README.md
index 1fa77e7..4a6cf7c 100644
--- a/src/cmd/cos_customizer/README.md
+++ b/src/cmd/cos_customizer/README.md
@@ -60,6 +60,11 @@
 `disable-auto-update` allows users to disable the auto-update service. And it
 will reclaim the disk space of the unused root partition.
 
+### COS Customizer Design
+
+See the `DESIGN.md` document for more information on the design particulars
+of the customizer.
+
 ### Minimal example
 
 Here is a minimal Google Cloud Build workflow demonstrating usage of the COS
@@ -332,7 +337,9 @@
 
 The `install-gpu` build step configures the image build to install GPU drivers
 on the builder VM. GPU drivers are installed using the
-[COS GPU installer](https://github.com/GoogleCloudPlatform/cos-gpu-installer).
+[COS GPU installer](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/cmd/cos_gpu_installer_v1/).
+Currently, this installer gets pulled from GCR at runtime onto the preload VM meaning that
+the preload VM must have access to gcr.
 In addition to installing GPU drivers, the `install-gpu` step installs a script
 named `setup_gpu.sh` in the GPU driver install directory. _In order to use the
 installed GPU drivers, this script must be run every time the system boots_. It
diff --git a/src/cmd/provisioner/README.md b/src/cmd/provisioner/README.md
new file mode 100644
index 0000000..b303169
--- /dev/null
+++ b/src/cmd/provisioner/README.md
@@ -0,0 +1,28 @@
+# The Provisioner
+
+This tool is not meant to be invoked directly and is instead meant to run on the preload vm
+created by the `finish-image-build` step in the
+[cos-customizer](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/cmd/cos_customizer/)
+
+The command line tool and it's configs are packaged in an image named cidata that is formatted with the
+FAT filesystem. This image is uploaded and mounted onto the preload VM at `/mnt/disks/cidata` and the
+provisioner is executed by a cloud-init script called
+[startup.yaml](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/data/startup.yaml).
+This cloud-init file creates two files:
+
+- `/tmp/startup.sh`
+- `/etc/systemd/system/customizer@.service`
+
+The systemd service customizer@.service calls the startup.sh script which will then call the provisioner.
+The provisioner reads from a file called the `prov.config`, also packaged in the cidata disk, which contains all
+the optional steps specified by the cos_customizer. The implementation of these steps are located at //src/pkg/provisioner.
+Here are the available implementations of those steps:
+
+- disable_auto_update_step.go
+- install_gpu_step.go
+- install_packages_step.go
+- run_script_step.go
+- seal_oem_step.go
+
+You'll notice that these steps map exactly to the optional steps in the
+[cos-customizer](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/cmd/cos_customizer/).
\ No newline at end of file
diff --git a/src/pkg/preloader/README.md b/src/pkg/preloader/README.md
new file mode 100644
index 0000000..a24a6ec
--- /dev/null
+++ b/src/pkg/preloader/README.md
@@ -0,0 +1,25 @@
+# The Preloader
+
+This package is a wrapper around
+[daisy](https://github.com/GoogleCloudPlatform/compute-daisy).
+It pulls in config information from the `build.config` file that is generated by the `cos_customizer`
+which is indirectly populated by the user provided `cloudbuild.yaml` config.
+The preloader takes this information and generates a daisy config using this template here:
+
+`src/data/build_image.wf.json`
+
+Once daisy is called and all resources are created, cloud-init will execute the
+[provisioner](https://cos.googlesource.com/cos/tools/+/refs/heads/master/src/cmd/provisioner)
+which is the next step of the process. Once cloud-init is done and the provisioner runs to
+completion, control will be handed back to daisy which will clean up any unecessary resources
+and exit the build.
+
+The provisioner is packaged in an image called `cidata` built in this directory's `BUILD.bazel`
+file. The image is created, artifacts are copied into the image, and the image is then embedded in
+`preload.go` where it is then later uploaded to GCS to create a disk to be mounted to the preload
+VM.
+
+A scratch image is also built in the same `BUILD.bazel` file and is used for the `install-gpu` step
+so that the toolchain isn't installed onto the boot disk and is instead bindmounted and executed
+from temporary storage. Much like cidata, the scratch image is also embedded in the `preload.go`
+file and uploaded to GCS to allow daisy to create a temporary ext4 disk for gpu installation.
\ No newline at end of file