Simple media ingest script Trying to script a simple command line tool for ingesting media to a target location following a structured naming convention. 

It's functional in its current state but I'd like to know if there are things to improve. 

#!/usr/local/bin/bash

#make target directory for transfer

make_directory(){

    echo -e "\n\nFollow the prompt to create a project directory.\n\n"
    sleep .5

    while [[ -z "$target_directory" ]]
        do
                echo -e "Path of target directory?"
                read target_directory
        done

    while [[ -z "$brand" ]]
        do
            echo -e "\nBrand Prefix?"
            read brand
        done

    while [[ -z "$project" ]]
        do
            echo -e "\nProject Name?"
            read project
        done

    while [[ -z "$media_type" ]]
        do
            echo -e "\nMedia Type?"
            read media_type
        done

    while [[ -z "$location" ]]
        do
            echo -e "\nLocation?"
            read location
        done

    while [[ -z "$employee" ]]
        do
            echo -e "\nEmployee?"
            read employee
        done

    path=${target_directory}/$(date +'%Y%m%d')_${brand}_${project}_${media_type}_${location}_${employee}

    echo -e "\nCreating directory: ${path}\n\n"

    mkdir -p "${path}"

}

# construct rsync command

construct_rsync(){

    echo -e "\n\nFollow the prompt to construct the rsync command.\n\n"
    while [[ -z "$source_path" ]]
    do
        echo -e "Path to source media?"
        read source_path
    done

    if [[ "$option" == "2" ]]; then
        while [[ -z "$target_directory" ]]
        do
            echo -e "Target directory?"
            read target_directory
        done
    path=$target_directory
    fi

    while true;
    do
        read -p "Additional rsync options? [y/n] " rsync_add
        case $rsync_add in
            [Yy]* )
                echo -e "\nEnter additional rsync parameters:"
                read rsync_options
                break;;
            [Nn]* )
                break;;
            *) echo "Please enter y or no!"
        esac
 done

    echo -e "\nConstructing rsync command...\n"
    sleep .5
    echo -e "Running rsync command:\n
    rsync \n
    -r \n
    --info=progress2 \n
    --log-file=${path}/$(date +'%Y%m%d')_transfer_log.txt \n
    ${rsync_options} \n
    ${source_path}/ \n
    ${path} \n"

    rsync -r --info=progress2 --log-file="${path}/$(date +'%Y%m%d')_transfer_log.txt" ${rsync_options} "${source_path}/" "${path}"
}

# log exit code of rsync

log(){

    echo -e "\nCreating error log..."
    echo $? &gt; "${path}/error_log.txt"

    sleep .5

    if [[ "$?" == "0" ]]; then
        echo -e "\nTransfer complete!"
    elif [[ "$?" != "0" ]]; then
        echo -e "\nError in transfer! Please refer to error_log.txt!"
    fi
}

# read user input and run appropriate functions

while true
do
read -p "Enter [1] to start an ingest or [2] to complete a partial ingest. " option

    case $option in

        1 )
            make_directory
            sleep .5
            construct_rsync
            sleep .5
            log
            break;;
      2 )
            construct_rsync
            sleep .5
            log
            break;;
      * )
            echo "Please enter a valid option!";;
    esac
done
Your code is pretty clear and readable. Congratulations!

Here are some suggestions:


Stop using sleep! Unless this is for a Hollywood hacker movie, it just slows things down. Nobody thinks delays are cool after the first three times you run something.
Take command-line arguments instead of prompting for everything. It's a lot easier to just put stuff into a command line than it is to respond to it at the keyboard. Something like:

ingest -t $HOME/media -b SONY -p "My Project" 


There are plenty of SO answers on how to do this.
Add some more functions! Anything you find yourself doing twice should be a function. Also, anything that you have to "break the flow" in order to do should be a function. Here are some examples:

while [[ -z "$target_directory" ]]
    do
        echo -e "Path of target directory?"
        read target_directory
    done

while [[ -z "$brand" ]]
    do
        echo -e "\nBrand Prefix?"
        read brand
    done


That's twice! Write a function to do this:

target_dir=$(prompt_for_variable target_dir 'Path of target directory?')"
brand="$(prompt_for_variable brand 'Brand Prefix?')"


Now consider this:

while true;
do
    read -p "Additional rsync options? [y/n] " rsync_add
    case $rsync_add in
        [Yy]* )


Right in the middle of "construct_rsync" you stop and loop forever prompting the user for a y/n answer. Write a function for that!

if get_yn 'Additional rsync options?'
then
     read -p "Enter the additional options: " rsync_options
fi

Don't lie to anybody, especially yourself. You have a function called construct_rsync but what does it do? It runs the command. Either change the name, or change the function.
Beware of $?. In your log function you refer to it several times. But $? is updated each time a command is run. So if you're going to make decisions based on the value, you should either capture the value into a separate variable (status=$? ... if $status) or make a single decision right up front (if $? ... else ... fi)