diff --git a/language/rust/develop.md b/language/rust/develop.md
index 926769b934..095e66082c 100644
--- a/language/rust/develop.md
+++ b/language/rust/develop.md
@@ -96,13 +96,88 @@ For the sample application, you'll use a variation of the backend from the react
    ? What port does your server listen on? 8000
    ```
 
-3. In the cloned repository's directory, run `docker build` to build the image.
+3. In the cloned repository's directory, open the `Dockerfile` in an IDE or text editor to update it.
+
+   `docker init` handled creating most of the instructions in the Dockerfile, but you'll need to update it for your unique application. In addition to a `src` directory, this application includes a `migrations` directory to initialize the database. Add a bind mount for the `migrations` directory to the build stage in the Dockerfile. The following is the updated Dockerfile.
+
+   ```dockerfile
+   # syntax=docker/dockerfile:1
+
+   # Comments are provided throughout this file to help you get started.
+   # If you need more help, visit the Dockerfile reference guide at
+   # https://docs.docker.com/engine/reference/builder/
+   
+   ################################################################################
+   # Create a stage for building the application.
+   
+   ARG RUST_VERSION=1.70.0
+   ARG APP_NAME=react-rust-postgres
+   FROM rust:${RUST_VERSION}-slim-bullseye AS build
+   ARG APP_NAME
+   WORKDIR /app
+   
+   # Build the application.
+   # Leverage a cache mount to /usr/local/cargo/registry/
+   # for downloaded dependencies and a cache mount to /app/target/ for 
+   # compiled dependencies which will speed up subsequent builds.
+   # Leverage a bind mount to the src directory to avoid having to copy the
+   # source code into the container. Once built, copy the executable to an
+   # output directory before the cache mounted /app/target is unmounted.
+   RUN --mount=type=bind,source=src,target=src \
+       --mount=type=bind,source=Cargo.toml,target=Cargo.toml \
+       --mount=type=bind,source=Cargo.lock,target=Cargo.lock \
+       --mount=type=cache,target=/app/target/ \
+       --mount=type=cache,target=/usr/local/cargo/registry/ \
+       --mount=type=bind,source=migrations,target=migrations \
+       <<EOF
+   set -e
+   cargo build --locked --release
+   cp ./target/release/$APP_NAME /bin/server
+   EOF
+   
+   ################################################################################
+   # Create a new stage for running the application that contains the minimal
+   # runtime dependencies for the application. This often uses a different base
+   # image from the build stage where the necessary files are copied from the build
+   # stage.
+   #
+   # The example below uses the debian bullseye image as the foundation for    running the app.
+   # By specifying the "bullseye-slim" tag, it will also use whatever happens to    be the
+   # most recent version of that tag when you build your Dockerfile. If
+   # reproducability is important, consider using a digest
+   # (e.g.,    debian@sha256:ac707220fbd7b67fc19b112cee8170b41a9e97f703f588b2cdbbcdcecdd8af57).
+   FROM debian:bullseye-slim AS final
+   
+   # Create a non-privileged user that the app will run under.
+   # See https://docs.docker.com/develop/develop-images/dockerfile_best-practices/   #user
+   ARG UID=10001
+   RUN adduser \
+       --disabled-password \
+       --gecos "" \
+       --home "/nonexistent" \
+       --shell "/sbin/nologin" \
+       --no-create-home \
+       --uid "${UID}" \
+       appuser
+   USER appuser
+   
+   # Copy the executable from the "build" stage.
+   COPY --from=build /bin/server /bin/
+   
+   # Expose the port that the application listens on.
+   EXPOSE 8000
+   
+   # What the container should run when it is started.
+   CMD ["/bin/server"]
+   ```
+
+4. In the cloned repository's directory, run `docker build` to build the image.
 
    ```console
    $ docker build -t rust-backend-image .
    ```
 
-4. Run `docker run` to run the image as a container on the same network as the database.
+5. Run `docker run` with the following options to run the image as a container on the same network as the database.
 
    ```console
    $ docker run \
@@ -114,12 +189,12 @@ For the sample application, you'll use a variation of the backend from the react
      -e PG_HOST=db \
      -e PG_USER=postgres \
      -e PG_PASSWORD=mysecretpassword \
-     -e ADDRESS=0.0.0.0:8000\
+     -e ADDRESS=0.0.0.0:8000 \
      -e RUST_LOG=debug \
      rust-backend-image
    ```
 
-5. Curl the application to verify that it connects to the database.
+6. Curl the application to verify that it connects to the database.
 
    ```console
    $ curl http://localhost:3001/users