Implement variables - get started section

_partials/_caggs-intro.md

@@ -1,5 +1,5 @@
 Time-series data usually grows very quickly. And that means that aggregating the
-data into useful summaries can become very slow. Continuous aggregates makes
+data into useful summaries can become very slow. $CAGG_CAPs make
 aggregating data lightning fast.
 
 If you are collecting data very frequently, you might want to aggregate your
@@ -8,25 +8,23 @@ temperature readings taken every second, you can find the average temperature
 for each hour. Every time you run this query, the database needs to scan the
 entire table and recalculate the average every time.
 
-Continuous aggregates are a kind of hypertable that is refreshed automatically
+$CAGG_CAPs are a kind of $HYPERTABLE that is refreshed automatically
 in the background as new data is added, or old data is modified. Changes to your
-dataset are tracked, and the hypertable behind the continuous aggregate is
+dataset are tracked, and the $HYPERTABLE behind the $CAGG is
 automatically updated in the background.
 
-You don't need to manually refresh your continuous aggregates, they are
-continuously and incrementally updated in the background. Continuous aggregates
-also have a much lower maintenance burden than regular PostgreSQL materialized
+You don't need to manually refresh your $CAGGs, they are
+continuously and incrementally updated in the background. They also have a much lower maintenance burden than regular PostgreSQL materialized
 views, because the whole view is not created from scratch on each refresh. This
 means that you can get on with working your data instead of maintaining your
 database.
 
-Because continuous aggregates are based on hypertables, you can query them in
+Because $CAGGs are based on $HYPERTABLEs, you can query them in
 exactly the same way as your other tables, and enable [compression][compression]
-or [tiered storage][data-tiering] on your continuous aggregates. You can even
-create
-[continuous aggregates on top of your continuous aggregates][hierarchical-caggs].
+or [tiered storage][data-tiering] on your $CAGGs. You can even
+create [$CAGGs on top of your $CAGGs][hierarchical-caggs].
 
-By default, querying continuous aggregates provides you with real-time data.
+By default, querying $CAGGs provides you with real-time data.
 Pre-aggregated data from the materialized view is combined with recent data that
 hasn't been aggregated yet. This gives you up-to-date results on every query.
 

_partials/_caggs-types.md

@@ -1,22 +1,22 @@
 There are three main ways to make aggregation easier: materialized views,
-continuous aggregates, and real time aggregates.
+$CAGGs, and $RTAGGs.
 
 [Materialized views][pg-materialized views] are a standard PostgreSQL function.
 They are used to cache the result of a complex query so that you can reuse it
 later on. Materialized views do not update regularly, although you can manually
 refresh them as required.
 
-[Continuous aggregates][about-caggs] are a Timescale only feature. They work in
+[$CAGG_CAPs][about-caggs] are a $COMPANY-only feature. They work in
 a similar way to a materialized view, but they are updated automatically in the
-background, as new data is added to your database. Continuous aggregates are
+background, as new data is added to your database. $CAGG_CAPs are
 updated continuously and incrementally, which means they are less resource
-intensive to maintain than materialized views. Continuous aggregates are based
-on hypertables, and you can query them in the same way as you do your other
+intensive to maintain than materialized views. $CAGG_CAPs are based
+on $HYPERTABLEs, and you can query them in the same way as you do your other
 tables.
 
-[Real time aggregates][real-time-aggs] are a Timescale only feature. They are
-the same as continuous aggregates, but they add the most recent raw data to the
-previously aggregated data to provide accurate and up to date results, without
+[$RTAGG_CAPs][real-time-aggs] are a $COMPANY-only feature. They are
+the same as $CAGGs, but they add the most recent raw data to the
+previously aggregated data to provide accurate and up-to-date results, without
 needing to aggregate data as it is being written.
 
 [pg-materialized views]: https://www.postgresql.org/docs/current/rules-materializedviews.html

_partials/_cloud-connect.md

@@ -1,45 +1,45 @@
 
 <Procedure>
 
-To connect to a service:
+To connect to a $SERVICE_SHORT:
 
-1. **Check your service is running correctly**
+1. **Check your $SERVICE_SHORT is running correctly**
 
-    In [Timescale Console][services-portal], check that your service is marked as `Running`.
+    In [$CONSOLE][services-portal], check that your $SERVICE_SHORT is marked as `Running`.
 
    ![Check service is running](https://assets.timescale.com/docs/images/console-services-view.png)
 
-1. **Connect to your service**
+1. **Connect to your $SERVICE_LONG**
 
     Use either:  
-    - [Data mode][popsql] in Timescale Console:  
-      1. In the [data mode][portal-data-mode] in Timescale Console, select a service and enter your password, then click **Connect**.
+    - [$DATA_MODE_CAPS][popsql] in $CONSOLE:  
+      1. In the [$DATA_MODE][portal-data-mode] in $CONSOLE, select a $SERVICE_SHORT and enter your password, then click **Connect**.
 
          You find your password in the config file you just downloaded.
       2. Select a query to edit:
          ![Select a query to edit](https://assets.timescale.com/docs/images/data-mode-query-window.png)
 
-    - [SQL editor][run-sqleditor] in Timescale Console:
+    - [$SQL_EDITOR][run-sqleditor] in $CONSOLE:
 
-       In the [ops mode][portal-ops-mode] in Timescale Console, select a service, then click **SQL editor**. 
+       In the [$DATA_MODE][portal-ops-mode] in $CONSOLE, select a $SERVICE_SHORT, then click **$SQL_EDITOR**. 
 
       ![Check service is running](https://assets.timescale.com/docs/images/ops-view-sql-editor.png)
 
     - [psql][install-psql] on the command line:
 
-      Connect to your service with the value of `Service URL` from the config file you 
+      Connect to your $SERVICE_SHORT with the value of `Service URL` from the config file you 
         just saved:
 
         <CodeBlock canCopy={true} showLineNumbers={false} children={`
         psql "postgres://tsdbadmin:<PASSWORD>@<HOST>:<PORT>/tsdb?sslmode=require"
         `} />
 
-   You can now run queries for this service.
+   You can now run queries for this $SERVICE_SHORT.
 
 Quick recap. You:
-- Manage your services in the [ops mode][portal-ops-mode] in Timescale Console:  add read replicas and enable 
+- Manage your $SERVICE_SHORTS in the [ops mode][portal-ops-mode] in $CONSOLE: add $READ_REPLICAs and enable 
   high-availability, configure compression, change parameters, and so on.
-- Analyze your data in the [data mode][portal-data-mode] in Timescale Console: write queries with
+- Analyze your data in the [$DATA_MODE_][portal-data-mode] in $CONSOLE: write queries with
   autocomplete, save them in folders, share them, create charts/dashboards, and much more.
 - Store configuration and security information in your config file.
 

_partials/_cloud-installation.md

@@ -1,15 +1,15 @@
-## Create a Timescale Cloud account
+## Create a $CLOUD_LONG account
 
 <Procedure>
 
-To set up Timescale:
+To set up $COMPANY:
 
 1.  Sign up for a [30 day free trial][sign-up].
 
     You receive a confirmation email in your inbox.
-1.  In the confirmation email, click the link supplied and sign in to [Timescale Console][tsc-portal].
+1.  In the confirmation email, click the link supplied and sign in to [$CONSOLE][tsc-portal].
 
-    Answer the requirements questions, they help us optimize the Timescale service for your use case. You can now create a Timescale service.
+    Answer the requirements questions, they help us optimize the $SERVICE_LONG for your use case. You can now create a $SERVICE_SHORT.
 
 
 

_partials/_cloud-intro.md

@@ -1,7 +1,7 @@
-Timescale Cloud is a cloud-based PostgreSQL platform for resource-intensive workloads. We help you build faster, 
-scale further, and stay under budget. Timescale Cloud offers the following PostgreSQL optimized database services:
+$CLOUD_LONG is a cloud-based PostgreSQL platform for resource-intensive workloads. We help you build faster, 
+scale further, and stay under budget. $CLOUD_LONG offers the following PostgreSQL optimized database services:
 
-- **[Time-series and Analytics][create-service]**: a Timescale DB instance optimized for your
+- **[Time-series and Analytics][create-service]**: a $TIMESCALE_DB instance optimized for your
   [time-series and analytics][what-is-time-series] workloads. Get automated dynamic data partitioning, hybrid 
   row-columnar storage, advanced compression techniques, incremental up-to-date materializations, and specialized 
   analysis functions as well as cloud-only features like transparent tiering and low-cost object storage.

_partials/_create-hypertable.md

@@ -1,15 +1,15 @@
 
 <Procedure>
 
-[Hypertables][hypertables] are PostgreSQL tables that automatically partition your data by time. You interact
-with hypertables in the same way as regular PostgreSQL tables, but with extra features that makes managing your
+[$HYPERTABLEs][hypertables] are PostgreSQL tables that automatically partition your data by time. You interact
+with $HYPERTABLEs in the same way as regular PostgreSQL tables, but with extra features that makes managing your
 time-series data much easier.
 
-To create a hypertable:
+To create a $HYPERTABLE:
 
-1. **Connect to your service**
+1. **Connect to your $SERVICE_SHORT**
 
-    In Timescale Console, click `Data`, then select a service.
+    In $CONSOLE, click `Data`, then select a $SERVICE_SHORT.
 
 1. **Create a PostgreSQL table** 
 
@@ -27,9 +27,9 @@ To create a hypertable:
 
     ![Data mode create table](https://assets.timescale.com/docs/images/data-mode-create-table.png)
 
-1.  **Make a hypertable**
+1.  **Make a $HYPERTABLE**
 
-    Copy the following into your SQL editor, then run your query:
+    Copy the following into your $SQL_EDITOR, then run your query:
     ```sql
     SELECT create_hypertable('stocks_real_time', by_range('time'));
     ```

_partials/_hypertables-intro.md

@@ -1,15 +1,15 @@
-Hypertables are PostgreSQL tables that automatically partition your data by
-time. You interact with hypertables in the same way as regular PostgreSQL
+$HYPERTABLE_CAPs are PostgreSQL tables that automatically partition your data by
+time. You interact with $HYPERTABLEs in the same way as regular PostgreSQL
 tables, but with extra features that makes managing your time-series data much
 easier.
 
-In Timescale, hypertables exist alongside regular PostgreSQL tables. Use
-hypertables to store time-series data. This gives you improved insert and query
+In $COMPANY, $HYPERTABLEs exist alongside regular PostgreSQL tables. Use
+$HYPERTABLEs to store time-series data. This gives you improved insert and query
 performance, and access to useful time-series features. Use regular PostgreSQL
 tables for other relational data.
 
-With hypertables, Timescale makes it easy to improve insert and query
+With $HYPERTABLEs, $COMPANY makes it easy to improve insert and query
 performance by partitioning time-series data on its time parameter. Behind the
 scenes, the database performs the work of setting up and maintaining the
-hypertable's partitions. Meanwhile, you insert and query your data as if it all
+$HYPERTABLE's partitions. Meanwhile, you insert and query your data as if it all
 lives in a single, regular PostgreSQL table.

_partials/_service-overview.md

@@ -1,5 +1,5 @@
-Each Timescale Cloud  service is a single 100% PostgreSQL database with [usage-based storage][how-plans-work]. You
-manage your services and interact with your data in Timescale Console using the following modes:
+Each $SERVICE_LONG is a single 100% PostgreSQL database with [usage-based storage][how-plans-work]. You
+manage your $SERVICE_SHORTs and interact with your data in $CONSOLE using the following modes:
 
 <table class="tg"><thead>
   <tr>

_partials/_timescale-intro.md

@@ -1,2 +1,2 @@
-Timescale extends PostgreSQL for all of your resource-intensive production workloads, so you 
+$COMPANY extends PostgreSQL for all of your resource-intensive production workloads, so you 
 can build faster, scale further, and stay under budget.

_partials/_timeseries-intro.md

@@ -1,7 +1,7 @@
 Time-series data represents how a system, process, or behavior changes over
 time. For example, if you are taking measurements from a temperature gauge every
 five minutes, you are collecting time-series data. Another common example is
-stock price changes, or even the battery life of your smart phone. As these
+stock price changes, or even the battery life of your smartphone. As these
 measurements change over time, each data point is recorded alongside its
 timestamp, allowing it to be measured, analyzed, and visualized.
 
@@ -12,13 +12,13 @@ when a change occurs.
 
 Databases have always had time fields, but using a special database for handling
 time-series data can make your database work much more effectively. Specialized
-time-series databases, like Timescale, are designed to handle large amounts of
+time-series databases, like $COMPANY, are designed to handle large amounts of
 database writes, so they work much faster. They are also optimized to handle
 schema changes, and use more flexible indexing, so you don't need to spend time
 migrating your data whenever you make a change.
 
 Time-series data is everywhere, but there are some environments where it is
-especially important to use a specialized time-series database, like Timescale:
+especially important to use a specialized time-series database, like $COMPANY:
 
 *   Monitoring computer systems: virtual machines, servers, container metrics,
     CPU, free memory, net/disk IOPs, service and application metrics such as
@@ -30,7 +30,7 @@ especially important to use a specialized time-series database, like Timescale:
     devices for smart homes.
 *   Eventing applications: user or customer interaction data such as
     clickstreams, pageviews, logins, and signups.
-*   Business intelligence: Tracking key metrics and the overall health of the
+*   Business intelligence: tracking key metrics and the overall health of the
     business.
 *   Environmental monitoring: temperature, humidity, pressure, pH, pollen count,
     air flow, carbon monoxide, nitrogen dioxide, or particulate matter.

_partials/_where-to-next.md

@@ -1,7 +1,7 @@
 Now you have TimescaleDB running, have a look at the:
 
 * [Tutorials][tutorials]: walk through a variety of business scenarios using example datasets.
-* [Use Timescale][tsdb-docs]: browse the features available with TimescaleDB.
+* [Use Timescale][tsdb-docs]: browse the features available with $TIMESCALE_DB.
 
 [tsdb-docs]: /use-timescale/:currentVersion:/
 [tutorials]: /tutorials/:currentVersion:/