- {% for post in table_of_contents(type)|reverse|slice(0, 4) %}
+
+ {% for post in table_of_contents(type)|reverse|slice(0, 3) %}
{% include '_partials/snippet.html.twig' with { 'content': post } %}
{% endfor %}
diff --git a/en/content/about/_index b/en/content/about/_index
index 63dc45d..2aaf977 100644
--- a/en/content/about/_index
+++ b/en/content/about/_index
@@ -2,5 +2,5 @@
title: About
description: About Erika Heidi and this site
tags: about
-index: 300
+index: 900
---
diff --git a/en/content/onepagers/_index b/en/content/onepagers/_index
new file mode 100644
index 0000000..11f421d
--- /dev/null
+++ b/en/content/onepagers/_index
@@ -0,0 +1,5 @@
+---
+title: One Pagers
+description: Short content that goes direct to the point
+index: 5
+---
diff --git a/en/content/onepagers/docker-basics-onepager.md b/en/content/onepagers/docker-basics-onepager.md
new file mode 100644
index 0000000..eeac72e
--- /dev/null
+++ b/en/content/onepagers/docker-basics-onepager.md
@@ -0,0 +1,171 @@
+---
+title: Dev Environments with Docker
+description: Learn the basics about using Docker for running local development environments on containers
+tags: docker, containers
+index: 10
+cover_image: https://cdn.erikaheidi.com/blog/dev-env-docker.png
+---
+
+Docker is a software used to build and run [containers](https://edu.chainguard.dev/software-security/what-are-containers/). Unlike virtual machines, containers do not emulate an entire operating system, relying on the host OS to provide an isolated filesystem that consumes less resources than traditional VMs, but still provide a fully functional runtime based on a chosen operating system.
+
+The build steps necessary to (re)create a Docker container image are defined in a [Dockerfile](https://docs.docker.com/engine/reference/builder/#dockerfile-reference). This file may contain special instructions to install packages, create users, and run arbitrary system commands.
+
+Container images can be hosted in a remote registry that allow images to be pulled from different locations. The default Docker registry is [Docker Hub](https://hub.docker.com), but there are many others. When using images from registries other than Docker Hub, you'll need to specify the registry URL along the image identifier.
+
+
+## Pulling Images from a Registry
+The `pull` command is used to pull images from a remote registry. It is not mandatory to run this command before running an image, as the pull will happen automatically. However, if you already have a local copy of an image, you'll need to run the `pull` command in order to obtain an updated version of the image.
+
+```shell
+docker pull registry/image
+```
+For example, this will pull the [PHP Chainguard Image](https://edu.chainguard.dev/chainguard/chainguard-images/reference/php) to your local machine:
+```shell
+docker pull cgr.dev/chainguard/php
+```
+You should see output similar to this:
+```shell
+Using default tag: latest
+latest: Pulling from chainguard/php
+1e4853eb9712: Pull complete
+Digest: sha256:387acb900179de11ca5a56c3ebbb6f29d2df88cb488d50fc9736ab085f27520d
+Status: Downloaded newer image for cgr.dev/chainguard/php:latest
+cgr.dev/chainguard/php:latest
+```
+
+## Running Containers
+The `run` command is used to execute the entry point defined by your image Dockerfile. Depending on the image and how it is used, you may need to provide additional parameters to the command.
+
+```shell
+docker run registry/image
+```
+For example, the following command will execute the PHP image we pulled in the previous section, with the `--version` flag to obtain the PHP version:
+
+```shell
+docker run cgr.dev/chainguard/php --version
+```
+```shell
+PHP 8.2.12 (cli) (built: Nov 15 2023 15:30:03) (NTS)
+Copyright (c) The PHP Group
+Zend Engine v4.2.12, Copyright (c) Zend Technologies
+```
+
+### Running Containers in Interactive Mode
+Many (maybe even most) container images run a single command and are terminated afterwards. It is the case with regular PHP images that are meant to run scripts. There is no interaction once the process of execution is initiated.
+
+Some images will require some type of interaction from the user. That is often the case with images that run an interactive application such as `bash`. In those cases, you'll need to provide the `-it` argument when running Docker:
+
+```shell
+docker run -it registry/image
+```
+For example, this will execute the [wolfi-base](https://edu.chainguard.dev/chainguard/chainguard-images/reference/wolfi-base) image and land you in a shell inside the newly created container:
+
+```shell
+docker run -it cgr.dev/chainguard/wolfi-base
+```
+
+### Running Ephemeral Containers
+To remove a container immediately after it is terminated, add the `-rm` parameter to the `docker run` command:
+
+```shell
+docker run --rm registry/image
+```
+This is especially useful for running quick commands that don't generate relevant output that needs to be shared or persisted, as with our first example that checked for the PHP version. We could rewrite that command to the following:
+
+```shell
+docker run --rm cgr.dev/chainguard/php --version
+```
+
+And this will prevent Docker from keeping the state of this container, which is good for saving resources.
+
+## Checking Container Status
+To have a full list of active and inactive containers currently registered in the system, run:
+
+```shell
+docker ps -a
+```
+_Note: When the `-a` parameter is not provided, Docker will list only containers that are currently running._
+
+You should get output similar to this:
+
+```shell
+CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
+26272c21399c cgr.dev/chainguard/php "/bin/php --version" 10 minutes ago Exited (0) 10 minutes ago musing_hermann
+```
+
+The first time we executed the command to obtain the PHP version of the container, we didn't use the `--rm` flag. That's why the container is listed here - it's inactive, but its state is saved.
+
+## Using Volume Shares
+When running development environments, it's crucial that you're able to edit your code in your local machine, while being able to execute and test it inside the container. To enable that, you can use [Docker volumes](https://docs.docker.com/storage/volumes/). Volumes are used to share the contents of a predefined path in your host machine to a location inside the container.
+
+The following command will create a volume sharing the contents of LOCAL_FOLDER in the host machine with REMOTE_FOLDER inside the container.
+
+```shell
+docker run -v LOCAL_FOLDER:REMOTE_FOLDER registry/image
+```
+
+### Use Case and Example
+
+Let's say you want to run a PHP script without having to install PHP (could be any other language). You want to be able to make changes to the file and test it in an isolated environment.
+
+Create a folder in your home directory for this demo:
+
+```shell
+mkdir ~/docker-demo
+cd ~/docker-demo
+```
+
+Next, create a new file and copy the following contents to it:
+
+```php
+