diff --git a/README.md b/README.md
index 484e2ba..a65f2fc 100644
--- a/README.md
+++ b/README.md
@@ -109,6 +109,11 @@ To stop and remove all containers of the sample application run:
 ```console
 docker compose down
 ```
+
+### Quickstart guides
+
+In addition to all the ready to run Compose samples listed above the folder [official-documentation-samples](official-documentation-samples/README.md) contains quickstart guides. Each of these step by step guides explain which files need to be created to build and run a Docker Compose application.
+
 <!--lint disable awesome-toc-->
 ## Contribute
 
diff --git a/official-documentation-samples/README.md b/official-documentation-samples/README.md
new file mode 100644
index 0000000..44d6559
--- /dev/null
+++ b/official-documentation-samples/README.md
@@ -0,0 +1,28 @@
+# Sample apps with Compose
+
+The following samples show the various aspects of how to work with Docker
+Compose. As a prerequisite, be sure to [install Docker Compose](https://docs.docker.com/compose/install/)
+if you have not already done so.
+
+## Key concepts these samples cover
+
+The samples should help you to:
+
+- define services based on Docker images using
+  [Compose files](https://docs.docker.com/compose/compose-file/) `docker-compose.yml` files
+- understand the relationship between `docker-compose.yml` and
+  [Dockerfiles](https://docs.docker.com/engine/reference/builder/)
+- learn how to make calls to your application services from Compose files
+
+## Samples tailored to demo Compose
+
+These samples focus specifically on Docker Compose:
+
+- [Quickstart: Compose and Django](./django/README.md) - Shows how to use Docker Compose to set up and run a simple Django/PostgreSQL app.
+
+- [Quickstart: Compose and Rails](./rails/README.md) - Shows how to use
+Docker Compose to set up and run a Rails/PostgreSQL app.
+
+- [Quickstart: Compose and WordPress](./wordpress/README.md) - Shows how to
+use Docker Compose to set up and run WordPress in an isolated environment
+with Docker containers.
diff --git a/official-documentation-samples/django/README.md b/official-documentation-samples/django/README.md
new file mode 100644
index 0000000..f7add9f
--- /dev/null
+++ b/official-documentation-samples/django/README.md
@@ -0,0 +1,286 @@
+# Quickstart: Compose and Django
+
+This quick-start guide demonstrates how to use Docker Compose to set up and run a simple Django/PostgreSQL app. Before starting,
+[install Compose](https://docs.docker.com/compose/install/).
+
+## Define the project components
+
+For this project, you need to create a Dockerfile, a Python dependencies file,
+and a `docker-compose.yml` file. (You can use either a `.yml` or `.yaml` extension for this file.)
+
+1. Create an empty project directory.
+
+    You can name the directory something easy for you to remember. This directory is the context for your application image. The directory should only contain resources to build that image.
+
+2. Create a new file called `Dockerfile` in your project directory.
+
+    The Dockerfile defines an application's image content via one or more build
+    commands that configure that image. Once built, you can run the image in a
+    container.  For more information on `Dockerfile`, see the [Docker user guide](https://docs.docker.com/get-started/)
+    and the [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).
+
+3. Add the following content to the `Dockerfile`.
+
+   ```dockerfile
+   # syntax=docker/dockerfile:1
+   FROM python:3
+   ENV PYTHONDONTWRITEBYTECODE=1
+   ENV PYTHONUNBUFFERED=1
+   WORKDIR /code
+   COPY requirements.txt /code/
+   RUN pip install -r requirements.txt
+   COPY . /code/
+   ```
+
+   This `Dockerfile` starts with a [Python 3 parent image](https://hub.docker.com/r/library/python/tags/3/).
+   The parent image is modified by adding a new `code` directory. The parent image is further modified
+   by installing the Python requirements defined in the `requirements.txt` file.
+
+4. Save and close the `Dockerfile`.
+
+5. Create a `requirements.txt` in your project directory.
+
+    This file is used by the `RUN pip install -r requirements.txt` command in your `Dockerfile`.
+
+6. Add the required software in the file.
+
+    ```python
+    Django>=3.0,<4.0
+    psycopg2>=2.8
+    ```
+
+7. Save and close the `requirements.txt` file.
+
+8. Create a file called `docker-compose.yml` in your project directory.
+
+    The `docker-compose.yml` file describes the services that make your app. In
+    this example those services are a web server and database.  The compose file
+    also describes which Docker images these services use, how they link
+    together, any volumes they might need to be mounted inside the containers.
+    Finally, the `docker-compose.yml` file describes which ports these services
+    expose. See the [`docker-compose.yml` reference](https://docs.docker.com/compose/compose-file/) for more
+    information on how this file works.
+
+9. Add the following configuration to the file.
+
+   ```yaml
+   services:
+     db:
+       image: postgres
+       volumes:
+         - ./data/db:/var/lib/postgresql/data
+       environment:
+         - POSTGRES_DB=postgres
+         - POSTGRES_USER=postgres
+         - POSTGRES_PASSWORD=postgres
+     web:
+       build: .
+       command: python manage.py runserver 0.0.0.0:8000
+       volumes:
+         - .:/code
+       ports:
+         - "8000:8000"
+       environment:
+         - POSTGRES_NAME=postgres
+         - POSTGRES_USER=postgres
+         - POSTGRES_PASSWORD=postgres
+       depends_on:
+         - db
+   ```
+
+   This file defines two services: The `db` service and the `web` service.
+
+   > Note:
+   >
+   > This uses the build in development server to run your application
+   > on port 8000. Do not use this in a production environment. For more
+   > information, see [Django documentation](https://docs.djangoproject.com/en/3.1/intro/tutorial01/#the-development-server){: target="_blank" rel="noopener" class="_”}.
+
+10. Save and close the `docker-compose.yml` file.
+
+## Create a Django project
+
+In this step, you create a Django starter project by building the image from the build context defined in the previous procedure.
+
+1. Change to the root of your project directory.
+
+2. Create the Django project by running the [docker compose run](https://docs.docker.com/engine/reference/commandline/compose_run/)
+   command as follows.
+
+   ```console
+   sudo docker compose run web django-admin startproject composeexample .
+   ```
+
+   This instructs Compose to run `django-admin startproject composeexample`
+   in a container, using the `web` service's image and configuration. Because
+   the `web` image doesn't exist yet, Compose builds it from the current
+   directory, as specified by the `build: .` line in `docker-compose.yml`.
+
+   Once the `web` service image is built, Compose runs it and executes the
+   `django-admin startproject` command in the container. This command
+   instructs Django to create a set of files and directories representing a
+   Django project.
+
+3. After the `docker compose` command completes, list the contents of your project.
+
+   ```console
+   $ ls -l
+
+   drwxr-xr-x 2 root   root   composeexample
+   drwxr-xr-x 3 root   root   data
+   -rw-rw-r-- 1 user   user   docker-compose.yml
+   -rw-rw-r-- 1 user   user   Dockerfile
+   -rwxr-xr-x 1 root   root   manage.py
+   -rw-rw-r-- 1 user   user   requirements.txt
+   ```
+
+   If you are running Docker on Linux, the files `django-admin` created are
+   owned by root. This happens because the container runs as the root user.
+   Change the ownership of the new files.
+
+   Do not change the permission of the data folder where Postgres has its file, otherwise Postgres will not be able to start due to permission issues.
+
+   ```console
+   sudo chown -R $USER:$USER composeexample manage.py
+   ```
+
+   If you are running Docker on Mac or Windows, you should already
+   have ownership of all files, including those generated by
+   `django-admin`. List the files just to verify this.
+
+   ```console
+   $ ls -l
+
+   total 32
+   -rw-r--r--  1 user  staff  145 Feb 13 23:00 Dockerfile
+   drwxr-xr-x  6 user  staff  204 Feb 13 23:07 composeexample
+   -rw-r--r--  1 user  staff  159 Feb 13 23:02 docker-compose.yml
+   -rwxr-xr-x  1 user  staff  257 Feb 13 23:07 manage.py
+   -rw-r--r--  1 user  staff   16 Feb 13 23:01 requirements.txt
+   ```
+
+### Connect the database
+
+In this section, you set up the database connection for Django.
+
+1. In your project directory, edit the `composeexample/settings.py` file.
+
+2. Replace the `DATABASES = ...` with the following:
+
+   ```python
+   # settings.py
+   
+   import os
+   
+   [...]
+   
+   DATABASES = {
+       'default': {
+           'ENGINE': 'django.db.backends.postgresql',
+           'NAME': os.environ.get('POSTGRES_NAME'),
+           'USER': os.environ.get('POSTGRES_USER'),
+           'PASSWORD': os.environ.get('POSTGRES_PASSWORD'),
+           'HOST': 'db',
+           'PORT': 5432,
+       }
+   }
+   ```
+
+   These settings are determined by the
+   [postgres](https://hub.docker.com/_/postgres) Docker image
+   specified in `docker-compose.yml`.
+
+3. Save and close the file.
+
+4. Run the [docker compose up](https://docs.docker.com/engine/reference/commandline/compose_up/) command from the top level directory for your project.
+
+   ```console
+   $ docker compose up
+
+   djangosample_db_1 is up-to-date
+   Creating djangosample_web_1 ...
+   Creating djangosample_web_1 ... done
+   Attaching to djangosample_db_1, djangosample_web_1
+   db_1   | The files belonging to this database system will be owned by user "postgres".
+   db_1   | This user must also own the server process.
+   db_1   |
+   db_1   | The database cluster will be initialized with locale "en_US.utf8".
+   db_1   | The default database encoding has accordingly been set to "UTF8".
+   db_1   | The default text search configuration will be set to "english".
+
+   <...>
+
+   web_1  | July 30, 2020 - 18:35:38
+   web_1  | Django version 3.0.8, using settings 'composeexample.settings'
+   web_1  | Starting development server at http://0.0.0.0:8000/
+   web_1  | Quit the server with CONTROL-C.
+   ```
+
+   At this point, your Django app should be running at port `8000` on
+   your Docker host. On Docker Desktop for Mac and Docker Desktop for Windows, go
+   to `http://localhost:8000` on a web browser to see the Django
+   welcome page.
+
+   ![Django example](images/django-it-worked.png)
+
+   > Note:
+   >
+   > On certain platforms (Windows 10), you might need to edit `ALLOWED_HOSTS`
+   > inside `settings.py` and add your Docker host name or IP address to the list.
+   > For demo purposes, you can set the value to:
+   >
+   > ```python
+   > ALLOWED_HOSTS = ['*']
+   > ```
+   >
+   > This value is **not** safe for production usage.  Refer to the
+   > [Django documentation](https://docs.djangoproject.com/en/1.11/ref/settings/#allowed-hosts)  for more information.
+
+5. List running containers.
+
+   In another terminal window, list the running Docker processes with the `docker ps` or `docker container ls` command.
+
+   ```console
+   $ docker ps
+
+   CONTAINER ID  IMAGE       COMMAND                  CREATED         STATUS        PORTS                    NAMES
+   def85eff5f51  django_web  "python3 manage.py..."   10 minutes ago  Up 9 minutes  0.0.0.0:8000->8000/tcp   django_web_1
+   678ce61c79cc  postgres    "docker-entrypoint..."   20 minutes ago  Up 9 minutes  5432/tcp                 django_db_1
+   ```
+
+6. Shut down services and clean up by using either of these methods:
+
+    * Stop the application by typing `Ctrl-C`  in the same shell in where you
+      started it:
+
+      ```console
+      Gracefully stopping... (press Ctrl+C again to force)
+      Killing test_web_1 ... done
+      Killing test_db_1 ... done
+      ```
+
+    * Or, for a more elegant shutdown, switch to a different shell, and run
+      [docker compose down](https://docs.docker.com/engine/reference/commandline/compose_down/) from the top level of your
+      Django sample project directory.
+
+      ```console
+      $ docker compose down
+
+      Stopping django_web_1 ... done
+      Stopping django_db_1 ... done
+      Removing django_web_1 ... done
+      Removing django_web_run_1 ... done
+      Removing django_db_1 ... done
+      Removing network django_default
+      ```
+
+  Once you've shut down the app, you can safely remove the Django project directory (for example, `rm -rf django`).
+
+## More Compose documentation
+
+* [Docker Compose overview](https://docs.docker.com/compose/)
+* [Install Docker Compose](https://docs.docker.com/compose/install/)
+* [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
+* [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
+* [Compose file reference](https://docs.docker.com/compose/compose-file/)
+* [Awesome Compose Django sample application](../../django/README.md)
diff --git a/official-documentation-samples/django/images/django-it-worked.png b/official-documentation-samples/django/images/django-it-worked.png
new file mode 100644
index 0000000..a96a3b0
Binary files /dev/null and b/official-documentation-samples/django/images/django-it-worked.png differ
diff --git a/official-documentation-samples/rails/README.md b/official-documentation-samples/rails/README.md
new file mode 100644
index 0000000..52e8dab
--- /dev/null
+++ b/official-documentation-samples/rails/README.md
@@ -0,0 +1,272 @@
+# Quickstart: Compose and Rails
+
+This Quickstart guide shows you how to use Docker Compose to set up and run
+a Rails/PostgreSQL app. Before starting, [install Compose](https://docs.docker.com/compose/install/).
+
+## Define the project
+
+Start by setting up the files needed to build the app. The app will run inside a
+Docker container containing its dependencies. Defining dependencies is done using
+a file called `Dockerfile`. To begin with, the  Dockerfile consists of:
+
+```dockerfile
+# syntax=docker/dockerfile:1
+FROM ruby:2.5
+RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
+WORKDIR /myapp
+COPY Gemfile /myapp/Gemfile
+COPY Gemfile.lock /myapp/Gemfile.lock
+RUN bundle install
+
+# Add a script to be executed every time the container starts.
+COPY entrypoint.sh /usr/bin/
+RUN chmod +x /usr/bin/entrypoint.sh
+ENTRYPOINT ["entrypoint.sh"]
+EXPOSE 3000
+
+# Configure the main process to run when running the image
+CMD ["rails", "server", "-b", "0.0.0.0"]
+```
+
+That'll put your application code inside an image that builds a container
+with Ruby, Bundler and all your dependencies inside it. For more information on
+how to write Dockerfiles, see the [Docker user guide](https://docs.docker.com/get-started/)
+and the [Dockerfile reference](https://docs.docker.com/engine/reference/builder/).
+
+Next, open an editor and create a bootstrap `Gemfile` which just loads Rails. This will be overwritten in a moment by `rails new`.
+
+```ruby
+source 'https://rubygems.org'
+gem 'rails', '~>5'
+```
+
+Create an empty `Gemfile.lock` file to build our `Dockerfile`.
+
+```console
+$ touch Gemfile.lock
+```
+
+Next, provide an entrypoint script to fix a Rails-specific issue that
+prevents the server from restarting when a certain `server.pid` file pre-exists.
+This script will be executed every time the container gets started.
+`entrypoint.sh` consists of:
+
+```bash
+#!/bin/bash
+set -e
+
+# Remove a potentially pre-existing server.pid for Rails.
+rm -f /myapp/tmp/pids/server.pid
+
+# Then exec the container's main process (what's set as CMD in the Dockerfile).
+exec "$@"
+```
+
+Finally, `docker-compose.yml` is where the magic happens. This file describes
+the services that comprise your app (a database and a web app), how to get each
+one's Docker image (the database just runs on a pre-made PostgreSQL image, and
+the web app is built from the current directory), and the configuration needed
+to link them together and expose the web app's port.
+
+```yaml
+services:
+  db:
+    image: postgres
+    volumes:
+      - ./tmp/db:/var/lib/postgresql/data
+    environment:
+      POSTGRES_PASSWORD: password
+  web:
+    build: .
+    command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
+    volumes:
+      - .:/myapp
+    ports:
+      - "3000:3000"
+    depends_on:
+      - db
+```
+
+> **Tip**
+>
+> You can use either a `.yml` or `.yaml` extension for this file.
+
+### Build the project
+
+With those files in place, you can now generate the Rails skeleton app
+using [docker compose run](https://docs.docker.com/engine/reference/commandline/compose_run/):
+
+```console
+$ docker compose run --no-deps web rails new . --force --database=postgresql
+```
+
+First, Compose builds the image for the `web` service using the `Dockerfile`.
+The `--no-deps` tells Compose not to start linked services. Then it runs
+`rails new` inside a new container, using that image. Once it's done, you
+should have generated a fresh app.
+
+List the files.
+
+```console
+$ ls -l
+
+total 64
+-rw-r--r--   1 vmb  staff   222 Jun  7 12:05 Dockerfile
+-rw-r--r--   1 vmb  staff  1738 Jun  7 12:09 Gemfile
+-rw-r--r--   1 vmb  staff  4297 Jun  7 12:09 Gemfile.lock
+-rw-r--r--   1 vmb  staff   374 Jun  7 12:09 README.md
+-rw-r--r--   1 vmb  staff   227 Jun  7 12:09 Rakefile
+drwxr-xr-x  10 vmb  staff   340 Jun  7 12:09 app
+drwxr-xr-x   8 vmb  staff   272 Jun  7 12:09 bin
+drwxr-xr-x  14 vmb  staff   476 Jun  7 12:09 config
+-rw-r--r--   1 vmb  staff   130 Jun  7 12:09 config.ru
+drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 db
+-rw-r--r--   1 vmb  staff   211 Jun  7 12:06 docker-compose.yml
+-rw-r--r--   1 vmb  staff   184 Jun  7 12:08 entrypoint.sh
+drwxr-xr-x   4 vmb  staff   136 Jun  7 12:09 lib
+drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 log
+-rw-r--r--   1 vmb  staff    63 Jun  7 12:09 package.json
+drwxr-xr-x   9 vmb  staff   306 Jun  7 12:09 public
+drwxr-xr-x   9 vmb  staff   306 Jun  7 12:09 test
+drwxr-xr-x   4 vmb  staff   136 Jun  7 12:09 tmp
+drwxr-xr-x   3 vmb  staff   102 Jun  7 12:09 vendor
+```
+
+If you are running Docker on Linux, the files `rails new` created are owned by
+root. This happens because the container runs as the root user. If this is the
+case, change the ownership of the new files.
+
+```console
+$ sudo chown -R $USER:$USER .
+```
+
+If you are running Docker on Mac or Windows, you should already have ownership
+of all files, including those generated by `rails new`.
+
+Now that you’ve got a new Gemfile, you need to build the image again. (This, and
+changes to the `Gemfile` or the Dockerfile, should be the only times you’ll need
+to rebuild.)
+
+```console
+$ docker compose build
+```
+
+### Connect the database
+
+The app is now bootable, but you're not quite there yet. By default, Rails
+expects a database to be running on `localhost` - so you need to point it at the
+`db` container instead. You also need to change the database and username to
+align with the defaults set by the `postgres` image.
+
+Replace the contents of `config/database.yml` with the following:
+
+```yaml
+default: &default
+  adapter: postgresql
+  encoding: unicode
+  host: db
+  username: postgres
+  password: password
+  pool: 5
+
+development:
+  <<: *default
+  database: myapp_development
+
+
+test:
+  <<: *default
+  database: myapp_test
+```
+
+You can now boot the app with [docker compose up](https://docs.docker.com/engine/reference/commandline/compose_up/).
+If all is well, you should see some PostgreSQL output:
+
+```console
+$ docker compose up
+
+rails_db_1 is up-to-date
+Creating rails_web_1 ... done
+Attaching to rails_db_1, rails_web_1
+db_1   | PostgreSQL init process complete; ready for start up.
+db_1   |
+db_1   | 2018-03-21 20:18:37.437 UTC [1] LOG:  listening on IPv4 address "0.0.0.0", port 5432
+db_1   | 2018-03-21 20:18:37.437 UTC [1] LOG:  listening on IPv6 address "::", port 5432
+db_1   | 2018-03-21 20:18:37.443 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
+db_1   | 2018-03-21 20:18:37.726 UTC [55] LOG:  database system was shut down at 2018-03-21 20:18:37 UTC
+db_1   | 2018-03-21 20:18:37.772 UTC [1] LOG:  database system is ready to accept connections
+```
+
+Finally, you need to create the database. In another terminal, run:
+
+```console
+$ docker compose run web rake db:create
+Starting rails_db_1 ... done
+Created database 'myapp_development'
+Created database 'myapp_test'
+```
+
+### View the Rails welcome page!
+
+That's it. Your app should now be running on port 3000 on your Docker daemon.
+
+On Docker Desktop for Mac and Docker Desktop for Windows, go to `http://localhost:3000` on a web
+browser to see the Rails Welcome.
+
+![Rails example](images/rails-welcome.png)
+
+### Stop the application
+
+To stop the application, run [docker compose down](https://docs.docker.com/engine/reference/commandline/compose_down/) in
+your project directory. You can use the same terminal window in which you
+started the database, or another one where you have access to a command prompt.
+This is a clean way to stop the application.
+
+```console
+$ docker compose down
+
+Stopping rails_web_1 ... done
+Stopping rails_db_1 ... done
+Removing rails_web_run_1 ... done
+Removing rails_web_1 ... done
+Removing rails_db_1 ... done
+Removing network rails_default
+
+```
+
+### Restart the application
+
+To restart the application run `docker compose up` in the project directory.
+
+### Rebuild the application
+
+If you make changes to the Gemfile or the Compose file to try out some different
+configurations, you need to rebuild. Some changes require only
+`docker compose up --build`, but a full rebuild requires a re-run of
+`docker compose run web bundle install` to sync changes in the `Gemfile.lock` to
+the host, followed by `docker compose up --build`.
+
+Here is an example of the first case, where a full rebuild is not necessary.
+Suppose you simply want to change the exposed port on the local host from `3000`
+in our first example to `3001`. Make the change to the Compose file to expose
+port `3000` on the container through a new port, `3001`, on the host, and save
+the changes:
+
+```yaml
+ports:
+  - "3001:3000"
+```
+
+Now, rebuild and restart the app with `docker compose up --build`.
+
+Inside the container, your app is running on the same port as before `3000`, but
+the Rails Welcome is now available on `http://localhost:3001` on your local
+host.
+
+## More Compose documentation
+
+* [Docker Compose overview](https://docs.docker.com/compose/)
+* [Install Docker Compose](https://docs.docker.com/compose/install/)
+* [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
+* [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
+* [Compose file reference](https://docs.docker.com/compose/compose-file/)
diff --git a/official-documentation-samples/rails/images/rails-welcome.png b/official-documentation-samples/rails/images/rails-welcome.png
new file mode 100644
index 0000000..c836307
Binary files /dev/null and b/official-documentation-samples/rails/images/rails-welcome.png differ
diff --git a/official-documentation-samples/wordpress/README.md b/official-documentation-samples/wordpress/README.md
new file mode 100644
index 0000000..20623c9
--- /dev/null
+++ b/official-documentation-samples/wordpress/README.md
@@ -0,0 +1,147 @@
+# Quickstart: Compose and WordPress
+
+You can use Docker Compose to easily run WordPress in an isolated environment
+built with Docker containers. This quick-start guide demonstrates how to use
+Compose to set up and run WordPress. Before starting, make sure you have
+[Compose installed](https://docs.docker.com/compose/install/).
+
+## Define the project
+
+1.  Create an empty project directory.
+
+    You can name the directory something easy for you to remember.
+    This directory is the context for your application image. The
+    directory should only contain resources to build that image.
+
+    This project directory contains a `docker-compose.yml` file which
+    is complete in itself for a good starter wordpress project.
+
+    >**Tip**: You can use either a `.yml` or `.yaml` extension for
+    this file. They both work.
+
+2.  Change into your project directory.
+
+    For example, if you named your directory `my_wordpress`:
+
+    ```console
+    $ cd my_wordpress/
+    ```
+
+3.  Create a `docker-compose.yml` file that starts your
+    `WordPress` blog and a separate `MySQL` instance with volume
+    mounts for data persistence:
+
+    ```yaml
+    services:
+      db:
+        # We use a mariadb image which supports both amd64 & arm64 architecture
+        image: mariadb:10.6.4-focal
+        # If you really want to use MySQL, uncomment the following line
+        #image: mysql:8.0.27
+        command: '--default-authentication-plugin=mysql_native_password'
+        volumes:
+          - db_data:/var/lib/mysql
+        restart: always
+        environment:
+          - MYSQL_ROOT_PASSWORD=somewordpress
+          - MYSQL_DATABASE=wordpress
+          - MYSQL_USER=wordpress
+          - MYSQL_PASSWORD=wordpress
+        expose:
+          - 3306
+          - 33060
+      wordpress:
+        image: wordpress:latest
+        volumes:
+          - wp_data:/var/www/html
+        ports:
+          - 80:80
+        restart: always
+        environment:
+          - WORDPRESS_DB_HOST=db
+          - WORDPRESS_DB_USER=wordpress
+          - WORDPRESS_DB_PASSWORD=wordpress
+          - WORDPRESS_DB_NAME=wordpress
+    volumes:
+      db_data:
+      wp_data:
+    ```
+
+   > **Notes**:
+   >
+   * The docker volumes `db_data` and `wordpress_data` persists updates made by WordPress
+   to the database, as well as the installed themes and plugins. [Learn more about docker volumes](https://docs.docker.com/storage/volumes/)
+   >
+   * WordPress Multisite works only on ports `80` and `443`.
+   {: .note-vanilla}
+
+### Build the project
+
+Now, run `docker compose up -d` from your project directory.
+
+This runs [`docker compose up`](https://docs.docker.com/engine/reference/commandline/compose_up/) in detached mode, pulls
+the needed Docker images, and starts the wordpress and database containers, as shown in
+the example below.
+
+```console
+$ docker compose up -d
+
+Creating network "my_wordpress_default" with the default driver
+Pulling db (mysql:5.7)...
+5.7: Pulling from library/mysql
+efd26ecc9548: Pull complete
+a3ed95caeb02: Pull complete
+<...>
+Digest: sha256:34a0aca88e85f2efa5edff1cea77cf5d3147ad93545dbec99cfe705b03c520de
+Status: Downloaded newer image for mysql:5.7
+Pulling wordpress (wordpress:latest)...
+latest: Pulling from library/wordpress
+efd26ecc9548: Already exists
+a3ed95caeb02: Pull complete
+589a9d9a7c64: Pull complete
+<...>
+Digest: sha256:ed28506ae44d5def89075fd5c01456610cd6c64006addfe5210b8c675881aff6
+Status: Downloaded newer image for wordpress:latest
+Creating my_wordpress_db_1
+Creating my_wordpress_wordpress_1
+```
+
+> **Note**: WordPress Multisite works only on ports `80` and/or `443`.
+If you get an error message about binding `0.0.0.0` to port `80` or `443`
+(depending on which one you specified), it is likely that the port you
+configured for WordPress is already in use by another service.
+
+### Bring up WordPress in a web browser
+
+At this point, WordPress should be running on port `80` of your Docker Host,
+and you can complete the "famous five-minute installation" as a WordPress
+administrator.
+
+> **Note**: The WordPress site is not immediately available on port `80`
+because the containers are still being initialized and may take a couple of
+minutes before the first load.
+
+If you are using Docker Desktop for Mac or Docker Desktop for Windows, you can use
+`http://localhost` as the IP address, and open `http://localhost:80` in a web
+browser.
+
+![Choose language for WordPress install](images/wordpress-lang.png)
+
+![WordPress Welcome](images/wordpress-welcome.png)
+
+### Shutdown and cleanup
+
+The command [`docker compose down`](https://docs.docker.com/engine/reference/commandline/compose_down/) removes the
+containers and default network, but preserves your WordPress database.
+
+The command `docker compose down --volumes` removes the containers, default
+network, and the WordPress database.
+
+## More Compose documentation
+
+* [Docker Compose overview](https://docs.docker.com/compose/)
+* [Install Docker Compose](https://docs.docker.com/compose/install/)
+* [Getting Started with Docker Compose](https://docs.docker.com/compose/gettingstarted/)
+* [Docker Compose Command line reference](https://docs.docker.com/compose/reference/)
+* [Compose file reference](https://docs.docker.com/compose/compose-file/)
+* [Awesome Compose WordPress sample](../../wordpress-mysql/README.md)
diff --git a/official-documentation-samples/wordpress/images/wordpress-lang.png b/official-documentation-samples/wordpress/images/wordpress-lang.png
new file mode 100644
index 0000000..a19eca9
Binary files /dev/null and b/official-documentation-samples/wordpress/images/wordpress-lang.png differ
diff --git a/official-documentation-samples/wordpress/images/wordpress-welcome.png b/official-documentation-samples/wordpress/images/wordpress-welcome.png
new file mode 100644
index 0000000..4046eb8
Binary files /dev/null and b/official-documentation-samples/wordpress/images/wordpress-welcome.png differ