--- a/devtools/docs/SUMMARY.md
+++ b/devtools/docs/SUMMARY.md
@@ -1,14 +1,14 @@
 
 # Summary
 
 * [Getting started](getting-started/README.md)
   * [Where is the code?](getting-started/where-is-the-code.md)
-  * [Servers and actors](getting-started/servers-and-actors.md)
+  * [Architecture overview](getting-started/architecture-overview.md)
   * [Set up to build DevTools](getting-started/build.md)
   * [Development profiles](getting-started/development-profiles.md)
 * [Bugs and issue trackers](bugs-issues.md)
 * [Files and directories](files/README.md)
   * [Adding New Files](files/adding-files.md)
 * [Tool Architectures](tools/tools.md)
   * [Inspector](tools/inspector.md)
     * [Panel Architecture](tools/inspector-panel.md)

new file mode 100644
--- /dev/null
+++ b/devtools/docs/getting-started/architecture-overview.md
@@ -0,0 +1,13 @@
+# Architecture overview 
+
+Broadly speaking, the tools are divided in two parts: the server and the client. A **server** is anything that can be debugged: for example, your browser, but it could also be Firefox for Android, running on another device. The **client** is the front-end side of the tools, and it is what developers interact with when using the tools.
+
+Since these two parts are decoupled, we can connect to any server using the same client. This enables us to debug multiple types of servers, using the same protocol to communicate.
+
+You will often hear about `actors`. Each feature that can be debugged (for example, network) is exposed via an `actor`, which provides data about that specific feature. It's up to each server to implement some or all actors; the client needs to find out and decide what it can render on the front-side when it connects to the server. So when we want to debug a new feature, we might need to do work in two parts of the code: the server (perhaps implementing a new actor, or extending existing ones) and the client (to display the debugging data returned by the actor).
+
+Often, an actor will correspond to a panel. But a panel might want to get data from multiple actors.
+
+You might also hear about `the toolbox`. The toolbox is what everyone else calls `developer tools` i.e. the front-end that you see when you open the tools in your browser.
+
+

--- a/devtools/docs/getting-started/build.md
+++ b/devtools/docs/getting-started/build.md
@@ -45,17 +45,17 @@ Building also takes a long time (special
 ### Running your own compiled version of Firefox
 
 To run the Firefox you just compiled:
 
 ```bash
 ./mach run
 ```
 
-This will run using an empty temporary profile which is discarded when you close the browser. We will look more into persistent development profiles later.<!--TODO: add link to that section when it's written-->
+This will run using an empty temporary profile which is discarded when you close the browser. We will look more into [persistent development profiles later](./development-profiles.md).
 
 ### Rebuilding
 
 Suppose you pulled the latest changes from the remote repository (or made your own changes) and want to build again.
 
 You can ask the `mach` script to build only changed files:
 
 ```bash

--- a/devtools/docs/getting-started/development-profiles.md
+++ b/devtools/docs/getting-started/development-profiles.md
@@ -1,15 +1,15 @@
 # Setting up a development profile
 
 You can have various [Firefox profiles](https://developer.mozilla.org/en-US/Firefox/Multiple_profiles) (think of something like "user accounts"), each one with different settings, addons, appearance, etc.
 
 This page will guide you through configuring a new profile to enable development features such as additional logging, dumping of network packets, remote debugging, etc. which will help when working in DevTools.
 
-Many of these changes are achieved by modifying preferences in `about:config`, an special page you can access by entering that in Firefox's URL bar. The first time, it will show you a warning page. Click through and then you can start searching for preferences to modify.
+Many of these changes are achieved by modifying preferences in `about:config`, a special page you can access by entering that in Firefox's URL bar. The first time, it will show you a warning page. Click through and then you can start searching for preferences to modify.
 
 Here's [a support article](https://support.mozilla.org/t5/Manage-preferences-and-add-ons/Configuration-Editor-for-Firefox/ta-p/35030) if you need help.
 
 ## Create a permanent profile
 
 We were using a temporary profile in the previous step, [building DevTools](./build.md). The contents of this profile are deleted each time the browser is closed, which means any preferences we set will not persist.
 
 The solution is to create a new profile:

deleted file mode 100644
--- a/devtools/docs/getting-started/servers-and-actors.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Servers and actors
-
-Broadly speaking, the tools are divided in two parts: the server and the client. A **server** is anything that can be debugged: for example, your browser, but it could also be Firefox for Android, running on another device. The **client** is the front-end side of the tools, and it is what developers interact with when using the tools.
-
-Since these two parts are decoupled, we can connect to any server using the same client. This enables us to debug multiple types of servers, using the same protocol to communicate.
-
-You will often hear about `actors`. Each feature that can be debugged (for example, network) is exposed via an `actor`, which provides data about that specific feature. It's up to each server to implement some or all actors; the client needs to find out and decide what it can render on the front-side when it connects to the server. So when we want to debug a new feature, we might need to do work in two parts of the code: the server (perhaps implementing a new actor, or extending existing ones) and the client (to display the debugging data returned by the actor).
-
-Often, an actor will correspond to a panel. But a panel might want to get data from multiple actors.
-
-You might also hear about `the toolbox`. The toolbox is what everyone else calls `developer tools` i.e. the front-end that you see when you open the tools in your browser.
-
-