diff --git a/src/Documentation/RightPanel/RightPanel.js b/src/Documentation/RightPanel/RightPanel.js
index e91c1bcbcd..7bb6a3722b 100644
--- a/src/Documentation/RightPanel/RightPanel.js
+++ b/src/Documentation/RightPanel/RightPanel.js
@@ -140,7 +140,7 @@ export default class RightPanel extends React.PureComponent {
           <span role="img" aria-label="bug">
             🐛
           </span>{' '}
-          Found an issue? Let us know or fix it:
+          Found an issue? Let us know! Or fix it:
         </Description>
 
         <GithubButton href={githubLink} target="_blank">
diff --git a/src/Documentation/glossary.js b/src/Documentation/glossary.js
index 560634a9d7..18d70cf9f5 100644
--- a/src/Documentation/glossary.js
+++ b/src/Documentation/glossary.js
@@ -21,10 +21,20 @@ form part of your expanded workspace, technically.
       name: 'DVC Project',
       match: ['DVC project', 'project', 'projects'],
       desc: `
-Initialized by running \`dvc init\` in the **workspace**. It will contain the
+Initialized by running \`dvc init\` in the **workspace** (typically in a Git
+repository). It will contain the
 [\`.dvc/\` directory](/doc/user-guide/dvc-files-and-directories) and
 [DVC-files](/doc/user-guide/dvc-file-format) created with commands such as
-\`dvc add\` or \`dvc run\`. It's typically also a Git repository.
+\`dvc add\` or \`dvc run\`. It may also be a Git repository.
+      `
+    },
+    {
+      name: 'DVC Repository',
+      match: ['DVC repository', 'DVC repositories'],
+      desc: `
+**DVC project** initialized using \`dvc init\` in a Git repository. It will
+contain \`.git/\` and [\`.dvc/\`](/doc/user-guide/dvc-files-and-directories)
+directories, as well as any DVC-files created by DVC.
       `
     },
     {
@@ -37,6 +47,15 @@ For more details, please refer to this [document]
 (/doc/user-guide/dvc-files-and-directories#structure-of-cache-directory).
       `
     },
+    {
+      name: 'Output',
+      match: ['output', 'outputs'],
+      desc: `
+A file or a directory that is under DVC control, recorded in the \`outs\`
+section of a DVC-file. See \`dvc add\` \`dvc run\`, \`dvc import\`,
+\`dvc import-url\` commands. A.k.a. **data artifact*.
+      `
+    },
     {
       name: 'Data Artifact',
       match: ['data artifact', 'data artifacts'],
@@ -44,7 +63,8 @@ For more details, please refer to this [document]
 Any data file or directory, as well as intermediate or final result (such as
 extracted features or a ML model file) that is under DVC control. Refer to
 [Versioning Data and Model Files]
-(/doc/use-cases/versioning-data-and-model-files) for more details.
+(/doc/use-cases/versioning-data-and-model-files) for more details. A.k.a
+**output*.
       `
     },
     {
@@ -55,14 +75,6 @@ Stage (DVC-file) created with the \`dvc import\` or \`dvc import-url\`
 commands. They represent files or directories from external sources.
       `
     },
-    {
-      name: 'Output',
-      match: ['output', 'outputs'],
-      desc: `
-A file or a directory that is under DVC control. See \`dvc add\` \`dvc run\`,
-\`dvc import\`, \`dvc import-url\` commands.
-      `
-    },
     {
       name: 'External Dependency',
       match: ['external dependency', 'external dependencies'],
diff --git a/src/Documentation/sidebar.json b/src/Documentation/sidebar.json
index 7138e05c6c..512a6018ef 100644
--- a/src/Documentation/sidebar.json
+++ b/src/Documentation/sidebar.json
@@ -96,7 +96,8 @@
         "label": "Sharing Data & Model Files",
         "slug": "sharing-data-and-model-files"
       },
-      "shared-development-server"
+      "shared-development-server",
+      "data-registry"
     ]
   },
   {
diff --git a/static/docs/changelog/0.18.md b/static/docs/changelog/0.18.md
index aa674de08c..6602052fb8 100644
--- a/static/docs/changelog/0.18.md
+++ b/static/docs/changelog/0.18.md
@@ -43,5 +43,5 @@ really excited to share the progress with you:
 
 Please use the discussion forum [discuss.dvc.org](discuss.dvc.org) and
 [issue tracker]() and don't hesitate to [⭐](https://github.com/iterative/dvc)
-our [DVC repository](https://github.com/iterative/dvc) if you haven't yet. We
+the [DVC repository](https://github.com/iterative/dvc) if you haven't yet. We
 are waiting for your feedback!
diff --git a/static/docs/changelog/0.35.md b/static/docs/changelog/0.35.md
index 29a5483c63..d5388abfb0 100644
--- a/static/docs/changelog/0.35.md
+++ b/static/docs/changelog/0.35.md
@@ -72,5 +72,5 @@ There are new [integrations and plugins](/doc/install/plugins) available:
   (PyCharm, IntelliJ, etc).
 
 Don't hesitate to
-[like\star DVC repository](https://github.com/iterative/dvc/stargazers) if you
+[star the DVC repository](https://github.com/iterative/dvc/stargazers) if you
 haven't yet. We are waiting for your feedback!
diff --git a/static/docs/command-reference/add.md b/static/docs/command-reference/add.md
index 2e818f59cb..8175664c3a 100644
--- a/static/docs/command-reference/add.md
+++ b/static/docs/command-reference/add.md
@@ -165,9 +165,7 @@ $ file .dvc/cache/d8/acabbfd4ee51c95da5d7628c7ef74b
 ```
 
 Note that tracking compressed files (e.g. ZIP or TAR archives) is not
-recommended, as `dvc add` supports tracking directories. (Details below.) For
-more context, refer to
-[Data Registry](/doc/use-cases/data-registry#problem-1-compressed-data-files)
+recommended, as `dvc add` supports tracking directories. (Details below.)
 
 ## Example: Directory
 
@@ -176,14 +174,14 @@ pictures. You may then have hundreds or thousands of pictures of these animals
 in a directory, and this is your training dataset:
 
 ```dvc
-$ tree pics
+$ tree pics --filelimit 3
 pics
 ├── train
-│   ├── cats        <-- A lot of images of cats
-│   └── dogs        <-- A lot of images of dogs
+│   ├── cats [many image files]
+│   └── dogs [many image files]
 └── validation
-    ├── cats        <-- More images of cats
-    └── dogs        <-- More images of dogs
+    ├── cats [more image files]
+    └── dogs [more image files]
 ```
 
 Taking a directory under DVC control as simple as with a single file:
diff --git a/static/docs/command-reference/cache/index.md b/static/docs/command-reference/cache/index.md
index 90b9cd712c..2ac04dc3ab 100644
--- a/static/docs/command-reference/cache/index.md
+++ b/static/docs/command-reference/cache/index.md
@@ -21,9 +21,9 @@ including the default cache directory.
 
 The cache is where your data files, models, etc (anything you want to version
 with DVC) are actually stored. The corresponding files you see in the
-<abbr>workspace</abbr> simply link to the ones in cache. (See
-`dvc config cache`, `type` config option, for more information on file links on
-different platforms.)
+<abbr>workspace</abbr> can simply link to the ones in cache. (Refer to
+[File link types](/doc/user-guide/large-dataset-optimization#file-link-types-for-the-dvc-cache)
+for more information on file links on different platforms.)
 
 > For more cache-related configuration options refer to `dvc config cache`.
 
diff --git a/static/docs/command-reference/destroy.md b/static/docs/command-reference/destroy.md
index 1da1280bad..533ba4f3b5 100644
--- a/static/docs/command-reference/destroy.md
+++ b/static/docs/command-reference/destroy.md
@@ -17,9 +17,9 @@ usage: dvc destroy [-h] [-q | -v] [-f]
 be removed as well, unless it's set to an external location with
 `dvc cache dir`. (By default a local cache is located in the `.dvc/cache`
 directory.) If you were using
-[symlinks for linking data](/doc/user-guide/large-dataset-optimization) from the
+[symlinks for linking](/doc/user-guide/large-dataset-optimization) data from the
 cache, DVC will replace them with copies, so that your data is intact after the
-DVC repository destruction.
+project's destruction.
 
 ## Options
 
diff --git a/static/docs/command-reference/fetch.md b/static/docs/command-reference/fetch.md
index 99fdf2997a..9b50b6c910 100644
--- a/static/docs/command-reference/fetch.md
+++ b/static/docs/command-reference/fetch.md
@@ -1,8 +1,7 @@
 # fetch
 
 Get files that are under DVC control from
-[remote](/doc/command-reference/remote#description) storage into the
-<abbr>cache</abbr>.
+[remote storage](/doc/command-reference/remote) into the <abbr>cache</abbr>.
 
 ## Synopsis
 
@@ -74,7 +73,7 @@ specified in DVC-files currently in the project are considered by `dvc fetch`
 ## Options
 
 - `-r REMOTE`, `--remote REMOTE` - name of the
-  [remote storage](/doc/command-reference/remote#description) to fetch from (see
+  [remote storage](/doc/command-reference/remote) to fetch from (see
   `dvc remote list`). If not specified, the default remote is used (see
   `dvc config core.remote`). The argument `REMOTE` is a remote name defined
   using the `dvc remote` command.
@@ -117,8 +116,7 @@ specified in DVC-files currently in the project are considered by `dvc fetch`
 ## Examples
 
 Let's employ a simple <abbr>workspace</abbr> with some data, code, ML models,
-pipeline stages, as well as a few Git tags, such as the <abbr>DVC project</abbr>
-created in our
+pipeline stages, as well as a few Git tags, such as our
 [get started example repo](https://github.com/iterative/example-get-started).
 Then we can see what happens with `dvc fetch` as we switch from tag to tag.
 
diff --git a/static/docs/command-reference/get-url.md b/static/docs/command-reference/get-url.md
index 2e7808e504..bc5256b3ef 100644
--- a/static/docs/command-reference/get-url.md
+++ b/static/docs/command-reference/get-url.md
@@ -31,8 +31,8 @@ be placed inside of it.
 Note that this command doesn't require an existing DVC project to run in. It's a
 single-purpose command that can be used out of the box after installing DVC.
 
-> See `dvc get` to download data or model files or directories from other DVC
-> repositories (e.g. GitHub URLs).
+> See `dvc get` to download data or model files or directories from other
+> <abbr>DVC repository</abbr> (e.g. GitHub URLs).
 
 DVC supports several types of (local or) remote locations (protocols):
 
diff --git a/static/docs/command-reference/get.md b/static/docs/command-reference/get.md
index 755978e663..120b3c98a3 100644
--- a/static/docs/command-reference/get.md
+++ b/static/docs/command-reference/get.md
@@ -1,7 +1,8 @@
 # get
 
-Download or copy file or directory from any <abbr>DVC project</abbr> in a Git
-repository (e.g. hosted on GitHub) into the current working directory.
+Download or copy file or directory from the
+[remote storage](/doc/command-reference/remote) of any <abbr>DVC project</abbr>
+in a Git repository (e.g. hosted on GitHub) into the current working directory.
 
 > Unlike `dvc import`, this command does not track the downloaded data files
 > (does not create a DVC-file).
@@ -20,7 +21,8 @@ positional arguments:
 
 Provides an easy way to download datasets, intermediate results, ML models, or
 other files and directories (any <abbr>data artifact</abbr>) tracked in another
-DVC repository, by downloading them into the current working directory.
+<abbr>DVC repository</abbr>, by downloading them into the current working
+directory. (It works like `wget`, but for DVC repositories.)
 
 Note that this command doesn't require an existing DVC project to run in. It's a
 single-purpose command that can be used out of the box after installing DVC.
diff --git a/static/docs/command-reference/import-url.md b/static/docs/command-reference/import-url.md
index 0c7fdb84a2..891361cd6e 100644
--- a/static/docs/command-reference/import-url.md
+++ b/static/docs/command-reference/import-url.md
@@ -36,7 +36,7 @@ desired for the downloaded data. If an existing directory is specified, then the
 output will be placed inside of it.
 
 > See `dvc import` to download and tack data or model files or directories from
-> other DVC repositories (e.g. GitHub URLs).
+> other <abbr>DVC repositories</abbr> (e.g. GitHub URLs).
 
 DVC supports [DVC-files](/doc/user-guide/dvc-file-format) that refer to data in
 external locations, see
diff --git a/static/docs/command-reference/import.md b/static/docs/command-reference/import.md
index 4dca2bd27f..842b031560 100644
--- a/static/docs/command-reference/import.md
+++ b/static/docs/command-reference/import.md
@@ -3,7 +3,7 @@
 Download or copy file or directory from any <abbr>DVC project</abbr> in a Git
 repository (e.g. hosted on GitHub) into the <abbr>workspace</abbr>, and track
 changes in this [external dependency](/doc/user-guide/external-dependencies).
-Creates a DVC-file.
+Creates [DVC-files](/doc/user-guide/dvc-file-format).
 
 > See also `dvc get`, that corresponds to the first step this command performs
 > (just download the data).
@@ -21,13 +21,13 @@ positional arguments:
 ## Description
 
 DVC provides an easy way to reuse datasets, intermediate results, ML models, or
-other files and directories tracked in another DVC repository into the
-workspace. The `dvc import` command downloads such a <abbr>data artifact</abbr>
-in a way that it is tracked with DVC, so it can be updated when the external
-data source changes.
+other files and directories tracked in another <abbr>DVC repository</abbr> into
+the workspace. The `dvc import` command downloads such a <abbr>data
+artifact</abbr> in a way that it is tracked with DVC, so it can be updated when
+the data source changes.
 
 The `url` argument specifies the address of the Git repository containing the
-external <abbr>project</abbr>. Both HTTP and SSH protocols are supported for
+source <abbr>project</abbr>. Both HTTP and SSH protocols are supported for
 online repositories (e.g. `[user@]server:project.git`). `url` can also be a
 local file system path to an "offline" repository.
 
@@ -35,31 +35,32 @@ The `path` argument of this command is used to specify the location of the data
 to be downloaded within the source project. It should point to a data file or
 directory tracked by that project – specified in one of the
 [DVC-files](/doc/user-guide/dvc-file-format) of the repository at `url`. (You
-will not find these files directly in the source Git repository.) The source
+will not find data files directly in the external Git repository.) The source
 project should have a default [DVC remote](/doc/command-reference/remote)
 configured, containing them.)
 
 > See `dvc import-url` to download and tack data from other supported URLs.
 
 After running this command successfully, the imported data is placed in the
-current working directory with its original file name e.g. `data.txt`. An import
-stage (DVC-file) is then created extending the full file or directory name of
-the imported data e.g. `data.txt.dvc` – similar to having used `dvc run` to
-generate the same output.
+current working directory with its original file name e.g. `data.txt`. An
+_import stage_ (DVC-file) is then created, extending the full file or directory
+name of the imported data e.g. `data.txt.dvc` – similar to having used `dvc run`
+to generate the same output.
 
 DVC supports DVC-files that refer to data in an external DVC repository (hosted
-on a Git server). In such a DVC-file, the `deps` section specifies the `repo`
-URL and data `path`, and the `outs` section contains the corresponding local
-path in the workspace. It records enough data from the external file or
-directory to enable DVC to efficiently check it to determine whether the local
-copy is out of date.
+on a Git server) a.k.a _import stages_. In such a DVC-file, the `deps` section
+specifies the `repo` URL and data `path`, and the `outs` section contains the
+corresponding local path in the workspace. It records enough data from the
+imported data to enable DVC to efficiently check it to determine whether the
+local copy is out of date.
 
 To actually [track the data](https://dvc.org/doc/get-started/add-files),
-`git add` (and `git commit`) the import stage (DVC-file).
+`git add` (and `git commit`) the import stage.
 
 Note that import stages are considered always "locked", meaning that if you run
-`dvc repro`, they won't be updated. Use `dvc update` on them to update the
-downloaded data artifact from the external DVC repository.
+`dvc repro`, they won't be updated. Use `dvc update` or
+[re-import](#example-fixed-revisions-re-importing) them to update the downloaded
+data artifact from the source project.
 
 ## Options
 
@@ -72,8 +73,10 @@ downloaded data artifact from the external DVC repository.
 - `--rev` - specific
   [Git revision](https://git-scm.com/book/en/v2/Git-Internals-Git-References)
   (such as a branch name, a tag, or a commit hash) of the DVC repository to
-  import the data from. The tip of the default branch is used by default when
-  this option is not specified.
+  import the data from. The tip of the repository's default branch is used by
+  default when this option is not specified. Note that this adds a `rev` field
+  in the import stage that fixes it to this revision. This can impact the
+  behavior of `dvc update`. (See **re-importing** example below.)
 
 - `-h`, `--help` - prints the usage/help message, and exit.
 
@@ -84,8 +87,8 @@ downloaded data artifact from the external DVC repository.
 
 ## Examples
 
-A simple case for this command is to import a dataset from an external DVC repo,
-such as our
+A simple case for this command is to import a dataset from an external <abbr>DVC
+repository</abbr>, such as our
 [get started example repo](https://github.com/iterative/example-get-started).
 
 ```dvc
@@ -118,5 +121,88 @@ outs:
 ```
 
 Several of the values above are pulled from the original stage file
-`model.pkl.dvc` in the external DVC repo. `url` and `rev_lock` fields are used
-to specify the origin and version of the dependency.
+`model.pkl.dvc` in the external DVC repository. `url` and `rev_lock` fields are
+used to specify the origin and version of the dependency.
+
+## Example: fixed revisions & re-importing
+
+When the `--rev` option is used, the import stage
+([DVC-file](/doc/user-guide/dvc-file-format)) will include a `rev` field under
+`repo` like this:
+
+```yaml
+deps:
+  - path: data/data.xml
+    repo:
+      url: git@github.com:iterative/dataset-registry.git
+      rev: cats-dogs-v1
+      rev_lock: 0547f5883fb18e523e35578e2f0d19648c8f2d5c
+```
+
+If the Git revision moves, such as a branch, this doesn't have much of an effect
+on the import/update workflow. However, for static refs such as tags (unless
+manually updated), or for SHA commits, `dvc update` will not have any effect on
+the import. In this cases, in order to actually "update" an import, it's
+necessary to **re-import the data** instead, by using `dvc import` again without
+or with a different `--rev`. For example:
+
+```dvc
+$ dvc import --rev master \
+             git@github.com:iterative/dataset-registry.git \
+             use-cases/cats-dogs
+```
+
+This will overwrite the import stage (DVC-file) either removing or replacing the
+`rev` field. This can produce an import stage that is able to be updated
+normally with `dvc update` going forward.
+
+## Example: Data registry
+
+If you take a look at our
+[dataset-registry](https://github.com/iterative/dataset-registry)
+<abbr>project</abbr>, you'll see that it's organized into different directories
+such as `tutorial/ver` and `use-cases/`, and these contain
+[DVC-files](/doc/user-guide/dvc-file-format) that track different datasets.
+Given this simple structure, these files can be easily shared among several
+other projects, using `dvc get` and `dvc import`. For example:
+
+```dvc
+$ dvc get https://github.com/iterative/dataset-registry \
+          tutorial/ver/data.zip
+```
+
+> Used in our [versioning tutorial](/doc/tutorials/versioning)
+
+Or
+
+```dvc
+$ dvc import git@github.com:iterative/dataset-registry.git \
+             use-cases/cats-dogs
+```
+
+`dvc import` provides a better way to incorporate data files tracked in external
+<abbr>DVC repositories</abbr> because it saves the connection between the
+current project and the source project. This means that enough information is
+recorded in an import stage (DVC-file) in order to
+[reproduce](/doc/command-reference/repro) downloading of this same data version
+in the future, where and when needed. This is achieved with the `repo` field,
+for example (matching the import command above):
+
+```yaml
+md5: 96fd8e791b0ee4824fc1ceffd13b1b49
+locked: true
+deps:
+  - path: use-cases/cats-dogs
+    repo:
+      url: git@github.com:iterative/dataset-registry.git
+      rev_lock: 0547f5883fb18e523e35578e2f0d19648c8f2d5c
+outs:
+  - md5: b6923e1e4ad16ea1a7e2b328842d56a2.dir
+    path: cats-dogs
+    cache: true
+    metric: false
+    persist: false
+```
+
+See a full explanation in our [Data Registry](/doc/use-cases/data-registry) use
+case.
diff --git a/static/docs/command-reference/init.md b/static/docs/command-reference/init.md
index 553ac7f32c..f6a69fe0f6 100644
--- a/static/docs/command-reference/init.md
+++ b/static/docs/command-reference/init.md
@@ -44,7 +44,7 @@ is a local cache and you cannot `git push` it.
 
 ## Examples
 
-Create a new DVC repository (requires Git):
+Create a new <abbr>DVC repository</abbr> (requires Git):
 
 ```dvc
 $ mkdir example && cd example
diff --git a/static/docs/command-reference/install.md b/static/docs/command-reference/install.md
index f1011cf1af..cda7101d8b 100644
--- a/static/docs/command-reference/install.md
+++ b/static/docs/command-reference/install.md
@@ -1,6 +1,7 @@
 # install
 
-Install Git hooks into the DVC repository to automate certain common actions.
+Install Git hooks into the <abbr>DVC repository</abbr> to automate certain
+common actions.
 
 ## Synopsis
 
diff --git a/static/docs/command-reference/update.md b/static/docs/command-reference/update.md
index 9c99f92125..f0007a4e49 100644
--- a/static/docs/command-reference/update.md
+++ b/static/docs/command-reference/update.md
@@ -1,6 +1,8 @@
 # update
 
-Update <abbr>data artifacts</abbr> imported from other DVC repositories.
+Update <abbr>data artifacts</abbr> imported from external <abbr>DVC
+repositories</abbr>, and corresponding
+[DVC-files](/doc/user-guide/dvc-file-format).
 
 ## Synopsis
 
@@ -15,16 +17,24 @@ positional arguments:
 
 After creating <abbr>import stages</abbr>
 ([DVC-files](/doc/user-guide/dvc-file-format)) with `dvc import` or
-`dvc import-url`, the external data source can change. Use `dvc update` to bring
-these imported file, directory, or <abbr>data artifact</abbr> up to date.
+`dvc import-url`, the data source can change. Use `dvc update` to bring these
+imported file, directory, or <abbr>data artifact</abbr> up to date.
+
+To indicate which import stages to update, we must specify the corresponding
+DVC-file `targets` as command arguments.
 
 Note that import stages are considered always "locked", meaning that if you run
 `dvc repro`, they won't be updated. `dvc update` is the only command that can
-update them. Also, for `dvc import` DVC-files, the `rev_lock` field is updated
-by `dvc update`.
+update them. Also, for `dvc import` import stages, the `rev_lock` field is
+updated by `dvc update`.
 
-To indicate which import stages to update, we must specify the corresponding
-DVC-file `targets` as command arguments.
+Another detail to note is that when the `--rev` (revision) option of
+`dvc import` has been used to create an import stage, DVC is not aware of what
+kind of
+[Git revision](https://git-scm.com/book/en/v2/Git-Internals-Git-References) this
+is, for example a branch or a tag. For static refs such as tags (unless manually
+updated), or for SHA commits, `dvc update` will not have any effect on the
+import.
 
 ## Options
 
@@ -60,4 +70,7 @@ Output 'model.pkl' didn't change. Skipping saving.
 Saving information to 'model.pkl.dvc'.
 ```
 
-This time nothing has changed, since the source repository is rather stable.
+This time nothing has changed, since the source <abbr>project</abbr> is rather
+stable.
+
+> Refer to this [re-importing example]() for
diff --git a/static/docs/get-started/add-files.md b/static/docs/get-started/add-files.md
index 9c26516107..3092c0ae69 100644
--- a/static/docs/get-started/add-files.md
+++ b/static/docs/get-started/add-files.md
@@ -10,11 +10,13 @@ $ dvc get https://github.com/iterative/dataset-registry \
         get-started/data.xml -o data/data.xml
 ```
 
-> `dvc get` can download <abbr>data artifacts</abbr> from any <abbr>DVC
-> project</abbr> hosted on a Git repository into the current working directory
-> (similar to `wget` but for DVC repositories). In this case we use our own
-> [iterative/dataset-registry](https://github.com/iterative/dataset-registry))
-> project as the external data source.
+> `dvc get` can use any <abbr>DVC project</abbr> hosted on a Git repository to
+> find the appropriate [remote storage](/doc/command-reference/remote) and
+> download <abbr>data artifacts</abbr> from it. (It works like `wget`, but for
+> DVC repositories.) In this case we use
+> [dataset-registry](https://github.com/iterative/dataset-registry)) as the
+> source project. (Refer to [Data Registry](/doc/use-cases/data-registry) for
+> more info about this setup.)
 
 To take a file (or a directory) under DVC control just run `dvc add` on it. For
 example:
diff --git a/static/docs/get-started/configure.md b/static/docs/get-started/configure.md
index b39b8c7172..659ba1ef36 100644
--- a/static/docs/get-started/configure.md
+++ b/static/docs/get-started/configure.md
@@ -31,8 +31,8 @@ $ git commit .dvc/config -m "Configure local remote"
 > to use DVC. For most [use cases](/doc/use-cases), other "more remote" types of
 > remotes will be required.
 
-Adding a remote should be specified by both its type prefix (protocol) and its
-path. DVC currently supports seven types of remotes:
+Adding a remote should be specified by both its type (protocol) and its path.
+DVC currently supports seven types of remotes:
 
 - `local`: Local Directory
 - `s3`: Amazon Simple Storage Service
diff --git a/static/docs/get-started/import-data.md b/static/docs/get-started/import-data.md
index 7010ab7155..87137bf64f 100644
--- a/static/docs/get-started/import-data.md
+++ b/static/docs/get-started/import-data.md
@@ -28,8 +28,8 @@ $ dvc import https://github.com/iterative/dataset-registry \
 ```
 
 This downloads `data.xml` from our
-[dataset-registry](https://github.com/iterative/dataset-registry) DVC project
-into the current working directory, adds it to `.gitignore`, and creates the
+[dataset-registry](https://github.com/iterative/dataset-registry) project into
+the current working directory, adds it to `.gitignore`, and creates the
 `data.xml.dvc` [DVC-file](/doc/user-guide/dvc-file-format) to track changes in
 the source data. With _imports_, we can use `dvc update` to check for changes in
 the external data source before [reproducing](/doc/get-started/reproduce) any
@@ -39,8 +39,7 @@ the external data source before [reproducing](/doc/get-started/reproduce) any
 
 ### Expand to learn more about imports
 
-Note that the
-[iterative/dataset-registry](https://github.com/iterative/dataset-registry)
+Note that the [dataset-registry](https://github.com/iterative/dataset-registry)
 repository doesn't actually contain a `get-started/data.xml` file. Instead, DVC
 inspects
 [get-started/data.xml.dvc](https://github.com/iterative/dataset-registry/blob/master/get-started/data.xml.dvc)
diff --git a/static/docs/tutorials/deep/preparation.md b/static/docs/tutorials/deep/preparation.md
index d6d2871ae8..3c2682e234 100644
--- a/static/docs/tutorials/deep/preparation.md
+++ b/static/docs/tutorials/deep/preparation.md
@@ -93,11 +93,12 @@ $ cat .dvc/.gitignore
 $ git commit -m "init DVC"
 ```
 
-The `.dvc/cache` directory is one of the most important parts of any DVC
-repository. The directory contains all the content of data files and will be
-described in the next chapter in more detail. Note that the cache directory is
-contained in the `.dvc/.gitignore` file, which means that it's not under Git
-control — this is your local directory and you cannot push it to any Git remote.
+The `.dvc/cache` directory is one of the most important parts of any <abbr>DVC
+repositories</abbr>. The directory contains all the content of data files and
+will be described in the next chapter in more detail. Note that the cache
+directory is contained in the `.dvc/.gitignore` file, which means that it's not
+under Git control — this is your local directory and you cannot push it to any
+Git remote.
 
 For more information refer to
 [DVC Files and Directories](/doc/user-guide/dvc-files-and-directories).
diff --git a/static/docs/tutorials/deep/sharing-data.md b/static/docs/tutorials/deep/sharing-data.md
index 352e5b8ac1..ed6c2e2902 100644
--- a/static/docs/tutorials/deep/sharing-data.md
+++ b/static/docs/tutorials/deep/sharing-data.md
@@ -3,9 +3,9 @@
 ## Pushing data to the cloud
 
 We've gone over how source code and [DVC-files](/doc/user-guide/dvc-file-format)
-can be shared using a Git repository. These DVC repositories will contain all
-the information needed for reproducibility, so it might be a good idea to share
-them with your team using Git hosting services (such as
+can be shared using a Git repository. These <abbr>DVC repositories</abbr> will
+contain all the information needed for reproducibility, so it might be a good
+idea to share them with your team using Git hosting services (such as
 [GitHub](https://github.com/)).
 
 DVC is able to push the <abbr>cache</abbr> to cloud storage.
diff --git a/static/docs/tutorials/interactive.md b/static/docs/tutorials/interactive.md
index c37ec7c9cb..09dcb5029e 100644
--- a/static/docs/tutorials/interactive.md
+++ b/static/docs/tutorials/interactive.md
@@ -27,8 +27,9 @@ Learn basic concepts and features of DVC with interactive lessons:
    pipeline end-to-end.
 
 6. [Importing Data](https://katacoda.com/dvc/courses/basics/importing) <br/>
-   Download and track data from another DVC project that is hosted in a Git
-   repository.
+   Download and track data from the
+   [remote storage](/doc/command-reference/remote) of any DVC project that is
+   hosted on a Git repository.
 
 ## Simple ML Scenarios
 
diff --git a/static/docs/tutorials/pipelines.md b/static/docs/tutorials/pipelines.md
index 3a0e67b4fa..767576d9ae 100644
--- a/static/docs/tutorials/pipelines.md
+++ b/static/docs/tutorials/pipelines.md
@@ -48,11 +48,13 @@ $ git add code/
 $ git commit -m "Download and add code to new Git repo"
 ```
 
-> `dvc get` can download data artifacts from any DVC project hosted on a Git
-> repository into the current working directory (similar to `wget` but for DVC
-> repositories). In this case we use our own
-> [iterative/dataset-registry](https://github.com/iterative/dataset-registry))
-> project as the external data source.
+> `dvc get` can use any <abbr>DVC project</abbr> hosted on a Git repository to
+> find the appropriate [remote storage](/doc/command-reference/remote) and
+> download <abbr>data artifacts</abbr> from it. (It works like `wget`, but for
+> DVC repositories.) In this case we use
+> [dataset-registry](https://github.com/iterative/dataset-registry)) as the
+> source project. (Refer to [Data Registry](/doc/use-cases/data-registry) for
+> more info about this setup.)
 
 Now let's install the requirements. But before we do that, we **strongly**
 recommend creating a
@@ -73,7 +75,7 @@ utilizing the same set of commands that are described in earlier
 > This will be determined by the interdependencies between DVC-files, mentioned
 > below.
 
-Initialize DVC repository (run it inside your Git repository):
+Initialize <abbr>DVC repository</abbr> (run it inside your Git repository):
 
 ```dvc
 $ dvc init
diff --git a/static/docs/tutorials/versioning.md b/static/docs/tutorials/versioning.md
index 40132dc354..8c759bf364 100644
--- a/static/docs/tutorials/versioning.md
+++ b/static/docs/tutorials/versioning.md
@@ -83,11 +83,13 @@ $ unzip -q data.zip
 $ rm -f data.zip
 ```
 
-> `dvc get` can download <abbr>data artifacts</abbr> from any DVC project hosted
-> on a Git repository into the current working directory (similar to `wget` but
-> for DVC repositories). In this case we use our own
-> [iterative/dataset-registry](https://github.com/iterative/dataset-registry)
-> project as the external data source.
+> `dvc get` can use any <abbr>DVC project</abbr> hosted on a Git repository to
+> find the appropriate [remote storage](/doc/command-reference/remote) and
+> download <abbr>data artifacts</abbr> from it. (It works like `wget`, but for
+> DVC repositories.) In this case we use
+> [dataset-registry](https://github.com/iterative/dataset-registry)) as the
+> source project. (Refer to [Data Registry](/doc/use-cases/data-registry) for
+> more info about this setup.)
 
 This command downloads and extracts our raw dataset, consisting of 1000 labeled
 images for training and 800 labeled images for validation. In total, it's a 43
@@ -161,12 +163,11 @@ $ git tag -a "v1.0" -m "model v1.0, 1000 images"
 ### Expand to learn more about DVC internals
 
 As we mentioned briefly, DVC does not commit the `data/` directory and
-`model.h5` file with Git. Instead, `dvc add` pushes them into the cache and adds
-them to `.gitignore`. We then `git commit` DVC-files that serve as pointers to
-the cache (usually in the `.dvc/cache` directory in the repository), where the
-actual data resides.
+`model.h5` file with Git. Instead, `dvc add` stores them in the cache (usually
+in `.dvc/cache`) and adds them to `.gitignore`. We then `git commit` DVC-files
+that contain pointers to the cached data.
 
-In this case we created `data.dvc` and `model.h5.dvc` files. Refer to the
+In this case we created `data.dvc` and `model.h5.dvc`. Refer to
 [DVC-File Format](/doc/user-guide/dvc-file-format) to learn more about how these
 files work.
 
@@ -194,7 +195,7 @@ $ unzip -q new-labels.zip
 $ rm -f new-labels.zip
 ```
 
-For simplicity's sake, we keep the validation dataset the same. Now our dataset
+For simplicity's sake, we keep the validation subset the same. Now our dataset
 has 2000 images for training and 800 images for validation, with a total size of
 67 MB:
 
@@ -228,6 +229,10 @@ $ python train.py
 $ dvc add model.h5
 ```
 
+> `dvc remove` is necessary here because `model.h5` was already added with
+> `dvc add` earlier, but we want to do so again. Later we'll see how `dvc run`
+> eliminates this extra step.
+
 Let's commit the second version:
 
 ```dvc
@@ -295,7 +300,7 @@ place.
 ## Automating capturing
 
 `dvc add` makes sense when you need to keep track of different versions of
-datasets or model files that come from external sources. The `data/` directory
+datasets or model files that come from source projects. The `data/` directory
 above (with cats and dogs images) is a good example.
 
 On the other hand, there are files that are the result of running some code. In
@@ -324,11 +329,12 @@ $ dvc run -f Dvcfile \
           python train.py
 ```
 
-Similar to `dvc add`, `dvc run` creates a DVC-file (forced to have the file name
-`Dvcfile` with the `-f` option). It puts all outputs (`-o`) under DVC control
-the same way that `dvc add` does. Unlike `dvc add`, `dvc run` also tracks
-dependencies (`-d`) and the command (`python train.py`) that was run to produce
-the result. We call such a DVC-file a "stage file".
+Similar to `dvc add`, `dvc run` creates a
+[DVC-file](/doc/user-guide/dvc-file-format) named `Dvcfile` (specified using the
+`-f` option). It puts all outputs (`-o`) under DVC control the same way as
+`dvc add` does. Unlike `dvc add`, `dvc run` also tracks dependencies (`-d`) and
+the command (`python train.py`) that was run to produce the result. We call such
+a DVC-file a "stage file".
 
 > At this point you could run `git add .` and `git commit` to save the `Dvcfile`
 > stage file and its changed output files to the repository.
diff --git a/static/docs/use-cases/data-registry.md b/static/docs/use-cases/data-registry.md
new file mode 100644
index 0000000000..933e304e2b
--- /dev/null
+++ b/static/docs/use-cases/data-registry.md
@@ -0,0 +1,172 @@
+# Data Registry
+
+One of the main uses of <abbr>DVC repositories</abbr> is the
+[versioning of data and model files](/doc/use-cases/data-and-model-files-versioning).
+This is provided by commands such as `dvc add` and `dvc run`, that allow
+tracking of datasets and any other <abbr>data artifacts</abbr>.
+
+With the aim to enable reusability of these versioned artifacts between
+different projects (similar to package management systems, but for data), DVC
+also includes the `dvc get`, `dvc import`, and `dvc update` commands. For
+example, project A may use a data file to begin its data
+[pipeline](/doc/command-reference/pipeline), but project B also requires this
+same file; Instead of
+[adding it](/doc/command-reference/add#example-single-file) it to both projects,
+B can simply import it from A. Furthermore, the version of the data file
+imported to B can be an older iteration than what's currently used in A.
+
+Keeping this in mind, we could build a <abbr>DVC project</abbr> dedicated to
+tracking and versioning datasets (or any kind of large files). This way we would
+have a repository that has all the metadata and change history for the project's
+data. We can see who updated what, and when; use pull requests to update data
+the same way you do with code; and we don't need ad-hoc conventions to store
+different data versions. Other projects can share the data in the registry by
+downloading (`dvc get`) or importing (`dvc import`) them for use in different
+data processes.
+
+The advantages of using a DVC **data registry** project are:
+
+- Data as code: Improve _lifecycle management_ with
+  [versioning](/doc/use-cases/data-and-model-files-versioning) of simple
+  directory structures (without ad-hoc conventions); Any version of the data or
+  results tracked by a DVC registry can be used in other projects at any time.
+  Leverage Git and Git hosting (e.g. GitHub) features such as change history,
+  branching, pull requests, reviews, and even continuous deployment of ML
+  models.
+- Reusability: Reproduce and organize _feature stores_ with a simple CLI
+  (`dvc get` and `dvc import` commands, similar to software package management
+  systems like `pip`).
+- Persistence: The DVC registry controlled
+  [remote storage](/doc/command-reference/remote) (e.g. an S3 bucket) improves
+  data security. There are less chances someone can delete or rewrite a model,
+  for example.
+- Storage Optimization: Track data
+  [shared](/doc/use-cases/share-data-and-model-files) by multiple projects
+  centralized in a single location (with the ability to create distributed
+  copies on other remotes). This simplifies data management and optimizes space
+  requirements.
+- Security: Registries can be setup to have read-only remote storage (e.g. an
+  HTTP location). Git versioning of DVC-files allows us to track and audit data
+  changes.
+
+## Example
+
+A dataset we use for several of our examples and tutorials is one containing
+2800 images of cats and dogs. We partitioned the dataset in two for our
+[Versioning Tutorial](/doc/tutorials/versioning), and backed up the parts on a
+storage server, downloading them with `wget` in our examples. This setup was
+then revised to download the dataset with `dvc get` instead, so we created the
+[dataset-registry](https://github.com/iterative/dataset-registry)) repository, a
+<abbr>DVC project</abbr> hosted on GitHub, to version the dataset (see its
+[`tutorial/ver`](https://github.com/iterative/dataset-registry/tree/master/tutorial/ver)
+directory).
+
+However, there are a few problems with the way this dataset is structured. Most
+importantly, this single dataset is tracked by 2 different
+[DVC-files](/doc/user-guide/dvc-file-format), instead of 2 versions of the same
+one, which would better reflect the intentions of this dataset... Fortunately,
+we have also prepared an improved alternative in the
+[`use-cases/`](https://github.com/iterative/dataset-registry/tree/master/use-cases)
+directory of the same <abbr>DVC repository</abbr>.
+
+To create a
+[first version](https://github.com/iterative/dataset-registry/tree/cats-dogs-v1/use-cases)
+of our dataset, we extracted the first part into the `use-cases/cats-dogs`
+directory (illustrated below), and ran `dvc add use-cases/cats-dogs` to
+[track the entire directory](https://dvc.org/doc/command-reference/add#example-directory).
+
+```dvc
+$ tree use-cases/cats-dogs --filelimit 3
+use-cases/cats-dogs
+└── data
+    ├── train
+    │   ├── cats [500 image files]
+    │   └── dogs [500 image files]
+    └── validation
+        ├── cats [400 image files]
+        └── dogs [400 image files]
+```
+
+In a local DVC project, we could have obtained this dataset at this point with
+the following command:
+
+```dvc
+$ dvc import git@github.com:iterative/dataset-registry.git \
+             use-cases/cats-dogs
+```
+
+> Note that unlike `dvc get`, which can be used from any directory, `dvc import`
+> always needs to run from an [initialized](/doc/command-reference/init) DVC
+> project.
+
+<details>
+
+### Expand for actionable command (optional)
+
+The command above is meant for informational purposes only. If you actually run
+it in a DVC project, although it should work, it will import the latest version
+of `use-cases/cats-dogs` from `dataset-registry`. The following command would
+actually bring in the version in question:
+
+```dvc
+$ dvc import --rev cats-dogs-v1 \
+             git@github.com:iterative/dataset-registry.git \
+             use-cases/cats-dogs
+```
+
+See the `dvc import` command reference for more details on the `--rev`
+(revision) option.
+
+</details>
+
+Importing keeps the connection between the local project and the source data
+registry where we are downloading the dataset from. This is achieved by creating
+a particular kind of [DVC-file](/doc/user-guide/dvc-file-format) that uses the
+`repo` field (a.k.a. _import stage_). (This file can be used for versioning the
+import with Git.)
+
+> For a sample DVC-file resulting from `dvc import`, refer to
+> [this example](/doc/command-reference/import#example-data-registry).
+
+Back in our **dataset-registry** project, a
+[second version](https://github.com/iterative/dataset-registry/tree/cats-dogs-v2/use-cases)
+of our dataset was created by extracting the second part, with 1000 additional
+images (500 cats, 500 dogs), into the same directory structure. Then, we simply
+ran `dvc add use-cases/cats-dogs` again.
+
+In our local project, all we have to do in order to obtain this latest version
+of the dataset is to run:
+
+```dvc
+$ dvc update cats-dogs.dvc
+```
+
+This is possible because of the connection that the import stage saved among
+local and source projects, as explained earlier.
+
+<details>
+
+### Expand for actionable command (optional)
+
+As with the previous hidden note, actually trying the commands above should
+produced the expected results, but not for obvious reasons. Specifically, the
+initial `dvc import` command would have already obtained the latest version of
+the dataset (as noted before), so this `dvc update` is unnecessary and won't
+have an effect.
+
+If you ran the `dvc import --rev cats-dogs-v1 ...` command instead, its import
+stage (DVC-file) would be fixed to that Git tag (`cats-dogs-v1`). In order to
+update it, do not use `dvc update`. Instead, re-import the data by using the
+original import command (without `--rev`). Refer to
+[this example](http://localhost:3000/doc/command-reference/import#example-fixed-revisions-re-importing)
+for more information.
+
+</details>
+
+This downloads new and changed files in `cats-dogs/` from the source project,
+and updates the metadata in the import stage DVC-file.
+
+As an extra detail, notice that so far our local project is working only with a
+local <abbr>cache</abbr>. It has no need to setup a
+[remotes](/doc/command-reference/remote) to [pull](/doc/command-reference/pull)
+or [push](/doc/command-reference/push) this dataset.
diff --git a/static/docs/use-cases/index.md b/static/docs/use-cases/index.md
index 1c6db65adf..90c9288132 100644
--- a/static/docs/use-cases/index.md
+++ b/static/docs/use-cases/index.md
@@ -9,13 +9,16 @@ range from basic to more advanced:
 - [Data Versioning](/doc/use-cases/versioning-data-and-model-files) describes
   our most primary use: tracking and versioning large files with Git + DVC.
 - [Sharing Data and Model Files](/doc/use-cases/sharing-data-and-model-files)
-  goes over basic collaboration possibilities enabled by DVC.
-- [Shared Development Server](/doc/use-cases/shared-development-server)
-  describes a single development machine setup for teams that prefer so.
+  goes over the basic collaboration possibilities enabled by DVC.
+- [Shared Development Server](/doc/use-cases/shared-development-server) provides
+  instructions to setup a single development machine for teams that prefer so.
+- [Data Registry](/doc/use-cases/data-registry) explains how to use a <abbr>DVC
+  repository<abbr> as a shared hub for reusing datasets or models among several
+  projects.
 
-This list of use cases is _not_ exhaustive. We keep reviewing our docs and will
-include interesting scenarios that surface in our community. Please,
-[contact us](/support) if you need help or have suggestions!
+> This list of use cases is **not** exhaustive. We keep reviewing our docs and
+> will include interesting scenarios that surface in the community. Please,
+> [contact us](/support) if you need help or have suggestions!
 
 Use cases are not written to be run end-to-end. For more general, hands-on
 experience with DVC, we recommend following the [Get Started](/doc/get-started),
diff --git a/static/docs/use-cases/shared-development-server.md b/static/docs/use-cases/shared-development-server.md
index edba5ecd88..6bbd866534 100644
--- a/static/docs/use-cases/shared-development-server.md
+++ b/static/docs/use-cases/shared-development-server.md
@@ -1,21 +1,19 @@
 # Shared Development Server
 
 Some teams may prefer using one single shared machine to run their experiments.
-This allows them to have better resource utilization such as the ability to use
-multiple GPUs, centralize all data storage, etc.
+This allows better resource utilization, such as the ability to use multiple
+GPUs, centralized data storage, etc. With DVC, you can easily setup shared data
+storage on a server accessed by several users, in a way that enables almost
+instantaneous <abbr>workspace</abbr> restoration/switching speed for everyone –
+similar to `git checkout` for your code.
 
 ![](/static/img/shared-server.png)
 
-With DVC, you can easily setup shared data storage on the server. This allows
-your team to store and share data for your projects effectively, and to have
-almost instantaneous <abbr>workspace</abbr> restoration/switching speed –
-similar to `git checkout` for your code.
-
-### Preparation
+## Preparation
 
-Create a shared directory to be used as <abbr>cache</abbr> location for
-everyone's <abbr>projects</abbr>, so that all your colleagues can use the same
-project cache:
+Create a shared directory to be used as the <abbr>cache</abbr> location for
+everyone's <abbr>DVC projects</abbr>, so that all your colleagues can use the
+same project cache:
 
 ```dvc
 $ mkdir -p /path/to/dvc-cache
@@ -27,7 +25,7 @@ written by others. The most straightforward way to do this is to make sure that
 everyone's users are members of the same group, and that your shared cache
 directory is owned by this group, with the aforementioned permissions.
 
-### Transfer existing cache (Optional)
+## Transfer existing cache (Optional)
 
 This step is optional. You can skip it if you are setting up a new DVC project
 whose cache directory is not stored in the default location, `.dvc/cache`. If
@@ -39,7 +37,7 @@ to simply move it from an old cache location to the new one:
 $ mv .dvc/cache/* /path/to/dvc-cache
 ```
 
-### Configure shared cache
+## Configure shared cache
 
 Tell DVC to use the directory we've set up above as an shared cache location by
 running:
@@ -55,7 +53,7 @@ $ git add .dvc/config
 $ git commit -m "dvc: shared external cache dir"
 ```
 
-### Examples
+## Examples
 
 You and your colleagues can work in your own separate <abbr>workspaces</abbr> as
 usual, and DVC will handle all your data in the most effective way possible.
diff --git a/static/docs/use-cases/sharing-data-and-model-files.md b/static/docs/use-cases/sharing-data-and-model-files.md
index 6a3dce4194..fc5dc395ab 100644
--- a/static/docs/use-cases/sharing-data-and-model-files.md
+++ b/static/docs/use-cases/sharing-data-and-model-files.md
@@ -1,14 +1,14 @@
 # Sharing Data and Model Files
 
 Like Git, DVC allows for a distributed environment and collaboration. We make it
-easy to consistently get all your data files and directories, along with
-matching source code to any machine. All you need to do is to setup
+easy to consistently get all your data files and directories into any machine,
+along with matching source code. All you need to do is to setup
 [remote storage](/doc/command-reference/remote) for your <abbr>DVC
-project</abbr> to store data files online, where others can reach them.
-Currently DVC supports Amazon S3, Google Cloud Storage, Microsoft Azure Blob
-Storage, SSH, HDFS, and other remote locations, and the list is constantly
-growing. (For a complete list of supported remote types and their configuration,
-take a look at the examples in `dvc remote add`.)
+project</abbr>, and push the data there, so others can reach it. Currently DVC
+supports Amazon S3, Google Cloud Storage, Microsoft Azure Blob Storage, SSH,
+HDFS, and other remote locations, and the list is constantly growing. (For a
+complete list and configuration instructions, take a look at the examples in
+`dvc remote add`.)
 
 ![](/static/img/model-sharing-digram.png)
 
diff --git a/static/docs/use-cases/versioning-data-and-model-files.md b/static/docs/use-cases/versioning-data-and-model-files.md
index 4e590a4f7e..134d2e4f29 100644
--- a/static/docs/use-cases/versioning-data-and-model-files.md
+++ b/static/docs/use-cases/versioning-data-and-model-files.md
@@ -5,13 +5,13 @@
 > [Versioning](/doc/tutorials/versioning) tutorial.
 
 DVC allows versioning data files and directories, intermediate results, and ML
-models using Git, but without storing the file contents in the repository. It's
-useful in general when dealing with files that are too large for Git to handle
-properly. DVC records information about your data in a special
-[DVC-file](/doc/user-guide/dvc-file-format). This description of files or
-directories can be used for versioning. DVC supports various types of
-[remote storage](/doc/command-reference/remote) for data that allows easily
-saving and sharing data alongside code.
+models using Git, but without storing the file contents in the Git repository.
+It's useful when dealing with files that are too large for Git to handle
+properly in general. DVC saves information about your data in special
+[DVC-files](/doc/user-guide/dvc-file-format), and these metafiles can be used
+for versioning. To actually store the data, DVC supports various types of
+[remote storage](/doc/command-reference/remote). This allows easily saving and
+sharing data alongside code.
 
 ![](/static/img/model-versioning-diagram.png)
 
diff --git a/static/docs/user-guide/dvc-file-format.md b/static/docs/user-guide/dvc-file-format.md
index c3359a7dd3..0b61870593 100644
--- a/static/docs/user-guide/dvc-file-format.md
+++ b/static/docs/user-guide/dvc-file-format.md
@@ -3,9 +3,9 @@
 When you add a file (with `dvc add`) or a command (with `dvc run`) to a
 [pipeline](/doc/command-reference/pipeline), DVC creates a special text metafile
 with the `.dvc` file extension (e.g. `process.dvc`), or with the default name
-`Dvcfile`. DVC-files a.k.a. **stage files** contain all the needed information
-to track your data and reproduce pipeline stages. The file itself contains a
-simple YAML format that could be easily written or altered manually.
+`Dvcfile`. These **DVC-files** (a.k.a. stage files) contain all the needed
+information to track your data and reproduce pipeline stages. The file itself
+contains a simple YAML format that could be easily written or altered manually.
 
 See the [Syntax Highlighting](/doc/install/plugins) to learn how to enable the
 highlighting for your editor.
@@ -62,12 +62,12 @@ A dependency entry consists of a pair of fields:
   [stages](/doc/command-reference/run))
 - `etag`: Strong ETag response header (only HTTP <abbr>external
   dependencies</abbr> created with `dvc import-url`)
-- `repo`: This entry is only for DVC repository external dependencies created
-  with `dvc import`, and in itself contains the following fields:
+- `repo`: This entry is only for external dependencies created with
+  `dvc import`, and in itself contains the following fields:
 
   - `url`: URL of Git repository with source DVC project
-  - `rev_lock`: Revision or version (Git commit hash) of the DVC repo at the
-    time of importing the dependency
+  - `rev_lock`: Revision or version (Git commit hash) of the external <abbr>DVC
+    repository</abbr> at the time of importing the dependency
 
   > See the examples in
   > [External Dependencies](/doc/user-guide/external-dependencies) for more
diff --git a/static/docs/user-guide/dvc-files-and-directories.md b/static/docs/user-guide/dvc-files-and-directories.md
index be43dfb1f1..54e3e0ed8d 100644
--- a/static/docs/user-guide/dvc-files-and-directories.md
+++ b/static/docs/user-guide/dvc-files-and-directories.md
@@ -14,8 +14,8 @@ operation:
   hand or with the command `dvc config --local`.
 
 - `.dvc/cache`: The [cache directory](#structure-of-cache-directory) will store
-  your data. The data files and directories in DVC repositories will only
-  contain links to the data files in the cache. (Refer to
+  your data. The data files and directories in <abbr>DVC repositories</abbr>
+  will only contain links to the data files in the cache. (Refer to
   [Large Dataset Optimization](/docs/user-guide/large-dataset-optimization). See
   `dvc config cache` for related configuration options.
 
@@ -43,19 +43,20 @@ operation:
 
 ## Structure of cache directory
 
-There are two ways in which the data is stored in <abbr>cache</abbr>. It depends
-on whether the data in question is a single file (eg. `data.csv`) or a directory
-of files.
+There are two ways in which the data is stored in <abbr>cache</abbr>: As a
+single file (eg. `data.csv`), or a directory of files.
 
 For the first case, we calculate the file's checksum, a 32 characters long
 string (usually MD5). The first two characters are used to name the directory
-inside `.dvc/cache` and the rest become the file name of the cached file. For
+inside `.dvc/cache`, and the rest become the file name of the cached file. For
 example, if a data file `Posts.xml.zip` has checksum
 `ec1d2935f811b77cc49b031b999cbf17`, its cache entry will be
-`.dvc/cache/ec/1d2935f811b77cc49b031b999cbf17` locally. If pushed to
-[remote storage](/doc/command-reference/remote), its location will be
-`<prefix>/ec/1d2935f811b77cc49b031b999cbf17`, where prefix is the name of the
-DVC remote.
+`.dvc/cache/ec/1d2935f811b77cc49b031b999cbf17` locally.
+
+> **Note!** File checksums are calculated from file contents only. 2 or more
+> files with different names but the same contents can exist in the workspace
+> and be tracked by DVC, but only one copy is stored in the cache. This helps
+> avoid data duplication in cache and remotes.
 
 For the second case, let us consider a directory with 2 images.
 
@@ -95,7 +96,7 @@ $ tree .dvc/cache
     └── 0b40427ee0998e9802335d98f08cd98f
 ```
 
-The cache file with `.dir` extension is a special text file that stores the
+The cache file with `.dir` extension is a special text file that contains the
 mapping of files in the `data/` directory (as a JSON array), along with their
 checksums. The other two cache files are the files inside `data/`. A typical
 `.dir` cache file looks like this:
diff --git a/static/docs/user-guide/external-dependencies.md b/static/docs/user-guide/external-dependencies.md
index c59b1ece1c..1b5d988962 100644
--- a/static/docs/user-guide/external-dependencies.md
+++ b/static/docs/user-guide/external-dependencies.md
@@ -151,9 +151,9 @@ if the file has changed and we need to download it again.
 
 ## Example: Using import
 
-`dvc import` can download a <abbr>data artifact</abbr> from an external DVC
-repository. It also creates an external dependency in its <abbr>import
-stage</abbr> (DVC-file).
+`dvc import` can download a <abbr>data artifact</abbr> from an external
+<abbr>DVC repository</abbr>repository. It also creates an external dependency in
+its <abbr>import stage</abbr> (DVC-file).
 
 ```dvc
 $ dvc import git@github.com:iterative/example-get-started model.pkl
@@ -184,7 +184,7 @@ outs:
     persist: false
 ```
 
-For external sources that are DVC repositories, `url` and `rev_lock` fields are
-used to specify the origin and version of the dependency.
+For external sources that are <abbr>DVC repositories</abbr>, `url` and
+`rev_lock` fields are used to specify the origin and version of the dependency.
 
 </details>