diff --git a/versioned_docs/version-4.4/reference/globals.md b/versioned_docs/version-4.4/reference/globals.md
index d8158e96..6256d50c 100644
--- a/versioned_docs/version-4.4/reference/globals.md
+++ b/versioned_docs/version-4.4/reference/globals.md
@@ -38,7 +38,7 @@ async function getRecord() {
}
```
-It is recommended that you [define a database](../getting-started) for all the tables that are required to exist in your application. This will ensure that the tables exist on the `tables` object. Also note that the property names follow a CamelCase convention for use in JavaScript and in the GraphQL Schemas, but these are translated to snake_case for the actual table names, and converted back to CamelCase when added to the `tables` object.
+It is recommended that you [define a database](../getting-started/quickstart) for all the tables that are required to exist in your application. This will ensure that the tables exist on the `tables` object. Also note that the property names follow a CamelCase convention for use in JavaScript and in the GraphQL Schemas, but these are translated to snake_case for the actual table names, and converted back to CamelCase when added to the `tables` object.
## `databases`
diff --git a/versioned_docs/version-4.5/developers/applications/index.md b/versioned_docs/version-4.5/developers/applications/index.md
index 4c36b35b..0de66484 100644
--- a/versioned_docs/version-4.5/developers/applications/index.md
+++ b/versioned_docs/version-4.5/developers/applications/index.md
@@ -34,7 +34,7 @@ flowchart LR
## Custom Functionality with JavaScript
-[The getting started guide](../../getting-started/first-harper-app) covers how to build an application entirely through schema configuration. However, if your application requires more custom functionality, you will probably want to employ your own JavaScript modules to implement more specific features and interactions. This gives you tremendous flexibility and control over how data is accessed and modified in Harper. Let's take a look at how we can use JavaScript to extend and define "resources" for custom functionality. Let's add a property to the dog records when they are returned, that includes their age in human years. In Harper, data is accessed through our [Resource API](../../reference/resources/), a standard interface to access data sources, tables, and make them available to endpoints. Database tables are `Resource` classes, and so extending the function of a table is as simple as extending their class.
+[The getting started guide](../../getting-started/quickstart) covers how to build an application entirely through schema configuration. However, if your application requires more custom functionality, you will probably want to employ your own JavaScript modules to implement more specific features and interactions. This gives you tremendous flexibility and control over how data is accessed and modified in Harper. Let's take a look at how we can use JavaScript to extend and define "resources" for custom functionality. Let's add a property to the dog records when they are returned, that includes their age in human years. In Harper, data is accessed through our [Resource API](../../reference/resources/), a standard interface to access data sources, tables, and make them available to endpoints. Database tables are `Resource` classes, and so extending the function of a table is as simple as extending their class.
To define custom (JavaScript) resources as endpoints, we need to create a `resources.js` module (this goes in the root of your application folder). And then endpoints can be defined with Resource classes that `export`ed. This can be done in addition to, or in lieu of the `@export`ed types in the schema.graphql. If you are exporting and extending a table you defined in the schema make sure you remove the `@export` from the schema so that don't export the original table or resource to the same endpoint/path you are exporting with a class. Resource classes have methods that correspond to standard HTTP/REST methods, like `get`, `post`, `patch`, and `put` to implement specific handling for any of these methods (for tables they all have default implementations). To do this, we get the `Dog` class from the defined tables, extend it, and export it:
diff --git a/versioned_docs/version-4.5/foundations/core-concepts.md b/versioned_docs/version-4.5/foundations/core-concepts.md
new file mode 100644
index 00000000..202f85ff
--- /dev/null
+++ b/versioned_docs/version-4.5/foundations/core-concepts.md
@@ -0,0 +1,80 @@
+---
+title: Core Concepts
+---
+
+# Core Concepts
+
+Before you build your first app with Harper, it helps to understand a few key ideas. These concepts show you how Harper is structured and why it’s flexible enough to power everything from a quick proof-of-concept to a production-ready platform.
+
+## Components
+
+**Components** are the building blocks of Harper.
+They’re JavaScript-based modules that extend Harper’s core, and they can talk directly to Harper’s [Global APIs](../reference/globals) (databases, tables, resources).
+
+Because components can build on top of each other, they give you composability. For example, both [Applications](../developers/applications/) and [Plugins](../developers/components/reference#extensions) are just kinds of components:
+
+- **Plugins** add individual capabilities, like defining tables or serving static assets.
+- **Applications** pull multiple plugins and resources together into a complete product.
+
+:::info
+💡 **Why it matters:** Instead of wiring up a backend from scratch, you can piece together pre-built functionality and get to working endpoints fast.
+:::
+
+## Applications (a type of Component)
+
+An **application** is a special kind of component that pulls everything together.
+Applications rely on plugins to do the work:
+
+- Use `graphqlSchema` to define your data tables.
+- Add `rest` to query that data instantly.
+- Plug in `static` to serve files or front-end assets.
+
+You can even run full frameworks like [Next.js](https://github.com/HarperDB/nextjs) or [Apollo](https://github.com/HarperDB/apollo) as Harper applications.
+
+:::info
+💡 **Why it matters:** Applications are how you ship real products on Harper. They let you stitch together resources, APIs, and UI in one place.
+:::
+
+## Plugins
+
+**Plugins** are a special kind of component that are not meant to run standalone, but instead add features to applications or other components. These were originally called **extensions** (and the [extension API](../developers/components/reference#extensions) is still supported), but the new plugin API is simultaneously a simplification and extensibility upgrade.
+
+Examples you’ll see in the ecosystem include:
+
+- **Built in plugins**: These are embedded in Harper and work out of the box. Examples include [graphqlSchema](../developers/components/built-in#graphqlschema) for database and table definitions, [rest](../developers/rest) for RESTful access to your data, and [static](../developers/components/built-in#static) for serving files or frontend assets.
+
+- **Custom plugins**: These live outside of Harper and are installed from GitHub or npm. Harper supports a few official ones, and the ecosystem may include community plugins as well. Examples include [@harperdb/nextjs](https://github.com/HarperDB/nextjs) for Next.js integration and [@harperdb/apollo](https://github.com/HarperDB/apollo) for Apollo GraphQL.
+
+:::info
+💡 **Why it matters:** Plugins give Harper its flexibility. You can compose them into applications to get powerful functionality without writing boilerplate yourself.
+:::
+
+## Resources
+
+**Resources** are Harper’s data layer and are implemented using the [`Resource`](../reference/resource/) class.
+They represent databases, tables, and other data entities, and they provide a unified API for accessing, querying, modifying, and monitoring records.
+
+At the simplest level, resources let you:
+
+- Define schemas and tables for your application data.
+- Query and update that data through Harper’s APIs.
+- Extend the base `Resource` class with JavaScript to define custom data sources or behaviors.
+
+Each `Resource` instance can represent a single record or a collection of records at a given point in time.
+Static methods on the `Resource` class handle common operations like parsing paths, running transactions, and enforcing access controls, while instance methods give you a transactional view of individual records.
+
+:::info
+💡 **Why it matters:** Whether you’re working with standard tables or custom-defined resources, everything in Harper’s data layer builds on the same model. This gives you consistency when modeling data and flexibility to extend it with your own logic. For full details, see the [Resource reference documentation](../reference/resource/).
+:::
+
+## Server
+
+At the edge of Harper is the **server layer**, which connects your data to the outside world. Harper supports REST/HTTP, WebSockets, MQTT, and more. A single resource can be available through multiple protocols at once—so the same table can power a real-time dashboard, a mobile app, and a backend API.
+
+:::info
+💡 **Why it matters:** You don’t have to choose between protocols. One data model, many ways to access it.
+:::
+
+---
+
+✅ With these concepts in mind, you’re ready to [build your first application](../getting-started/quickstart). That’s where you’ll see how Components, Resources, and Extensions come together in practice.
diff --git a/versioned_docs/version-4.5/foundations/harper-architecture.md b/versioned_docs/version-4.5/foundations/harper-architecture.md
new file mode 100644
index 00000000..d8f767fb
--- /dev/null
+++ b/versioned_docs/version-4.5/foundations/harper-architecture.md
@@ -0,0 +1,101 @@
+---
+title: Harper Architecture
+---
+
+# Harper Architecture
+
+Before diving deep into APIs and configuration, it helps to understand the big picture of how Harper works.
+Harper uses a **three-layer architecture** designed for distributed, edge-first computing. Each layer builds on the next, letting you start simple and scale as your app grows.
+
+
+
+At a high level:
+
+- **Core services** handle data, networking, and files.
+- **Plugins** layer in reusable features (REST, GraphQL, Next.js, etc.).
+- **Applications** bring everything together to deliver user-facing functionality.
+
+:::info
+💡 **Why it matters:** You focus on building your app, while Harper takes care of scaling, networking, and consistency behind the scenes.
+:::
+
+---
+
+## Core Services
+
+Harper ships with three essential services:
+
+- **Database** → Fast storage, queries, and transactions.
+- **Networking** → REST/HTTP, WebSockets, MQTT, and cluster communication.
+- **Component Management** → The system that loads, configures, and connects components (applications, plugins, resources) so they work together consistently.
+
+Think of these as Harper’s foundation—every extension and app builds on them.
+
+---
+
+## Applications & Extensions
+
+Most of your work will happen here.
+
+### Applications
+
+Applications sit at the top layer. They’re where you implement user-facing features. Examples:
+
+- A **Next.js app** served directly from Harper.
+- A **basic app** from the [Getting Started guide](../getting-started/quickstart) that defines a schema, adds a table, and automatically exposes REST endpoints with the `rest` extension.
+
+Applications don’t re-invent core logic—they declare the plugins they need.
+
+### Component Configuration
+
+Every Harper project starts with a **root configuration**.
+This configuration declares which components (applications, plugins/extensions, resources) should be loaded and how they should be initialized.
+
+Some components are self-contained, while others include configuration that ties into additional components. For example:
+
+- An application in the root config might load the `rest` plugin.
+- The `rest` plugin exposes data from the database, so its configuration links to `graphqlSchema`.
+- `graphqlSchema` defines the tables that the database service makes available.
+
+This layering of configuration is what makes Harper composable: by declaring one component in your root config, you can enable entire sets of functionality.
+
+:::info
+💡 **Why it matters:** Instead of wiring everything manually, you declare the root config, and Harper initializes the components in the right relationships.
+:::
+
+---
+
+## Resource API
+
+At the heart of Harper is the **Resource API**. It gives you a unified, consistent way to interact with data.
+
+- `get()` → fetch data
+- `post()` → create data or trigger actions
+- `put()` → replace existing data
+- `patch()` → update part of a record
+
+Every call is wrapped in a transaction, so multi-table operations stay consistent without extra boilerplate.
+
+For the complete API, see the [Resource reference](../reference/resource).
+
+:::info
+💡 **Why it matters:** You can build reliable features—like signups, payments, or analytics—without hand-rolling transaction logic.
+:::
+
+---
+
+## Transaction Model
+
+All requests run inside automatic transactions:
+
+- Read/write across multiple tables in a single request.
+- Automatic change tracking.
+- Guaranteed consistency at commit.
+
+:::info
+💡 **Why it matters:** You don’t have to think about database race conditions or half-finished writes—Harper guarantees integrity by default.
+:::
+
+---
+
+✅ With this architecture in mind, you can see how Harper scales from “hello world” to complex, distributed applications. Next, try putting it into practice by [building your first app](../developers/applications/).
diff --git a/versioned_docs/version-4.5/foundations/use-cases.md b/versioned_docs/version-4.5/foundations/use-cases.md
new file mode 100644
index 00000000..642a74f7
--- /dev/null
+++ b/versioned_docs/version-4.5/foundations/use-cases.md
@@ -0,0 +1,80 @@
+---
+title: Harper Use Cases
+---
+
+# Harper Use Cases
+
+Harper is designed to cut out infrastructure complexity so you can move faster.
+Here are some common ways developers use Harper in production today — each one showing how Harper’s architecture translates into real-world outcomes.
+
+---
+
+## RESTful APIs for Distributed & Cached Data
+
+**Great for:** web apps, mobile apps, data-heavy platforms.
+
+Harper’s most common use case is exposing distributed, cached data over a RESTful interface.
+This lets you serve complex or large-scale datasets efficiently, with built-in caching and global distribution.
+
+- Define your schema with the `graphqlSchema` plugin.
+- Expose it instantly over REST using the `rest` plugin.
+- Take advantage of Harper’s caching layer to serve hot data without extra infrastructure.
+- Power both web and mobile applications from the same API.
+
+:::info
+💡 **Why it matters:** Instead of bolting a cache or API layer onto a database, Harper gives you a unified system that scales for real-world apps.
+:::
+
+---
+
+## Online Catalogs & Content Delivery
+
+**Great for:** e-commerce sites, real estate listings, media & content platforms.
+
+Harper’s distributed architecture makes your pages load fast worldwide, improving **SEO** and **conversion rates**.
+
+- Host your frontend directly with the [Next.js Extension](https://github.com/HarperDB/nextjs).
+- Support any framework using Harper’s extension system.
+- Use Harper’s built-in caching + JavaScript layer to [server-side render pages](https://www.harpersystems.dev/development/tutorials/server-side-rendering-with-multi-tier-cache).
+- Keep pages instantly fresh with built-in [WebSocket connections](../developers/real-time#websockets).
+
+:::info
+💡 **Why it matters:** Instead of stitching together CDN + DB + API layers, you deliver catalog and content experiences from a single platform.
+:::
+
+---
+
+## Data Delivery Networks
+
+**Great for:** live sports updates, flight tracking, software updates.
+
+Harper combines **messaging**, **data storage**, and **application logic** in one system. That means:
+
+- Push real-time updates directly to clients.
+- Process and store data without leaving Harper.
+- Eliminate extra message brokers or caching systems.
+
+Explore the [real-time docs](../developers/real-time) to see how it works.
+
+:::info
+💡 **Why it matters:** You can build real-time data services in hours, not weeks, with fewer moving parts to manage.
+:::
+
+---
+
+## Edge Inference Systems
+
+**Great for:** IoT pipelines, sensor networks, edge AI.
+
+Normally, capturing and analyzing streams at the edge requires a patchwork of tools. Harper simplifies this with:
+
+- **Self-healing connections** that keep data flowing even in flaky environments.
+- The same Harper runtime running at both layers.
+
+:::info
+💡 **Why it matters:** One consistent stack across edge and cloud makes AI/ML inference faster, cheaper, and easier to scale.
+:::
+
+---
+
+✅ Want to explore more? [Contact us](https://www.harpersystems.dev/contact) and we’ll walk you through building your own use case.
diff --git a/versioned_docs/version-4.5/getting-started/harper-concepts.md b/versioned_docs/version-4.5/getting-started/harper-concepts.md
deleted file mode 100644
index 46f07cee..00000000
--- a/versioned_docs/version-4.5/getting-started/harper-concepts.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Harper Concepts
----
-
-# Harper Concepts
-
-As you begin your journey with Harper, there are a few concepts and definitions that you should understand.
-
-## Components
-
-Harper components are a core Harper concept defined as flexible JavaScript based extensions of the highly extensible core Harper platform. They are executed by Harper directly and have complete access to the Harper [Global APIs](../reference/globals) (such as Resource, databases, and tables).
-
-A key aspect to components are their extensibility; components can be built on other components. For example, a [Harper Application](../developers/applications) is a component that uses many other components. The [application template](https://github.com/HarperDB/application-template) demonstrates many of Harper's built-in components such as [rest](../developers/components/built-in#rest) (for automatic REST endpoint generation), [graphqlSchema](../developers/components/built-in#graphqlschema) (for table schema definitions), and many more.
-
-## Applications
-
-Applications are a subset of components that cannot be used directly and must depend on other extensions. Examples include defining schemas (using [graphqlSchema](../developers/components/built-in#graphqlschema) built-in extension), defining custom resources (using [jsResource](../developers/components/built-in#jsresource) built-in extension), hosting static files (using [static](../developers/components/built-in#static) built-in extension), enabling REST querying of resources (using [rest](../developers/components/built-in#rest) built-in extension), and running [Next.js](https://github.com/HarperDB/nextjs), [Astro](https://github.com/HarperDB/astro), or [Apollo](https://github.com/HarperDB/apollo) applications through their respective extensions.
-
-## Resources
-
-Resources in Harper encompass databases, tables, and schemas that store and structure data within the system. The concept is central to Harper's data management capabilities, with custom resources being enabled by the built-in jsResource extension. Resources represent the data layer of the Harper ecosystem and provide the foundation for data operations across applications built with the platform.
-
-## Server
-
-Harper is a multi-protocol server, handling incoming requests from clients and serving data from the data model. Harper supports multiple server protocols, with components for serving REST/HTTP (including Server-Sent Events), MQTT, WebSockets, and the Operations API (and custom server components can be added). Harper uses separate layers for the data model and the servers. The data model, which is defined with resources, can be exported and be used as the source for any of the servers. A single table or other resource can then be accessed and modified through REST, MQTT, SSE, or any other server protocol, for a powerful integrated model with multiple forms of access.
-Networking in Harper handles different communication protocols including HTTP, WebSocket, and MQTT, as well as event-driven systems. These networking capabilities enable Harper applications to communicate with other services, receive requests, send responses, and participate in real-time data exchange. The networking layer is fundamental to Harper's functionality as a versatile application platform.
-
-\_\_
-
-As you go through Harper, you will pick up more knowledge of other advanced areas along the way, but with these concepts, you're now ready to create your first application.
diff --git a/versioned_docs/version-4.5/getting-started/index.mdx b/versioned_docs/version-4.5/getting-started/index.mdx
deleted file mode 100644
index fc919612..00000000
--- a/versioned_docs/version-4.5/getting-started/index.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Getting Started
----
-
-import CustomDocCardList from '@site/src/components/CustomDocCardList';
-
-# Getting Started
-
-If you're new to Harper, this section will guide you through the essential resources you need to get started.
-
-Follow the steps in this documentation to discover how Harper can simplify your backend stack, eliminate many inter-process communication delays, and achieve a more predictable and performant application experience.
-
-For more advanced concepts in Harper, see our [blog](https://www.harpersystems.dev/blog).
-
-## Harper Basics
-
-
diff --git a/versioned_docs/version-4.5/getting-started/install-harper.md b/versioned_docs/version-4.5/getting-started/install-harper.md
deleted file mode 100644
index 114471e8..00000000
--- a/versioned_docs/version-4.5/getting-started/install-harper.md
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Install Harper
----
-
-# Install Harper
-
-There are three ways to install a Harper instance: using a package manager like npm, deploying it as a Docker container, and offline installation. Below is a step-by-step tutorial for each method.
-
-## Installing via NPM
-
-Before you begin, ensure you have [Node.js](https://nodejs.org/) LTS version or newer. Node.js comes with npm, which will be used to install Harper.
-
-Open your terminal or command prompt and install Harper globally by executing the command below. Installing globally allows the `harperdb` command to be accessible from anywhere on your machine, making it easier to manage multiple projects.
-
-```bash
-npm install -g harperdb
-```
-
-Once the installation finishes, simply start your Harper instance by running the command below in your terminal.
-
-```bash
-harperdb
-```
-
-This launches Harper as a standalone, where you can define your schemas, endpoints, and application logic within a single integrated environment. The first time you set this up, you will need to set up your Harper destination, username, password, config, and hostname.
-
-At this point, your local Harper instance is up and running, giving you the ability to develop and test your database applications using your favorite local development tools, including debuggers and version control systems.
-
-## Installing via Docker
-
-Using Docker to run Harper is an efficient way to manage a containerized instance that encapsulates all of Harper’s functionality. First, ensure that Docker is installed and running on your system. If it isn’t, download it from the [official Docker website](https://docs.docker.com/engine/install/) and complete the installation process.
-
-Next, open your terminal and pull the latest Harper image by running the following command:
-
-```bash
-docker pull harperdb/harperdb
-```
-
-This command downloads the official Harper image from Docker Hub, ensuring you have the most recent version of the containerized instance. Once the image is downloaded, you can start a new Harper container with the following command:
-
-```bash
-docker run -d -p 9925:9925 harperdb/harperdb
-```
-
-In this command, the `-d` flag runs the container in detached mode, allowing it to operate in the background, and the `-p 9925:9925` flag maps port 9925 on your local machine to port 9925 within the container, which is Harper’s default port. This port mapping lets you interact with the Harper instance directly from your local environment.
-
-### How to Use this Image
-
-[Harper configuration settings](https://harperdb.io/docs/reference/configuration-file/) can be passed as Docker run environment variables. If no environment variables are provided, Harper will operate with default configuration settings, such as:
-
-- ROOTPATH=/home/harperdb/hdb
-- OPERATIONSAPI_NETWORK_PORT=9925
-- HDB_ADMIN_USERNAME=HDB_ADMIN
-- HDB_ADMIN_PASSWORD=password
-- LOGGING_STDSTREAMS=true
-
-These defaults allow you to quickly start an instance, though you can customize your configuration to better suit your needs.
-
-Containers created from this image store all data and Harper configuration at `/home/harperdb/hdb`. To ensure that your data persists beyond the lifecycle of a container, you should mount this directory to a directory on the container host using a Docker volume. This ensures that your database remains available and your settings are not lost when the container is stopped or removed.
-
-:::info
-Test your Harper instance is up and running by querying `curl http://localhost:9925/health`
-:::
-
-### Example Deployments
-
-To run a Harper container in the background with persistent storage and exposed ports, you can use a command like this:
-
-```bash
-docker run -d \
- -v :/home/harperdb/hdb \
- -e HDB_ADMIN_USERNAME=HDB_ADMIN \
- -e HDB_ADMIN_PASSWORD=password \
- -e THREADS=4 \
- -p 9925:9925 \
- -p 9926:9926 \
- harperdb/harperdb
-```
-
-Here, the `` should be replaced with an actual directory path on your system where you want to store the persistent data. This command also exposes both the Harper Operations API (port 9925) and an additional HTTP port (9926).
-For a more advanced setup, enabling HTTPS and clustering, you can run:
-
-```bash
-docker run -d \
- -v :/home/harperdb/hdb \
- -e HDB_ADMIN_USERNAME=HDB_ADMIN \
- -e HDB_ADMIN_PASSWORD=password \
- -e THREADS=4 \
- -e OPERATIONSAPI_NETWORK_PORT=null \
- -e OPERATIONSAPI_NETWORK_SECUREPORT=9925 \
- -e HTTP_SECUREPORT=9926 \
- -e CLUSTERING_ENABLED=true \
- -e CLUSTERING_USER=cluster_user \
- -e CLUSTERING_PASSWORD=password \
- -e CLUSTERING_NODENAME=hdb1 \
- -p 9925:9925 \
- -p 9926:9926 \
- -p 9932:9932 \
- harperdb/harperdb
-```
-
-In this setup, additional environment variables disable the unsecure Operations API port and enable secure ports for HTTPS, along with clustering parameters such as the clustering user, password, and node name. The port 9932 is also exposed for Harper clustering communication.
-
-Finally, if you simply wish to check the Harper version using the container, execute:
-
-```bash
-docker run --rm harperdb/harperdb /bin/bash -c "harperdb version"
-```
-
-This command runs the container momentarily to print the version information, then removes the container automatically when finished.
-
-### Logs and Troubleshooting
-
-To verify that the container is running properly, you can check your running containers with:
-
-```bash
-docker ps
-```
-
-If you want to inspect the logs to ensure that Harper has started correctly, use this command (be sure to replace `` with the actual ID from the previous command):
-
-```bash
-docker logs
-```
-
-Once verified, you can access your Harper instance by opening your web browser and navigating to [http://localhost:9925](http://localhost:9925) (or the appropriate port based on your configuration).
-
-### Raw binary installation
-
-There's a different way to install Harper. You can choose your version and download the npm package and install it directly (you’ll still need Node.js and NPM). Click [this link](https://products-harperdb-io.s3.us-east-2.amazonaws.com/index.html) to download and install the package. Once you’ve downloaded the .tgz file, run the following command from the directory where you’ve placed it:
-
-```bash
-npm install -g harperdb-X.X.X.tgz harperdb install
-```
diff --git a/versioned_docs/version-4.5/getting-started/installation.md b/versioned_docs/version-4.5/getting-started/installation.md
new file mode 100644
index 00000000..e37dad66
--- /dev/null
+++ b/versioned_docs/version-4.5/getting-started/installation.md
@@ -0,0 +1,103 @@
+---
+title: Install Harper
+---
+
+# Install Harper
+
+You can get Harper running in minutes.
+Choose the option that fits your workflow:
+
+- **npm** → best for local development & quick starts.
+- **Docker** → best for containerized environments and team setups.
+- **Raw binary** → best if you need a manual or offline install.
+
+---
+
+## Install with npm (fastest way)
+
+Make sure you have [Node.js](https://nodejs.org/) (LTS or newer). Then run:
+
+```bash
+npm install -g harperdb
+harperdb
+```
+
+That’s it! Harper is now running locally.
+The first time, you’ll set up your destination, username, password, and [configuration](../deployments/configuration).
+
+✅ Quick check: open http://localhost:9925 or run:
+
+```bash
+curl http://localhost:9925/health
+```
+
+:::info
+💡 Why choose npm: It’s the simplest way to try Harper and build apps right from your laptop.
+:::
+
+## Install with Docker
+
+Want Harper in a container? Pull the image:
+
+```bash
+docker pull harperdb/harperdb
+```
+
+Start a container, mount a volume and pass environment variables:
+
+```bash
+docker run -d \
+ -v :/home/harperdb/hdb \
+ -e HDB_ADMIN_USERNAME=HDB_ADMIN \
+ -e HDB_ADMIN_PASSWORD=password \
+ -e THREADS=4 \
+ -e OPERATIONSAPI_NETWORK_PORT=null \
+ -e OPERATIONSAPI_NETWORK_SECUREPORT=9925 \
+ -e HTTP_SECUREPORT=9926 \
+ -e CLUSTERING_ENABLED=true \
+ -e CLUSTERING_USER=cluster_user \
+ -e CLUSTERING_PASSWORD=password \
+ -e CLUSTERING_NODENAME=hdb1 \
+ -p 9925:9925 \
+ -p 9926:9926 \
+ -p 9932:9932 \
+ harperdb/harperdb
+```
+
+Here, the `` should be replaced with an actual directory path on your system where you want to store the persistent data. This command also exposes both the Harper Operations API (port 9925) and an additional HTTP port (9926).
+
+✅ Quick check:
+
+```bash
+curl http://localhost:9925/health
+```
+
+:::info
+💡 Why choose Docker: Great for consistent team environments, CI/CD pipelines, or deploying Harper alongside other services.
+:::
+
+## Install from Raw Binary
+
+Need offline or manual setup? Download the package from [our release index](https://products-harperdb-io.s3.us-east-2.amazonaws.com/index.html), then install:
+
+```bash
+npm install -g harperdb-X.X.X.tgz
+harperdb install
+```
+
+:::info
+💡 Why choose Raw Binary: Works without Docker, ideal for controlled environments.
+:::
+
+## Next Steps
+
+Once Harper is running, you can:
+
+- [Build your first application](../getting-started/quickstart)
+- Explore the [Core Concepts](../foundations/core-concepts)
+- Learn about [Harper's architecture](../foundations/harper-architecture)
+- Review [Configuration options](../deployments/configuration)
+
+:::info
+Need help? Please don’t hesitate to [reach out](https://www.harpersystems.dev/contact).
+:::
diff --git a/versioned_docs/version-4.5/getting-started/first-harper-app.md b/versioned_docs/version-4.5/getting-started/quickstart.md
similarity index 99%
rename from versioned_docs/version-4.5/getting-started/first-harper-app.md
rename to versioned_docs/version-4.5/getting-started/quickstart.md
index f8090b56..75cdfbab 100644
--- a/versioned_docs/version-4.5/getting-started/first-harper-app.md
+++ b/versioned_docs/version-4.5/getting-started/quickstart.md
@@ -163,7 +163,7 @@ http://localhost:9926/Dog/?breed=Husky&name=Balto&select(id,name,breed)
Congratulations, you now have created a secure database application backend with a table, a well-defined structure, access controls, and a functional REST endpoint with query capabilities! See the [REST documentation for more information on HTTP access](../developers/rest) and see the [Schema reference](../developers/applications/defining-schemas) for more options for defining schemas.
-> Additionally, you may now use GraphQL (over HTTP) to create queries. See the documentation for that new feature [here](../../reference/graphql).
+> Additionally, you may now use GraphQL (over HTTP) to create queries. See the documentation for that new feature [here](../reference/graphql).
## Key Takeaway
diff --git a/versioned_docs/version-4.5/getting-started/what-is-harper.md b/versioned_docs/version-4.5/getting-started/what-is-harper.md
deleted file mode 100644
index 6099b048..00000000
--- a/versioned_docs/version-4.5/getting-started/what-is-harper.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: What is Harper
----
-
-# What is Harper
-
-:::info
-[Connect with our team!](https://www.harpersystems.dev/contact)
-:::
-
-## What is Harper? Performance, Simplicity, and Scale.
-
-Harper is an all-in-one backend technology that fuses database technologies, caching, application hosting, and messaging functions into a single system. Unlike traditional architectures where each piece runs independently and incurs extra costs and latency from serialization and network operations between processes, Harper systems can handle workloads seamlessly and efficiently.
-
-Harper simplifies scaling with clustering and native data replication. At scale, architectures tend to include 4 to 16 redundant, geo-distributed nodes located near every user population center. This ensures that every user experiences minimal network latency and maximum reliability in addition to the already rapid server responses.
-
-
-
-## Understanding the Paradigm Shift
-
-Have you ever combined MongoDB with Redis, Next.js with Postgres, or perhaps Fastify with anything else? The options seem endless. It turns out that the cost of serialization, network hops, and intermediary processes in these systems adds up to 50% of the total system resources used (often more). Not to mention the hundreds of milliseconds of latency they can add.
-
-What we realized is that networking systems together in this way is inefficient and only necessary because a fused technology did not exist. So, we built Harper, a database fused with a complete JavaScript application system. It’s not only orders of magnitude more performant than separated systems, but it’s also easier to deploy and manage at scale.
-
-## Build With Harper
-
-Start by running Harper locally with [npm](https://www.npmjs.com/package/harperdb) or [Docker](https://hub.docker.com/r/harperdb/harperdb).
-
-Since technology tends to be built around the storage, processing, and transfer of data, start by [defining your schema](./first-harper-app#creating-our-first-table) with the `schema.graphql` file in the root of the application directory.
-
-If you would like to [query](./first-harper-app#adding-an-endpoint) this data, add the `@export` directive to our data schema and test out the [REST](../developers/rest), [MQTT](../developers/real-time#mqtt), or [WebSocket](../developers/real-time#websockets) endpoints.
-
-When you are ready for something a little more advanced, start [customizing your application](../developers/applications/#custom-functionality-with-javascript).
-
-Finally, when it’s time to deploy, explore [replication](../developers/replication/) between nodes.
-
-If you would like to jump into the most advanced capabilities, learn about [components](../developers/components/).
-
-:::warning
-Need help? Please don’t hesitate to [reach out](https://www.harpersystems.dev/contact).
-:::
-
-## Popular Use Cases
-
-With so much functionality built in, the use cases span nearly all application systems. Some of the most popular are listed below, motivated by new levels of performance and system simplicity.
-
-### Online Catalogs & Content Delivery
-
-For use cases like e-commerce, real estate listing, and content-oriented sites, Harper’s breakthroughs in performance and distribution pay dividends in the form of better SEO and higher conversion rates. One common implementation leverages Harper’s [Next.js Component](https://github.com/HarperDB/nextjs) to host modern, performant frontend applications. Other implementations leverage the built-in caching layer and JavaScript application system to [server-side render pages](https://www.harpersystems.dev/development/tutorials/server-side-rendering-with-multi-tier-cache) that remain fully responsive because of built-in WebSocket connections.
-
-### Data Delivery Networks
-
-For use cases like real-time sports updates, flight tracking, and zero-day software update distribution, Harper is rapidly gaining popularity. Harper’s ability to receive and broadcast messages while simultaneously handling application logic and data storage streamlines operations and eliminates the need for multiple separate systems. To build an understanding of our messaging system function, refer to our [real-time documentation](../developers/real-time).
-
-### Edge Inference Systems
-
-Capturing, storing, and processing real-time data streams from client and IoT systems typically requires a stack of technology. Harper’s selective data replication and self-healing connections make for an ideal multi-tier system where edge and cloud systems both run Harper, making everything more performant.
-
-[We’re happy](https://www.harpersystems.dev/contact) to walk you through how to do this.
diff --git a/versioned_docs/version-4.5/index.mdx b/versioned_docs/version-4.5/index.mdx
index fb458855..27ee5503 100644
--- a/versioned_docs/version-4.5/index.mdx
+++ b/versioned_docs/version-4.5/index.mdx
@@ -19,19 +19,19 @@ Welcome to the Harper Documentation! Here, you'll find all things Harper, and ev
items={[
{
type: 'link',
- href: 'getting-started/install-harper',
+ href: '/docs/getting-started/installation',
label: 'Install Harper',
description: 'Pick the installation method that best suits your environment',
},
{
type: 'link',
- href: 'getting-started/what-is-harper',
- label: 'What is Harper',
- description: 'Learn about Harper, how it works, and some of its usecases',
+ href: '/docs/foundations/harper-architecture',
+ label: 'Harper Architecture',
+ description: 'Learn about what Harper is composed of, and how they work together',
},
{
type: 'link',
- href: 'getting-started/harper-concepts',
+ href: '/docs/foundations/core-concepts',
label: 'Harper Concepts',
description: "Learn about Harper's fundamental concepts and how they interact",
},
diff --git a/versioned_docs/version-4.5/reference/globals.md b/versioned_docs/version-4.5/reference/globals.md
index 1d3acd95..aa3a9190 100644
--- a/versioned_docs/version-4.5/reference/globals.md
+++ b/versioned_docs/version-4.5/reference/globals.md
@@ -38,7 +38,7 @@ async function getRecord() {
}
```
-It is recommended that you [define a database](../getting-started) for all the tables that are required to exist in your application. This will ensure that the tables exist on the `tables` object. Also note that the property names follow a CamelCase convention for use in JavaScript and in the GraphQL Schemas, but these are translated to snake_case for the actual table names, and converted back to CamelCase when added to the `tables` object.
+It is recommended that you [define a database](../getting-started/quickstart) for all the tables that are required to exist in your application. This will ensure that the tables exist on the `tables` object. Also note that the property names follow a CamelCase convention for use in JavaScript and in the GraphQL Schemas, but these are translated to snake_case for the actual table names, and converted back to CamelCase when added to the `tables` object.
## `databases`
diff --git a/versioned_docs/version-4.6/developers/applications/index.md b/versioned_docs/version-4.6/developers/applications/index.md
index bc619f4c..1d1ddaa8 100644
--- a/versioned_docs/version-4.6/developers/applications/index.md
+++ b/versioned_docs/version-4.6/developers/applications/index.md
@@ -81,7 +81,7 @@ This guide is going to walk you through building a basic Harper application usin
## Custom Functionality with JavaScript
-[The getting started guide](../getting-started/first-harper-app) covers how to build an application entirely through schema configuration. However, if your application requires more custom functionality, you will probably want to employ your own JavaScript modules to implement more specific features and interactions. This gives you tremendous flexibility and control over how data is accessed and modified in Harper. Let's take a look at how we can use JavaScript to extend and define "resources" for custom functionality. Let's add a property to the dog records when they are returned, that includes their age in human years. In Harper, data is accessed through our [Resource API](../reference/resources/), a standard interface to access data sources, tables, and make them available to endpoints. Database tables are `Resource` classes, and so extending the function of a table is as simple as extending their class.
+[The getting started guide](../getting-started/quickstart) covers how to build an application entirely through schema configuration. However, if your application requires more custom functionality, you will probably want to employ your own JavaScript modules to implement more specific features and interactions. This gives you tremendous flexibility and control over how data is accessed and modified in Harper. Let's take a look at how we can use JavaScript to extend and define "resources" for custom functionality. Let's add a property to the dog records when they are returned, that includes their age in human years. In Harper, data is accessed through our [Resource API](../reference/resources/), a standard interface to access data sources, tables, and make them available to endpoints. Database tables are `Resource` classes, and so extending the function of a table is as simple as extending their class.
To define custom (JavaScript) resources as endpoints, we need to create a `resources.js` module (this goes in the root of your application folder). And then endpoints can be defined with Resource classes that `export`ed. This can be done in addition to, or in lieu of the `@export`ed types in the schema.graphql. If you are exporting and extending a table you defined in the schema make sure you remove the `@export` from the schema so that don't export the original table or resource to the same endpoint/path you are exporting with a class. Resource classes have methods that correspond to standard HTTP/REST methods, like `get`, `post`, `patch`, and `put` to implement specific handling for any of these methods (for tables they all have default implementations). To do this, we get the `Dog` class from the defined tables, extend it, and export it:
diff --git a/versioned_docs/version-4.6/foundations/core-concepts.md b/versioned_docs/version-4.6/foundations/core-concepts.md
new file mode 100644
index 00000000..c2514c79
--- /dev/null
+++ b/versioned_docs/version-4.6/foundations/core-concepts.md
@@ -0,0 +1,80 @@
+---
+title: Core Concepts
+---
+
+# Core Concepts
+
+Before you build your first app with Harper, it helps to understand a few key ideas. These concepts show you how Harper is structured and why it’s flexible enough to power everything from a quick proof-of-concept to a production-ready platform.
+
+## Components
+
+**Components** are the building blocks of Harper.
+They’re JavaScript-based modules that extend Harper’s core, and they can talk directly to Harper’s [Global APIs](../reference/globals) (databases, tables, resources).
+
+Because components can build on top of each other, they give you composability. For example, both [Applications](../developers/applications/) and [Plugins](../reference/components/built-in-extensions) are just kinds of components:
+
+- **Plugins** add individual capabilities, like defining tables or serving static assets.
+- **Applications** pull multiple plugins and resources together into a complete product.
+
+:::info
+💡 **Why it matters:** Instead of wiring up a backend from scratch, you can piece together pre-built functionality and get to working endpoints fast.
+:::
+
+## Applications (a type of Component)
+
+An **application** is a special kind of component that pulls everything together.
+Applications rely on plugins to do the work:
+
+- Use `graphqlSchema` to define your data tables.
+- Add `rest` to query that data instantly.
+- Plug in `static` to serve files or front-end assets.
+
+You can even run full frameworks like [Next.js](https://github.com/HarperDB/nextjs) or [Apollo](https://github.com/HarperDB/apollo) as Harper applications.
+
+:::info
+💡 **Why it matters:** Applications are how you ship real products on Harper. They let you stitch together resources, APIs, and UI in one place.
+:::
+
+## Plugins
+
+**Plugins** are a special kind of component that are not meant to run standalone, but instead add features to applications or other components. These were originally called **extensions** (and the [extension API](../reference/components/extensions) is still supported), but the new [plugin API](../reference/components/plugins) is simultaneously a simplification and extensibility upgrade.
+
+Examples you’ll see in the ecosystem include:
+
+- **Built in plugins**: These are embedded in Harper and work out of the box. Examples include [graphqlSchema](../reference/components/built-in-extensions#graphqlschema) for database and table definitions, [rest](../reference/components/built-in-extensions#rest) for RESTful access to your data, and [static](../reference/components/built-in-extensions#static) for serving files or frontend assets.
+
+- **Custom plugins**: These live outside of Harper and are installed from GitHub or npm. Harper supports a few official ones, and the ecosystem may include community plugins as well. Examples include [@harperdb/nextjs](https://github.com/HarperDB/nextjs) for Next.js integration and [@harperdb/apollo](https://github.com/HarperDB/apollo) for Apollo GraphQL.
+
+:::info
+💡 **Why it matters:** Plugins give Harper its flexibility. You can compose them into applications to get powerful functionality without writing boilerplate yourself.
+:::
+
+## Resources
+
+**Resources** are Harper’s data layer and are implemented using the [`Resource`](../reference/resources/) class.
+They represent databases, tables, and other data entities, and they provide a unified API for accessing, querying, modifying, and monitoring records.
+
+At the simplest level, resources let you:
+
+- Define schemas and tables for your application data.
+- Query and update that data through Harper’s APIs.
+- Extend the base `Resource` class with JavaScript to define custom data sources or behaviors.
+
+Each `Resource` instance can represent a single record or a collection of records at a given point in time.
+Static methods on the `Resource` class handle common operations like parsing paths, running transactions, and enforcing access controls, while instance methods give you a transactional view of individual records.
+
+:::info
+💡 **Why it matters:** Whether you’re working with standard tables or custom-defined resources, everything in Harper’s data layer builds on the same model. This gives you consistency when modeling data and flexibility to extend it with your own logic. For full details, see the [Resource reference documentation](../reference/resources/).
+:::
+
+## Server
+
+At the edge of Harper is the **server layer**, which connects your data to the outside world. Harper supports REST/HTTP, WebSockets, MQTT, and more. A single resource can be available through multiple protocols at once—so the same table can power a real-time dashboard, a mobile app, and a backend API.
+
+:::info
+💡 **Why it matters:** You don’t have to choose between protocols. One data model, many ways to access it.
+:::
+
+---
+
+✅ With these concepts in mind, you’re ready to [build your first application](../getting-started/quickstart). That’s where you’ll see how Components, Resources, and Extensions come together in practice.
diff --git a/versioned_docs/version-4.6/foundations/harper-architecture.md b/versioned_docs/version-4.6/foundations/harper-architecture.md
new file mode 100644
index 00000000..0c6dfb28
--- /dev/null
+++ b/versioned_docs/version-4.6/foundations/harper-architecture.md
@@ -0,0 +1,101 @@
+---
+title: Harper Architecture
+---
+
+# Harper Architecture
+
+Before diving deep into APIs and configuration, it helps to understand the big picture of how Harper works.
+Harper uses a **three-layer architecture** designed for distributed, edge-first computing. Each layer builds on the next, letting you start simple and scale as your app grows.
+
+
+
+At a high level:
+
+- **Core services** handle data, networking, and files.
+- **Plugins** layer in reusable features (REST, GraphQL, Next.js, etc.).
+- **Applications** bring everything together to deliver user-facing functionality.
+
+:::info
+💡 **Why it matters:** You focus on building your app, while Harper takes care of scaling, networking, and consistency behind the scenes.
+:::
+
+---
+
+## Core Services
+
+Harper ships with three essential services:
+
+- **Database** → Fast storage, queries, and transactions.
+- **Networking** → REST/HTTP, WebSockets, MQTT, and cluster communication.
+- **Component Management** → The system that loads, configures, and connects components (applications, plugins, resources) so they work together consistently.
+
+Think of these as Harper’s foundation—every extension and app builds on them.
+
+---
+
+## Applications & Extensions
+
+Most of your work will happen here.
+
+### Applications
+
+Applications sit at the top layer. They’re where you implement user-facing features. Examples:
+
+- A **Next.js app** served directly from Harper.
+- A **basic app** from the [Getting Started guide](../getting-started/quickstart) that defines a schema, adds a table, and automatically exposes REST endpoints with the `rest` extension.
+
+Applications don’t re-invent core logic—they declare the plugins they need.
+
+### Component Configuration
+
+Every Harper project starts with a **root configuration**.
+This configuration declares which components (applications, plugins/extensions, resources) should be loaded and how they should be initialized.
+
+Some components are self-contained, while others include configuration that ties into additional components. For example:
+
+- An application in the root config might load the `rest` plugin.
+- The `rest` plugin exposes data from the database, so its configuration links to `graphqlSchema`.
+- `graphqlSchema` defines the tables that the database service makes available.
+
+This layering of configuration is what makes Harper composable: by declaring one component in your root config, you can enable entire sets of functionality.
+
+:::info
+💡 **Why it matters:** Instead of wiring everything manually, you declare the root config, and Harper initializes the components in the right relationships.
+:::
+
+---
+
+## Resource API
+
+At the heart of Harper is the **Resource API**. It gives you a unified, consistent way to interact with data.
+
+- `get()` → fetch data
+- `post()` → create data or trigger actions
+- `put()` → replace existing data
+- `patch()` → update part of a record
+
+Every call is wrapped in a transaction, so multi-table operations stay consistent without extra boilerplate.
+
+For the complete API, see the [Resource reference](../reference/resources).
+
+:::info
+💡 **Why it matters:** You can build reliable features—like signups, payments, or analytics—without hand-rolling transaction logic.
+:::
+
+---
+
+## Transaction Model
+
+All requests run inside automatic transactions:
+
+- Read/write across multiple tables in a single request.
+- Automatic change tracking.
+- Guaranteed consistency at commit.
+
+:::info
+💡 **Why it matters:** You don’t have to think about database race conditions or half-finished writes—Harper guarantees integrity by default.
+:::
+
+---
+
+✅ With this architecture in mind, you can see how Harper scales from “hello world” to complex, distributed applications. Next, try putting it into practice by [building your first app](../developers/applications/).
diff --git a/versioned_docs/version-4.6/foundations/use-cases.md b/versioned_docs/version-4.6/foundations/use-cases.md
new file mode 100644
index 00000000..642a74f7
--- /dev/null
+++ b/versioned_docs/version-4.6/foundations/use-cases.md
@@ -0,0 +1,80 @@
+---
+title: Harper Use Cases
+---
+
+# Harper Use Cases
+
+Harper is designed to cut out infrastructure complexity so you can move faster.
+Here are some common ways developers use Harper in production today — each one showing how Harper’s architecture translates into real-world outcomes.
+
+---
+
+## RESTful APIs for Distributed & Cached Data
+
+**Great for:** web apps, mobile apps, data-heavy platforms.
+
+Harper’s most common use case is exposing distributed, cached data over a RESTful interface.
+This lets you serve complex or large-scale datasets efficiently, with built-in caching and global distribution.
+
+- Define your schema with the `graphqlSchema` plugin.
+- Expose it instantly over REST using the `rest` plugin.
+- Take advantage of Harper’s caching layer to serve hot data without extra infrastructure.
+- Power both web and mobile applications from the same API.
+
+:::info
+💡 **Why it matters:** Instead of bolting a cache or API layer onto a database, Harper gives you a unified system that scales for real-world apps.
+:::
+
+---
+
+## Online Catalogs & Content Delivery
+
+**Great for:** e-commerce sites, real estate listings, media & content platforms.
+
+Harper’s distributed architecture makes your pages load fast worldwide, improving **SEO** and **conversion rates**.
+
+- Host your frontend directly with the [Next.js Extension](https://github.com/HarperDB/nextjs).
+- Support any framework using Harper’s extension system.
+- Use Harper’s built-in caching + JavaScript layer to [server-side render pages](https://www.harpersystems.dev/development/tutorials/server-side-rendering-with-multi-tier-cache).
+- Keep pages instantly fresh with built-in [WebSocket connections](../developers/real-time#websockets).
+
+:::info
+💡 **Why it matters:** Instead of stitching together CDN + DB + API layers, you deliver catalog and content experiences from a single platform.
+:::
+
+---
+
+## Data Delivery Networks
+
+**Great for:** live sports updates, flight tracking, software updates.
+
+Harper combines **messaging**, **data storage**, and **application logic** in one system. That means:
+
+- Push real-time updates directly to clients.
+- Process and store data without leaving Harper.
+- Eliminate extra message brokers or caching systems.
+
+Explore the [real-time docs](../developers/real-time) to see how it works.
+
+:::info
+💡 **Why it matters:** You can build real-time data services in hours, not weeks, with fewer moving parts to manage.
+:::
+
+---
+
+## Edge Inference Systems
+
+**Great for:** IoT pipelines, sensor networks, edge AI.
+
+Normally, capturing and analyzing streams at the edge requires a patchwork of tools. Harper simplifies this with:
+
+- **Self-healing connections** that keep data flowing even in flaky environments.
+- The same Harper runtime running at both layers.
+
+:::info
+💡 **Why it matters:** One consistent stack across edge and cloud makes AI/ML inference faster, cheaper, and easier to scale.
+:::
+
+---
+
+✅ Want to explore more? [Contact us](https://www.harpersystems.dev/contact) and we’ll walk you through building your own use case.
diff --git a/versioned_docs/version-4.6/getting-started/harper-concepts.md b/versioned_docs/version-4.6/getting-started/harper-concepts.md
deleted file mode 100644
index 0e88b0d1..00000000
--- a/versioned_docs/version-4.6/getting-started/harper-concepts.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Harper Concepts
----
-
-# Harper Concepts
-
-As you begin your journey with Harper, there are a few concepts and definitions that you should understand.
-
-## Components
-
-Harper components are a core Harper concept defined as flexible JavaScript based extensions of the highly extensible core Harper platform. They are executed by Harper directly and have complete access to the Harper [Global APIs](../reference/globals) (such as Resource, databases, and tables).
-
-A key aspect to components are their extensibility; components can be built on other components. For example, a [Harper Application](../developers/applications/) is a component that uses many other components. The [application template](https://github.com/HarperDB/application-template) demonstrates many of Harper's built-in components such as [rest](../reference/components/built-in-extensions#rest) (for automatic REST endpoint generation), [graphqlSchema](../reference/components/built-in-extensions#graphqlschema) (for table schema definitions), and many more.
-
-## Applications
-
-Applications are a subset of components that cannot be used directly and must depend on other extensions. Examples include defining schemas (using [graphqlSchema](../reference/components/built-in-extensions#graphqlschema) built-in extension), defining custom resources (using [jsResource](../reference/components/built-in-extensions#jsresource) built-in extension), hosting static files (using [static](../reference/components/built-in-extensions#static) built-in extension), enabling REST querying of resources (using [rest](../reference/components/built-in-extensions#rest) built-in extension), and running [Next.js](https://github.com/HarperDB/nextjs), [Astro](https://github.com/HarperDB/astro), or [Apollo](https://github.com/HarperDB/apollo) applications through their respective extensions.
-
-## Resources
-
-Resources in Harper encompass databases, tables, and schemas that store and structure data within the system. The concept is central to Harper's data management capabilities, with custom resources being enabled by the built-in jsResource extension. Resources represent the data layer of the Harper ecosystem and provide the foundation for data operations across applications built with the platform.
-
-## Server
-
-Harper is a multi-protocol server, handling incoming requests from clients and serving data from the data model. Harper supports multiple server protocols, with components for serving REST/HTTP (including Server-Sent Events), MQTT, WebSockets, and the Operations API (and custom server components can be added). Harper uses separate layers for the data model and the servers. The data model, which is defined with resources, can be exported and be used as the source for any of the servers. A single table or other resource can then be accessed and modified through REST, MQTT, SSE, or any other server protocol, for a powerful integrated model with multiple forms of access.
-Networking in Harper handles different communication protocols including HTTP, WebSocket, and MQTT, as well as event-driven systems. These networking capabilities enable Harper applications to communicate with other services, receive requests, send responses, and participate in real-time data exchange. The networking layer is fundamental to Harper's functionality as a versatile application platform.
-
-\_\_
-
-As you go through Harper, you will pick up more knowledge of other advanced areas along the way, but with these concepts, you're now ready to create your first application.
diff --git a/versioned_docs/version-4.6/getting-started/index.mdx b/versioned_docs/version-4.6/getting-started/index.mdx
deleted file mode 100644
index fc919612..00000000
--- a/versioned_docs/version-4.6/getting-started/index.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Getting Started
----
-
-import CustomDocCardList from '@site/src/components/CustomDocCardList';
-
-# Getting Started
-
-If you're new to Harper, this section will guide you through the essential resources you need to get started.
-
-Follow the steps in this documentation to discover how Harper can simplify your backend stack, eliminate many inter-process communication delays, and achieve a more predictable and performant application experience.
-
-For more advanced concepts in Harper, see our [blog](https://www.harpersystems.dev/blog).
-
-## Harper Basics
-
-
diff --git a/versioned_docs/version-4.6/getting-started/install-harper.md b/versioned_docs/version-4.6/getting-started/install-harper.md
deleted file mode 100644
index 114471e8..00000000
--- a/versioned_docs/version-4.6/getting-started/install-harper.md
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Install Harper
----
-
-# Install Harper
-
-There are three ways to install a Harper instance: using a package manager like npm, deploying it as a Docker container, and offline installation. Below is a step-by-step tutorial for each method.
-
-## Installing via NPM
-
-Before you begin, ensure you have [Node.js](https://nodejs.org/) LTS version or newer. Node.js comes with npm, which will be used to install Harper.
-
-Open your terminal or command prompt and install Harper globally by executing the command below. Installing globally allows the `harperdb` command to be accessible from anywhere on your machine, making it easier to manage multiple projects.
-
-```bash
-npm install -g harperdb
-```
-
-Once the installation finishes, simply start your Harper instance by running the command below in your terminal.
-
-```bash
-harperdb
-```
-
-This launches Harper as a standalone, where you can define your schemas, endpoints, and application logic within a single integrated environment. The first time you set this up, you will need to set up your Harper destination, username, password, config, and hostname.
-
-At this point, your local Harper instance is up and running, giving you the ability to develop and test your database applications using your favorite local development tools, including debuggers and version control systems.
-
-## Installing via Docker
-
-Using Docker to run Harper is an efficient way to manage a containerized instance that encapsulates all of Harper’s functionality. First, ensure that Docker is installed and running on your system. If it isn’t, download it from the [official Docker website](https://docs.docker.com/engine/install/) and complete the installation process.
-
-Next, open your terminal and pull the latest Harper image by running the following command:
-
-```bash
-docker pull harperdb/harperdb
-```
-
-This command downloads the official Harper image from Docker Hub, ensuring you have the most recent version of the containerized instance. Once the image is downloaded, you can start a new Harper container with the following command:
-
-```bash
-docker run -d -p 9925:9925 harperdb/harperdb
-```
-
-In this command, the `-d` flag runs the container in detached mode, allowing it to operate in the background, and the `-p 9925:9925` flag maps port 9925 on your local machine to port 9925 within the container, which is Harper’s default port. This port mapping lets you interact with the Harper instance directly from your local environment.
-
-### How to Use this Image
-
-[Harper configuration settings](https://harperdb.io/docs/reference/configuration-file/) can be passed as Docker run environment variables. If no environment variables are provided, Harper will operate with default configuration settings, such as:
-
-- ROOTPATH=/home/harperdb/hdb
-- OPERATIONSAPI_NETWORK_PORT=9925
-- HDB_ADMIN_USERNAME=HDB_ADMIN
-- HDB_ADMIN_PASSWORD=password
-- LOGGING_STDSTREAMS=true
-
-These defaults allow you to quickly start an instance, though you can customize your configuration to better suit your needs.
-
-Containers created from this image store all data and Harper configuration at `/home/harperdb/hdb`. To ensure that your data persists beyond the lifecycle of a container, you should mount this directory to a directory on the container host using a Docker volume. This ensures that your database remains available and your settings are not lost when the container is stopped or removed.
-
-:::info
-Test your Harper instance is up and running by querying `curl http://localhost:9925/health`
-:::
-
-### Example Deployments
-
-To run a Harper container in the background with persistent storage and exposed ports, you can use a command like this:
-
-```bash
-docker run -d \
- -v :/home/harperdb/hdb \
- -e HDB_ADMIN_USERNAME=HDB_ADMIN \
- -e HDB_ADMIN_PASSWORD=password \
- -e THREADS=4 \
- -p 9925:9925 \
- -p 9926:9926 \
- harperdb/harperdb
-```
-
-Here, the `` should be replaced with an actual directory path on your system where you want to store the persistent data. This command also exposes both the Harper Operations API (port 9925) and an additional HTTP port (9926).
-For a more advanced setup, enabling HTTPS and clustering, you can run:
-
-```bash
-docker run -d \
- -v :/home/harperdb/hdb \
- -e HDB_ADMIN_USERNAME=HDB_ADMIN \
- -e HDB_ADMIN_PASSWORD=password \
- -e THREADS=4 \
- -e OPERATIONSAPI_NETWORK_PORT=null \
- -e OPERATIONSAPI_NETWORK_SECUREPORT=9925 \
- -e HTTP_SECUREPORT=9926 \
- -e CLUSTERING_ENABLED=true \
- -e CLUSTERING_USER=cluster_user \
- -e CLUSTERING_PASSWORD=password \
- -e CLUSTERING_NODENAME=hdb1 \
- -p 9925:9925 \
- -p 9926:9926 \
- -p 9932:9932 \
- harperdb/harperdb
-```
-
-In this setup, additional environment variables disable the unsecure Operations API port and enable secure ports for HTTPS, along with clustering parameters such as the clustering user, password, and node name. The port 9932 is also exposed for Harper clustering communication.
-
-Finally, if you simply wish to check the Harper version using the container, execute:
-
-```bash
-docker run --rm harperdb/harperdb /bin/bash -c "harperdb version"
-```
-
-This command runs the container momentarily to print the version information, then removes the container automatically when finished.
-
-### Logs and Troubleshooting
-
-To verify that the container is running properly, you can check your running containers with:
-
-```bash
-docker ps
-```
-
-If you want to inspect the logs to ensure that Harper has started correctly, use this command (be sure to replace `` with the actual ID from the previous command):
-
-```bash
-docker logs
-```
-
-Once verified, you can access your Harper instance by opening your web browser and navigating to [http://localhost:9925](http://localhost:9925) (or the appropriate port based on your configuration).
-
-### Raw binary installation
-
-There's a different way to install Harper. You can choose your version and download the npm package and install it directly (you’ll still need Node.js and NPM). Click [this link](https://products-harperdb-io.s3.us-east-2.amazonaws.com/index.html) to download and install the package. Once you’ve downloaded the .tgz file, run the following command from the directory where you’ve placed it:
-
-```bash
-npm install -g harperdb-X.X.X.tgz harperdb install
-```
diff --git a/versioned_docs/version-4.6/getting-started/installation.md b/versioned_docs/version-4.6/getting-started/installation.md
new file mode 100644
index 00000000..e37dad66
--- /dev/null
+++ b/versioned_docs/version-4.6/getting-started/installation.md
@@ -0,0 +1,103 @@
+---
+title: Install Harper
+---
+
+# Install Harper
+
+You can get Harper running in minutes.
+Choose the option that fits your workflow:
+
+- **npm** → best for local development & quick starts.
+- **Docker** → best for containerized environments and team setups.
+- **Raw binary** → best if you need a manual or offline install.
+
+---
+
+## Install with npm (fastest way)
+
+Make sure you have [Node.js](https://nodejs.org/) (LTS or newer). Then run:
+
+```bash
+npm install -g harperdb
+harperdb
+```
+
+That’s it! Harper is now running locally.
+The first time, you’ll set up your destination, username, password, and [configuration](../deployments/configuration).
+
+✅ Quick check: open http://localhost:9925 or run:
+
+```bash
+curl http://localhost:9925/health
+```
+
+:::info
+💡 Why choose npm: It’s the simplest way to try Harper and build apps right from your laptop.
+:::
+
+## Install with Docker
+
+Want Harper in a container? Pull the image:
+
+```bash
+docker pull harperdb/harperdb
+```
+
+Start a container, mount a volume and pass environment variables:
+
+```bash
+docker run -d \
+ -v :/home/harperdb/hdb \
+ -e HDB_ADMIN_USERNAME=HDB_ADMIN \
+ -e HDB_ADMIN_PASSWORD=password \
+ -e THREADS=4 \
+ -e OPERATIONSAPI_NETWORK_PORT=null \
+ -e OPERATIONSAPI_NETWORK_SECUREPORT=9925 \
+ -e HTTP_SECUREPORT=9926 \
+ -e CLUSTERING_ENABLED=true \
+ -e CLUSTERING_USER=cluster_user \
+ -e CLUSTERING_PASSWORD=password \
+ -e CLUSTERING_NODENAME=hdb1 \
+ -p 9925:9925 \
+ -p 9926:9926 \
+ -p 9932:9932 \
+ harperdb/harperdb
+```
+
+Here, the `` should be replaced with an actual directory path on your system where you want to store the persistent data. This command also exposes both the Harper Operations API (port 9925) and an additional HTTP port (9926).
+
+✅ Quick check:
+
+```bash
+curl http://localhost:9925/health
+```
+
+:::info
+💡 Why choose Docker: Great for consistent team environments, CI/CD pipelines, or deploying Harper alongside other services.
+:::
+
+## Install from Raw Binary
+
+Need offline or manual setup? Download the package from [our release index](https://products-harperdb-io.s3.us-east-2.amazonaws.com/index.html), then install:
+
+```bash
+npm install -g harperdb-X.X.X.tgz
+harperdb install
+```
+
+:::info
+💡 Why choose Raw Binary: Works without Docker, ideal for controlled environments.
+:::
+
+## Next Steps
+
+Once Harper is running, you can:
+
+- [Build your first application](../getting-started/quickstart)
+- Explore the [Core Concepts](../foundations/core-concepts)
+- Learn about [Harper's architecture](../foundations/harper-architecture)
+- Review [Configuration options](../deployments/configuration)
+
+:::info
+Need help? Please don’t hesitate to [reach out](https://www.harpersystems.dev/contact).
+:::
diff --git a/versioned_docs/version-4.6/getting-started/quickstart.md b/versioned_docs/version-4.6/getting-started/quickstart.md
new file mode 100644
index 00000000..75cdfbab
--- /dev/null
+++ b/versioned_docs/version-4.6/getting-started/quickstart.md
@@ -0,0 +1,170 @@
+---
+title: Create Your First Application
+---
+
+# Create Your First Application
+
+Now that you've set up Harper, let's build a simple API. Harper lets you build powerful APIs with minimal effort. In just a few minutes, you'll have a functional REST API with automatic validation, indexing, and querying—all without writing a single line of code.
+
+## Setup Your Project
+
+Start by cloning the Harper application template:
+
+```bash
+git clone https://github.com/HarperDB/application-template my-app
+cd my-app
+```
+
+## Creating our first Table
+
+The core of a Harper application is the database, so let's create a database table.
+
+A quick and expressive way to define a table is through a [GraphQL Schema](https://graphql.org/learn/schema). Using your editor of choice, edit the file named `schema.graphql` in the root of the application directory, `my-app`, that we created above. To create a table, we will need to add a `type` of `@table` named `Dog` (and you can remove the example table in the template):
+
+```graphql
+type Dog @table {
+ # properties will go here soon
+}
+```
+
+And then we'll add a primary key named `id` of type `ID`:
+
+_(Note: A GraphQL schema is a fast method to define tables in Harper, but you are by no means required to use GraphQL to query your application, nor should you necessarily do so)_
+
+```graphql
+type Dog @table {
+ id: ID @primaryKey
+}
+```
+
+Now we tell Harper to run this as an application:
+
+```bash
+harperdb dev . # tell Harper cli to run current directory as an application in dev mode
+```
+
+Harper will now create the `Dog` table and its `id` attribute we just defined. Not only is this an easy way to create a table, but this schema is included in our application, which will ensure that this table exists wherever we deploy this application (to any Harper instance).
+
+## Adding Attributes to our Table
+
+Next, let's expand our `Dog` table by adding additional typed attributes for dog `name`, `breed` and `age`.
+
+```graphql
+type Dog @table {
+ id: ID @primaryKey
+ name: String
+ breed: String
+ age: Int
+}
+```
+
+This will ensure that new records must have these properties with these types.
+
+Because we ran `harperdb dev .` earlier (dev mode), Harper is now monitoring the contents of our application directory for changes and reloading when they occur. This means that once we save our schema file with these new attributes, Harper will automatically reload our application, read `my-app/schema.graphql` and update the `Dog` table and attributes we just defined. The dev mode will also ensure that any logging or errors are immediately displayed in the console (rather only in the log file).
+
+As a document database, Harper supports heterogeneous records, so you can freely specify additional properties on any record. If you do want to restrict the records to only defined properties, you can always do that by adding the sealed directive:
+
+```graphql
+type Dog @table @sealed {
+ id: ID @primaryKey
+ name: String
+ breed: String
+ age: Int
+ tricks: [String]
+}
+```
+
+## Adding an Endpoint
+
+Now that we have a running application with a database (with data if you imported any data), let's make this data accessible from a RESTful URL by adding an endpoint. To do this, we simply add the `@export` directive to our `Dog` table:
+
+```graphql
+type Dog @table @export {
+ id: ID @primaryKey
+ name: String
+ breed: String
+ age: Int
+ tricks: [String]
+}
+```
+
+By default the application HTTP server port is `9926` (this can be [configured here](../deployments/configuration#http)), so the local URL would be `http://localhost:9926/Dog/` with a full REST API. We can PUT or POST data into this table using this new path, and then GET or DELETE from it as well (you can even view data directly from the browser). If you have not added any records yet, we could use a PUT or POST to add a record. PUT is appropriate if you know the id, and POST can be used to assign an id:
+
+```bash
+curl -X POST http://localhost:9926/Dog/ \
+ -H "Content-Type: application/json" \
+ -d '{
+ "name": "Harper",
+ "breed": "Labrador",
+ "age": 3,
+ "tricks": ["sits"]
+ }'
+```
+
+With this a record will be created and the auto-assigned id will be available through the `Location` header. If you added a record, you can visit the path `/Dog/` to view that record. Alternately, the curl command `curl http://localhost:9926/Dog/` will achieve the same thing.
+
+## Authenticating Endpoints
+
+Now that you've created your first API endpoints, it's important to ensure they're protected. Without authentication, anyone could potentially access, misuse, or overload your APIs, whether by accident or malicious intent. Authentication verifies who is making the request and enables you to control access based on identity, roles, or permissions. It’s a foundational step in building secure, reliable applications.
+
+Endpoints created with Harper automatically support `Basic`, `Cookie`, and `JWT` authentication methods. See the documentation on [security](../developers/security/) for more information on different levels of access.
+
+By default, Harper also automatically authorizes all requests from loopback IP addresses (from the same computer) as the superuser, to make it simple to interact for local development. If you want to test authentication/authorization, or enforce stricter security, you may want to disable the [`authentication.authorizeLocal` setting](../deployments/configuration#authentication).
+
+### Content Negotiation
+
+These endpoints support various content types, including `JSON`, `CBOR`, `MessagePack` and `CSV`. Simply include an `Accept` header in your requests with the preferred content type. We recommend `CBOR` as a compact, efficient encoding with rich data types, but `JSON` is familiar and great for web application development, and `CSV` can be useful for exporting data to spreadsheets or other processing.
+
+Harper works with other important standard HTTP headers as well, and these endpoints are even capable of caching interaction:
+
+```
+Authorization: Basic
+Accept: application/cbor
+If-None-Match: "etag-id" # browsers can automatically provide this
+```
+
+## Querying
+
+Querying your application database is straightforward and easy, as tables exported with the `@export` directive are automatically exposed via [REST endpoints](../developers/rest). Simple queries can be crafted through [URL query parameters](https://en.wikipedia.org/wiki/Query_string).
+
+In order to maintain reasonable query speed on a database as it grows in size, it is critical to select and establish the proper indexes. So, before we add the `@export` declaration to our `Dog` table and begin querying it, let's take a moment to target some table properties for indexing. We'll use `name` and `breed` as indexed table properties on our `Dog` table. All we need to do to accomplish this is tag these properties with the `@indexed` directive:
+
+```graphql
+type Dog @table {
+ id: ID @primaryKey
+ name: String @indexed
+ breed: String @indexed
+ owner: String
+ age: Int
+ tricks: [String]
+}
+```
+
+And finally, we'll add the `@export` directive to expose the table as a RESTful endpoint
+
+```graphql
+type Dog @table @export {
+ id: ID @primaryKey
+ name: String @indexed
+ breed: String @indexed
+ owner: String
+ age: Int
+ tricks: [String]
+}
+```
+
+Now we can start querying. Again, we just simply access the endpoint with query parameters (basic GET requests), like:
+
+```
+http://localhost:9926/Dog/?name=Harper
+http://localhost:9926/Dog/?breed=Labrador
+http://localhost:9926/Dog/?breed=Husky&name=Balto&select(id,name,breed)
+```
+
+Congratulations, you now have created a secure database application backend with a table, a well-defined structure, access controls, and a functional REST endpoint with query capabilities! See the [REST documentation for more information on HTTP access](../developers/rest) and see the [Schema reference](../developers/applications/defining-schemas) for more options for defining schemas.
+
+> Additionally, you may now use GraphQL (over HTTP) to create queries. See the documentation for that new feature [here](../reference/graphql).
+
+## Key Takeaway
+
+Harper's schema-driven approach means you can build production-ready APIs in minutes, not hours. Start with pure schema definitions to get 90% of your functionality, then add custom code only where needed. This gives you the best of both worlds: rapid development with the flexibility to customize when required.
diff --git a/versioned_docs/version-4.6/getting-started/what-is-harper.md b/versioned_docs/version-4.6/getting-started/what-is-harper.md
deleted file mode 100644
index 60bc6a84..00000000
--- a/versioned_docs/version-4.6/getting-started/what-is-harper.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: What is Harper
----
-
-# What is Harper
-
-:::info
-[Connect with our team!](https://www.harpersystems.dev/contact)
-:::
-
-## What is Harper? Performance, Simplicity, and Scale.
-
-Harper is an all-in-one backend technology that fuses database technologies, caching, application hosting, and messaging functions into a single system. Unlike traditional architectures where each piece runs independently and incurs extra costs and latency from serialization and network operations between processes, Harper systems can handle workloads seamlessly and efficiently.
-
-Harper simplifies scaling with clustering and native data replication. At scale, architectures tend to include 4 to 16 redundant, geo-distributed nodes located near every user population center. This ensures that every user experiences minimal network latency and maximum reliability in addition to the already rapid server responses.
-
-
-
-## Understanding the Paradigm Shift
-
-Have you ever combined MongoDB with Redis, Next.js with Postgres, or perhaps Fastify with anything else? The options seem endless. It turns out that the cost of serialization, network hops, and intermediary processes in these systems adds up to 50% of the total system resources used (often more). Not to mention the hundreds of milliseconds of latency they can add.
-
-What we realized is that networking systems together in this way is inefficient and only necessary because a fused technology did not exist. So, we built Harper, a database fused with a complete JavaScript application system. It’s not only orders of magnitude more performant than separated systems, but it’s also easier to deploy and manage at scale.
-
-## Build With Harper
-
-Start by running Harper locally with [npm](https://www.npmjs.com/package/harperdb) or [Docker](https://hub.docker.com/r/harperdb/harperdb).
-
-Since technology tends to be built around the storage, processing, and transfer of data, start by [defining your schema](../developers/applications/#creating-our-first-table) with the `schema.graphql` file in the root of the application directory.
-
-If you would like to [query](../developers/applications/#adding-an-endpoint) this data, add the `@export` directive to our data schema and test out the [REST](../developers/rest), [MQTT](../developers/real-time#mqtt), or [WebSocket](../developers/real-time#websockets) endpoints.
-
-When you are ready for something a little more advanced, start [customizing your application](../developers/applications/#custom-functionality-with-javascript).
-
-Finally, when it’s time to deploy, explore [replication](../developers/replication/) between nodes.
-
-If you would like to jump into the most advanced capabilities, learn about [components](../reference/components/).
-
-:::warning
-Need help? Please don’t hesitate to [reach out](https://www.harpersystems.dev/contact).
-:::
-
-## Popular Use Cases
-
-With so much functionality built in, the use cases span nearly all application systems. Some of the most popular are listed below, motivated by new levels of performance and system simplicity.
-
-### Online Catalogs & Content Delivery
-
-For use cases like e-commerce, real estate listing, and content-oriented sites, Harper’s breakthroughs in performance and distribution pay dividends in the form of better SEO and higher conversion rates. One common implementation leverages Harper’s [Next.js Component](https://github.com/HarperDB/nextjs) to host modern, performant frontend applications. Other implementations leverage the built-in caching layer and JavaScript application system to [server-side render pages](https://www.harpersystems.dev/development/tutorials/server-side-rendering-with-multi-tier-cache) that remain fully responsive because of built-in WebSocket connections.
-
-### Data Delivery Networks
-
-For use cases like real-time sports updates, flight tracking, and zero-day software update distribution, Harper is rapidly gaining popularity. Harper’s ability to receive and broadcast messages while simultaneously handling application logic and data storage streamlines operations and eliminates the need for multiple separate systems. To build an understanding of our messaging system function, refer to our [real-time documentation](../developers/real-time).
-
-### Edge Inference Systems
-
-Capturing, storing, and processing real-time data streams from client and IoT systems typically requires a stack of technology. Harper’s selective data replication and self-healing connections make for an ideal multi-tier system where edge and cloud systems both run Harper, making everything more performant.
-
-[We’re happy](https://www.harpersystems.dev/contact) to walk you through how to do this.
diff --git a/versioned_docs/version-4.6/index.mdx b/versioned_docs/version-4.6/index.mdx
index 19f890a6..446da533 100644
--- a/versioned_docs/version-4.6/index.mdx
+++ b/versioned_docs/version-4.6/index.mdx
@@ -10,7 +10,9 @@ import CustomDocCardList from '@site/src/components/CustomDocCardList';
[Connect with our team!](https://www.harpersystems.dev/contact)
:::
-Welcome to the Harper Documentation! Here, you'll find all things Harper, and everything you need to get started, troubleshoot issues, and make the most of our platform.
+Harper is an all-in-one backend technology that fuses database technologies, caching, application hosting, and messaging functions into a single system. Unlike traditional architectures where each piece runs independently and incurs extra costs and latency from serialization and network operations between processes, Harper systems can handle workloads seamlessly and efficiently.
+
+Here, you'll find all things Harper, and everything you need to get started, troubleshoot issues, and make the most of our platform.
## Getting Started
@@ -19,19 +21,19 @@ Welcome to the Harper Documentation! Here, you'll find all things Harper, and ev
items={[
{
type: 'link',
- href: 'docs/getting-started/install-harper',
+ href: '/docs/getting-started/installation',
label: 'Install Harper',
description: 'Pick the installation method that best suits your environment',
},
{
type: 'link',
- href: 'docs/getting-started/what-is-harper',
- label: 'What is Harper',
- description: 'Learn about Harper, how it works, and some of its usecases',
+ href: '/docs/foundations/harper-architecture',
+ label: 'Harper Architecture',
+ description: 'Learn about what Harper is composed of, and how they work together',
},
{
type: 'link',
- href: 'docs/getting-started/harper-concepts',
+ href: '/docs/foundations/core-concepts',
label: 'Harper Concepts',
description: "Learn about Harper's fundamental concepts and how they interact",
},
diff --git a/versioned_sidebars/version-4.4-sidebars.json b/versioned_sidebars/version-4.4-sidebars.json
index f4ff0475..ced3c7f0 100644
--- a/versioned_sidebars/version-4.4-sidebars.json
+++ b/versioned_sidebars/version-4.4-sidebars.json
@@ -5,16 +5,15 @@
"id": "index",
"label": "Harper Docs"
},
- "getting-started",
{
"type": "category",
- "label": "Developers",
- "items": [
- {
- "type": "autogenerated",
- "dirName": "developers"
- }
- ]
+ "label": "Getting Started",
+ "items": ["getting-started/installation", "getting-started/quickstart"]
+ },
+ {
+ "type": "category",
+ "label": "Foundations of Harper",
+ "items": ["foundations/harper-architecture", "foundations/core-concepts", "foundations/use-cases"]
},
{
"type": "category",
diff --git a/versioned_sidebars/version-4.5-sidebars.json b/versioned_sidebars/version-4.5-sidebars.json
index b160e1f2..07801d54 100644
--- a/versioned_sidebars/version-4.5-sidebars.json
+++ b/versioned_sidebars/version-4.5-sidebars.json
@@ -8,16 +8,12 @@
{
"type": "category",
"label": "Getting Started",
- "link": {
- "type": "doc",
- "id": "getting-started/index"
- },
- "items": [
- "getting-started/what-is-harper",
- "getting-started/install-harper",
- "getting-started/harper-concepts",
- "getting-started/first-harper-app"
- ]
+ "items": ["getting-started/installation", "getting-started/quickstart"]
+ },
+ {
+ "type": "category",
+ "label": "Foundations of Harper",
+ "items": ["foundations/harper-architecture", "foundations/core-concepts", "foundations/use-cases"]
},
{
"type": "category",
diff --git a/versioned_sidebars/version-4.6-sidebars.json b/versioned_sidebars/version-4.6-sidebars.json
index b160e1f2..07801d54 100644
--- a/versioned_sidebars/version-4.6-sidebars.json
+++ b/versioned_sidebars/version-4.6-sidebars.json
@@ -8,16 +8,12 @@
{
"type": "category",
"label": "Getting Started",
- "link": {
- "type": "doc",
- "id": "getting-started/index"
- },
- "items": [
- "getting-started/what-is-harper",
- "getting-started/install-harper",
- "getting-started/harper-concepts",
- "getting-started/first-harper-app"
- ]
+ "items": ["getting-started/installation", "getting-started/quickstart"]
+ },
+ {
+ "type": "category",
+ "label": "Foundations of Harper",
+ "items": ["foundations/harper-architecture", "foundations/core-concepts", "foundations/use-cases"]
},
{
"type": "category",