diff --git a/src/data/nav.yml b/src/data/nav.yml
index 79dd65f16..06f2077ee 100644
--- a/src/data/nav.yml
+++ b/src/data/nav.yml
@@ -154,13 +154,13 @@
- title: Build a quickstart
url: '/instant-observability/build-a-quickstart'
pages:
- - title: Send data to New Relic
- url: /instant-observability/build-a-quickstart/send-data-to-newrelic
- - title: Create dashboard in New Relic One
- url: /instant-observability/build-a-quickstart/create-dashboard
+ - title: Deploy your application
+ url: /instant-observability/build-a-quickstart/deploy-your-application
+ - title: Create a dashboard
+ url: /instant-observability/build-a-quickstart/create-a-dashboard
- title: Create alerts
url: /instant-observability/build-a-quickstart/create-alerts
- - title: Create quickstart
+ - title: Create a quickstart
url: /instant-observability/build-a-quickstart/create-quickstart
- title: Try our APIs
icon: nr-share
diff --git a/src/images/instant-observability/add-notification-channel.png b/src/images/instant-observability/add-notification-channel.png
index 9299030e6..0486bbaa3 100644
Binary files a/src/images/instant-observability/add-notification-channel.png and b/src/images/instant-observability/add-notification-channel.png differ
diff --git a/src/images/instant-observability/dashboard2.png b/src/images/instant-observability/dashboard2.png
deleted file mode 100644
index 994b52d44..000000000
Binary files a/src/images/instant-observability/dashboard2.png and /dev/null differ
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/create-a-dashboard.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/create-a-dashboard.mdx
new file mode 100644
index 000000000..9e016f79c
--- /dev/null
+++ b/src/markdown-pages/instant-observability/build-a-quickstart/create-a-dashboard.mdx
@@ -0,0 +1,138 @@
+---
+path: '/instant-observability/build-a-quickstart/create-a-dashboard'
+title: 'Create a dashboard'
+template: 'GuideTemplate'
+description: 'create a dashboard to observe your data in New Relic'
+duration: '15 min'
+---
+
+
+
+This procedure is a part of lab that teaches you how to build a quickstart. If you haven't already, checkout the [_Lab introduction_](/instant-observability/build-a-quickstart)
+
+Each procedure in this lab builds on top of the last one, so make sure you [_deploy your application_](/instant-observability/build-a-quickstart/deploy-your-application) before proceeding with this one.
+
+
+
+New Relic One dashboards allow you to quickly observe and make meaning of the information that you collect. You can gather and chart the specific data you want to see and customize it the way you want to see.
+
+You're going to create dashboard in New Relic One. Navigate to https://one.newrelic.com/ and sign in with your account. Here, you can see different tabs such as **Browse Data**, **Dashboards**, **Alerts & AI** etc.
+Move to **Dashboards** and click **Create a dashboard** in the top right corner.
+
+
+
+Name your dashboard **FlashDB** and click create.
+
+
+
+## Add charts to your dashboard
+
+Once the dashboard is in place, you can start creating charts. You're going to add the folloiwng charts:
+- Database methods
+- Avergae response time
+- Errors
+- Database size
+- Cache hits
+- Keys
+
+Hover over the dashboard and click **Add a new chart**.
+
+
+
+New Relic One allow you to add charts using query builder or you can choose to add text, images or links using Markdown. Click **Add a chart**.
+
+
+
+It will take you to a query builder option. Edit the query as follow:
+
+>```SQL
+>SELECT count(*) FROM fdb_method FACET method
+>```
+
+
+
+Here, you group your results of FlashDB methods by attribute values and see the count of each type of transaction. You can choose to present your results in different formats such as table, billboard, pie chart etc.
+
+
+
+Change the chart type to pie, name your chart and click save.
+
+
+
+The chart is now visible on your dashboard.
+
+
+
+
+You can add more charts to your dashboard following the same pattern. To do so, click **+** in upper right hand corner.
+
+
+
+This will take you to the same _Add to your dashboard_ page, allowing you to add another chart, text, image or links. Add a few more charts to your dashboard as follow:
+
+### Average response time
+Run the following query to observe the **average response time** of database transactions.
+
+>```SQL
+> SELECT average(fdb_create_responses), average(fdb_read_responses), average(fdb_update_responses), average(fdb_delete_responses) FROM Metric SINCE 30 MINUTES AGO TIMESERIES
+>```
+
+
+
+>**Note:** Make sure to click **Run** to see above results.
+
+Here, you observe average response time for different transactions for past 30 minutes. Click save to add this chart to your dashboard as well. Follow the same procedure to add the following charts as well.
+
+### Errors
+
+>```SQL
+> SELECT sum(fdb_create_errors), sum(fdb_read_errors), sum(fdb_update_errors), sum(fdb_delete_errors) FROM Metric SINCE 60 MINUTES AGO TIMESERIES
+>```
+
+Here, you observe errors for all database transactions for past one hour.
+
+
+
+### Database size
+
+>```SQL
+> SELECT sum(mdb_size) FROM Metric
+>```
+
+
+
+This chart will show you the database size.
+
+### Cache hits
+
+>```SQL
+> SELECT sum(fdb_cache_hits) FROM Metric SINCE 30 MINUTES AGO TIMESERIES
+>```
+
+
+
+Here, you observe the total number of cache hits for past 30 minutes using line chart.
+
+### Keys
+
+>```SQL
+> SELECT count(fdb_keys) FROM Metric SINCE 5 MINUTES AGO TIMESERIES
+>```
+
+
+
+Here, you observe the flashDB key count for past 5 minutes.
+
+You can manipulate the above queries and change time window to focus on the data that you want to observe. Your final dashboard will look similar to the following:
+
+
+
+## Summary
+
+Following this procedure, you created a dashboard and added multiple charts to it to observe your services in New Relic One.
+
+
+
+This procedure is a part of lab that teaches you how to build a quickstart. Continue on to next procedure: [_Create alerts_](/instant-observability/build-a-quickstart/create-alerts).
+
+
\ No newline at end of file
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/create-quickstart.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/create-a-quickstart.mdx
similarity index 83%
rename from src/markdown-pages/instant-observability/build-a-quickstart/create-quickstart.mdx
rename to src/markdown-pages/instant-observability/build-a-quickstart/create-a-quickstart.mdx
index 8bf9829a4..b38944bc3 100644
--- a/src/markdown-pages/instant-observability/build-a-quickstart/create-quickstart.mdx
+++ b/src/markdown-pages/instant-observability/build-a-quickstart/create-a-quickstart.mdx
@@ -1,42 +1,44 @@
---
path: '/instant-observability/build-a-quickstart/create-quickstart'
-title: 'Create your quickstart'
+title: 'Create a quickstart'
template: 'GuideTemplate'
description: 'Package up your dashboards and alerts and create a quickstart'
duration: '30 min'
---
-New Relic One quickstarts allow you to quickly and easily observe and monitor your services since they include observability building blocks like dashboards and alerts.
-All of this is available through an open ecosystem where you could contribute your best practices.
+
-
+This procedure is a part of lab that teaches you how to build quickstart. If you haven't already, checkout the [_lab introduction_](/instant-observability/build-a-quickstart)
-This lesson is a part of lab that teaches you to build quickstart. Before proceeding with the lesson, make sure you have a GitHub account and completed the previous lessons to have your dashboards and alerts in place.
+As this procedure builds on top of the last ones in the lab, make you create a [dashboard](instant-observability/build-a-quickstart/create-a-dashboard) and [alerts](/instant-observability/build-a-quickstart/create-alerts) before proceeding with this one.
-In this lesson, you'll package your dashboards and alerts into a quickstart and contribute your quickstart to New Relic One catalog.
+New Relic One quickstarts allow you to quickly and easily observe and monitor your services since they include observability building blocks like dashboards and alerts. You can package your dashboards and alerts into a quickstart and contribute it to New Relic One catalog.
+
To get started, navigate to GitHub repository of [New Relic One Observability Packs](https://github.com/newrelic/newrelic-observability-packs) and fork it.
-Now, clone your own repository to your local machine with either using git or GitHub Desktop and open it in the IDE of your choice. Notice the directory structure. __template_ folder is of special importance since it contains the templates for observability building blocks in the quickstart.
+Now, clone your own repository to your local machine using `git clone` command and open it in the IDE of your choice.
+
+Notice the directory structure. __template_ folder is of special importance since it contains the templates for observability building blocks in the quickstart.
-
+
-As you can see in the above image, the _\_template_ directory contains the folders for dashboards, alerts, and instrumentation. Each of these folders contain a template or template directories that you can use to create entities for your quickstart.
+The _\_template_ directory contains the folders for dashboards, alerts, and instrumentation. Each of these folders contain a template or template directories that you can use to create entities for your quickstart.
## Add dashboards to quickstart
-Copy the _\_template_ directory and it's content to a new directory within the _packs_ folder. You don't need to copy the entire content but only the entities you want to create. Since you're only going to add dashboards and alerts to your quickstart, delete the _instrumentation_ directory. Choose a meaningful name for your recently created directory; which identifies the purpose of your quickstart. For FlashDB, just name it flashdb.
+Copy the _\_template_ directory and it's content to a new directory within the _packs_ folder. You don't need to copy the entire content but only the entities you want to create. Since you're only going to add dashboards and alerts to your quickstart, delete the _instrumentation_ directory. Name the directory as **flashdb**.
-You're going to add existing dashboard to your quickstart. Copy your dashboard's JSON and save it as a JSON file in the _dashboards_ directory.
+You're going to add existing dashboard to your quickstart. Move to your dashboard in New Relic One and copy its JSON. Then save it as a JSON file in the _dashboards_ directory.
-Here, you copied your dashboard's JSON to clipboard. You can simply replace the content of existing JSON file in _dashboards_ directory and rename it as **flashDB.json**. Here's what your _flashDB.json_ file should contain:
+Here, you copied your dashboard's JSON to clipboard. Replace the content of existing JSON file in _dashboards_ directory and rename it as **flashDB.json**. Your _flashDB.json_ file should contain the following content:
>```json
> {
@@ -215,19 +217,19 @@ Next, create a screenshot of your dashboard and add it to _dashboards_ directory
## Add alerts to quickstart
-The next step is to add alerts to the quickstart. The _alerts_ directory contain the templates for static, outlier and baseline alerts. You're going to add existing alerts to the quickstart.
+Next, you add alerts to the quickstart. You're going to add existing static alerts to the quickstart. The _alerts_ directory contain the templates for static alerts.
To help you populate your .yml alert files, you can use New Relic One's [Graphql API](https://api.newrelic.com/graphiql) to get the json object. Open the Graphql APi and select your account from the drop down.
-
+
-Building a query is simple in graphiql. All you need to do is check the appropriate boxes and it will do the rest. Build the query as follow in Graphql.
+Building a query is simple in graphiql. Check the appropriate boxes to build the query in Graphql. Your query should be same as follows:
>```json
>{
actor {
- account(id: 3248695) {
+ account(id: {_your account id_}) {
alerts {
- nrqlCondition(id: "{_enter nrql conditions's id_}") {
+ nrqlCondition(id: "{_nrql conditions's id_}") {
... on AlertsNrqlStaticCondition {
id
name
@@ -249,9 +251,9 @@ Building a query is simple in graphiql. All you need to do is check the appropri
}
>
-Running the above query in Graphql will respond with the details of your alert consition which you can use to update your quickstart.
+Running the above query in Graphql will respond with the details of your alert condition that you can use to update your quickstart.
-
+
For static condition, take the static-alert.yml file and start populating it using the information returned from above query.
First, name the file as **Cache Hit Ratio.yml** and populate it as follow:
@@ -356,7 +358,9 @@ Create your **Read response.yml** file based on the above response.
## Add quickstart description
Your quickstart is almost ready to go live. But how will other's know and understand what your quickstart is about and what it can do?
-To help others understnad the purpose of your quickstart, you need to add quickstart's description. In the root directory of your pack, you can find a _config.yml_ file.
+To help others understnad the purpose of your quickstart, you need to add quickstart's description.
+
+In the root directory of your pack, you can find a _config.yml_ file.
Open the file in your IDE and edit it as follow:
>```yml
@@ -418,13 +422,10 @@ Follow the [conventional commit syntax](https://github.com/newrelic/newrelic-obs
> git commit -m "feat(flashdb): Added a quickstart for flashdb"
> ```
-
+
We, at New Relic, are always happy to receive contributions from the community. However, we are expecting a number of contributions for flashdb following the same lab course.
-To help us manage your contributions efficiently, we encourage you to label your contribution following this particular lab as **lab**. You can simply using git tag command as follow:
->```bash
-> git tag lab HEAD
->
+To help us manage your contributions efficiently, we encourage you to label your contribution following this particular lab as **lab** using `git tag` command.
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/create-alerts.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/create-alerts.mdx
index c49fbd429..5c178db97 100644
--- a/src/markdown-pages/instant-observability/build-a-quickstart/create-alerts.mdx
+++ b/src/markdown-pages/instant-observability/build-a-quickstart/create-alerts.mdx
@@ -1,96 +1,111 @@
---
path: '/instant-observability/build-a-quickstart/create-alerts'
-title: 'Create Alerts'
+title: 'Create alerts'
template: 'GuideTemplate'
description: 'create alerts in New Relic One'
duration: '15 min'
---
-New Relic alerts allow you to create robust and customizable alert policies for anything that you want to monitor.
-When you set up alert conditions, you can get notified about the problems that you're interested in and you can troubleshoot and resolve problems faster.
+
-
+This procedure is a part of a lab that teaches you how to build a quickstart. If you haven't already, checkout the [_Lab introduction_](/instant-observability/build-a-quickstart)
-This lesson is a part of a lab that teaches you to build quickstart. Before you proceed with the lesson, make sure your demo services are up and running.
-It is assumed that you are already familiar with alerts basics. If you're just getting started then visit the [alert documentation](https://docs.newrelic.com/docs/alerts-applied-intelligence/) to familiarize yourself with the basics before proceeding.
+Each procedure in this lab builds on top of the last one, so make sure you [_create a dashboard_](/instant-observability/build-a-quickstart/create-a-dashboard) before proceeding with this one.
-### Create alert policy
+New Relic alerts allow you to monitor your services and notify you about problems that you're interested in, so you can react fast to troubleshoot and resolve them.
-Before you could set alert conditions, you must create a policy. For example, you want to get an alert whenever your database takes longer to respond. You can create a policy for high response rate.
-Move to _Policies_ under Alerts section of Alert & AI and click **New alert policy**.
+>**Note:** It is assumed that you are already familiar with the alerts basics. If you're just getting started, visit the [alert documentation](https://docs.newrelic.com/docs/alerts-applied-intelligence/) to familiarize yourself with the basics before proceeding.
-
+## Create an alert policy
-Give a meaningful name to your policy such as **FlashDB alert policy**. Use the default values for the rest of the fields and click **Create alert policy**.
+Before you set alert conditions, you must create a policy.
+From **Alert & AI**, go to the **Alerts** section and click **Policies** from left-hand navigation. Then, click **New alert policy**.
-
+
-The next step is to add alert conditions to the alert policy. Click **Create a condition**.
+Name your policy **FlashDB alert policy**. Use the default values for the rest of the fields and click **Create alert policy**.
-
+
-On the next page, choose the category for which you want to define the alert condition. NRQL category allow you to create alert conditions using NRQL queries. Choose this option and click **Next, define thresholds**.
+The next step is to add alert conditions to the alert policy. You're going to add folloinwg alert conditions:
+- slow read response
+- low cache hit ratio
-
+## Create alert conditions
-Enter a meaningful name for your alert condition. For example, you want to get notified if the read operation is taking longer than expected then you can create an alert condition _slow read responses_ and enter the following NRQL query for your condition.
+Under **FlashDB alert policy**, click **Create a condition**.
->```bash
+
+
+The next page asks you to choose a category for your condition. Choose NRQL, which allows you to create a condition using a NRQL query. Then click **Next, define thresholds**.
+
+
+
+You want to get notified if the read operation is taking longer than expected. Name your alert condition _slow read responses_ and enter the following NRQL query for your condition.
+
+>```SQL
> SELECT average(fdb_read_responses) FROM Metric
>```
-Here, you just selected the average read response for FlashDB. Scroll down on the same page to define threshold. Select **Static** as the threshold type. It is the simplest threshold type and creates a condition based on the numeric value returned by the query.
-Now, set the critical threshold value at 0.9 as follow:
+Here, you selected the average read response for FlashDB.
+
+Scroll down on the same page to define threshold. Select **Static** as the threshold type. It is the simplest threshold type and creates a condition based on the numeric value returned by the query.
+Set the critical threshold value at 0.9:
-Here, you define the alert condition that will open violation whenever read response time is above 0.9 for at least 5 minutes. You can also add a warning threshold by clicking **Add warning threshold**.
+Here, you defined a condition that will open violation whenever read response time is above 0.9 for at least 5 minutes. You can also add a warning threshold by clicking **Add warning threshold**.
-Now, specify a threshold value for warning. Say, you want the alert condition to warn you when the read response is above 0.8 for at least 5 minutes. Enter the threshold value as 0.8 and click **Save condition**.
+Enter the threshold value at 0.8 to get a warning when the read response is above 0.8 for at least 5 minutes.
+Then, click **Save condition**.
-You can see your alert consition under your FlashDB alert policy now.
+Now, You can see your new condition under your FlashDB alert policy.
-Since you claimed that your database is fastest in the space, you also want to observe cache hit ratio and get a notification if it is low. You can add another alert condition under the same policy by clicking **Add a condition**.
+### Create a cache hit ratio condition
+
+Since you claimed that your database is fastest in the space so, you also want New Relic to notify you if your cache hit ratio is too low. Add another condition under the same policy by clicking **Add a condition**.
-You are familiar with the next page where you choose the category for your alert condition. Choose NRQL and click **Next, define threshold**.
+The next page asks you to choose the category for your condition. Choose NRQL and click **Next, define threshold**.
-
+
-Enter the name _low cache hit ratio_ for your conditiona and the following NRQL query.
+Enter the name Low cache hit ratio for your condition and use the following NRQL query.
->```bash
+>```SQL
> SELECT sum(fdb_cache_hits)/sum(fdb_read_responses) FROM Metric
>```
-The next step is adding threshold values for critical violation as well as warning. The procedure is same as we did before. The only difference is that we want to get warning notification if the query returns a value _below_ 0.85 and a critical violation notification is the value falls _below_ 0.75 for at least 5 minutes.
+Next, add threshold values for critical violation and warning. The procedure is same as before. The only difference is that you want New Relic to notify you if the query returns a value _below_ 0.85 and open a critical violation if the value falls _below_ 0.75 for at least 5 minutes.
-Save condition to add it to previoulsy defined FlashDB alert policy. Your policy will look something like the following.
+Save the condition to add it to your alert policy which now looks like the following.
-### Add a notification channel
+## Add a notification channel
+
+To receive notifications for any opened violation, you also need to add notification channel.
-To receive notifications for any opened violation, you also need to add notification channel. Move to the Notification channels tab and click **Add notification channels**.
+First, move to the **Notification channels** tab and click **Add notification channels**.
-New Relic gives you multiple options such as Email, Slack, Webhook etc. to choose from. At simplest, click Email to add an email notification channel.
+From the list of channel options, click Email.
@@ -98,8 +113,12 @@ Select the email you want to receive your notifications on, and click **Update p
-
+## Summary
+
+During this procedure, you created FlashDB alert policy and added slow read responses and low cache hit ratio conditions to it. Y ou also added a notoification channel to receive notifications about any opened violations.
+
+
-This lesson is a part of lab that teaches you to build a quickstart. Continue on to next lesson: [_Create quickstart_](/instant-observability/build-a-quickstart/create-quickstart)
+This procedure is a part of lab that teaches you how to build a quickstart. Continue on to next lesson: [_Create a quickstart_](/instant-observability/build-a-quickstart/create-quickstart)
\ No newline at end of file
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/create-dashboard.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/create-dashboard.mdx
deleted file mode 100644
index 3e66b02bd..000000000
--- a/src/markdown-pages/instant-observability/build-a-quickstart/create-dashboard.mdx
+++ /dev/null
@@ -1,124 +0,0 @@
----
-path: '/instant-observability/build-a-quickstart/create-dashboard'
-title: 'Create dashboard in New Relic One'
-template: 'GuideTemplate'
-description: 'create dashboard to observe your data in New Relic'
-duration: '15 min'
----
-
-
-New Relic One dashboards allow you to quickly observe and make meaning of the information that you collect. You can gather and chart the specific data you want to see and customize it the way you want to see.
-
-Throughout this lesson, you're going to create different charts in New Relic One dashboard to get insights from database transactions.
-
-
-
-This lesson is a part of lab that teaches you to build quickstart. Before you proceed with this lesson, make sure you have your demo services up and running.
-
-
-
-You're going to create dashboard in New Relic One. Navigate to https://one.newrelic.com/ and sign in with your account. Here, you can see different tabs such as *Browse Data*, *Dashboards*, *Alerts & AI* etc.
-Move to *Dashboards* and click **Create a dashboard** in the top right corner.
-
-
-
-Name your dashboard and click create.
-
-
-
-## Add charts to your dashboard
-
-Once the dashboard is in place, you can start creating charts. Hover over the dashboard and click **Add a new chart** where you want to add the chart.
-
-
-
-New Relic One allow you to add chart using query builder as well as text, images or links using Markdown. Click **Add a chart**.
-
-
-
-It will take you to a query builder option. Edit the query as follow:
-
->```bash
->SELECT count(*) FROM fdb_method FACET method
->```
-
-
-
-Here, you group your results of fdb_method by attribute values. You can choose to present your results in different formats such as table, billboard, pie chart etc.
-
-
-
-Change the chart type to pie, name your chart and click save.
-
-
-
-The chart is now visible on your dashboard.
-
-
-
-
-You can add more charts to your dashboard following the same pattern. To add more charts to your dashboard, click **+** in upper right hand corner.
-
-
-
-This will take to the same _Add to your dashboard_ page, allowing you to add another chart, text, image or links. Add a few more charts to your dashboard following the same procedure as you did just now.
-#### Average response time
-Run the following query to observe the **average response time** of database transactions.
-
->```bash
-> SELECT average(fdb_create_responses), average(fdb_read_responses), average(fdb_update_responses), average(fdb_delete_responses) FROM Metric SINCE 30 MINUTES AGO TIMESERIES
->```
-
-
-
->**Note:** Make sure to click **Run** for the results to be visible.
-
-Click save to add this chart to your dashboard as well. Your dashboard will look similar to the following:
-
-
-
-Add few more charts to your dashboard as follow:
-
-#### Errors
-
->```bash
-> SELECT sum(fdb_create_errors), sum(fdb_read_errors), sum(fdb_update_errors), sum(fdb_delete_errors) FROM Metric SINCE 60 MINUTES AGO TIMESERIES
->```
-
-Here, you observe total errors for all database transactions for past one hour.
-
-
-
-#### Database size
-
->```bash
-> SELECT sum(mdb_size) FROM Metric
->```
-
-
-
-#### Cache hits
-
->```bash
-> SELECT sum(fdb_cache_hits) FROM Metric SINCE 30 MINUTES AGO TIMESERIES
->```
-
-
-
-#### Keys
-
->```bash
-> SELECT count(fdb_keys) FROM Metric SINCE 5 MINUTES AGO TIMESERIES
->```
-
-
-
-Your final dashboard will look similar to the following:
-
-
-
-
-
-This lesson is a part of lab that teaches you to build quickstart. Continue on to next lesson: [_Create New Relic Alerts_](/instant-observability/build-a-quickstart/create-alerts).
-
-
\ No newline at end of file
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/deploy-your-application.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/deploy-your-application.mdx
new file mode 100644
index 000000000..a82001e47
--- /dev/null
+++ b/src/markdown-pages/instant-observability/build-a-quickstart/deploy-your-application.mdx
@@ -0,0 +1,49 @@
+---
+path: '/instant-observability/build-a-quickstart/deploy-your-application'
+title: 'Deploy your application'
+template: 'GuideTemplate'
+description: 'Spin up your demo services to follow along the lab'
+duration: '5 min'
+---
+
+
+
+This procedure is a part of lab that teaches you how to build a quickstart. If you haven't already, check out the [_Lab introduction_](/instant-observability/build-a-quickstart)
+
+
+
+Before you build a quickstart, you need to spin up demo services. The lab depends on two important services:
+- A python program that mimics the database and also provides functions for CRUD operations. It also makes use of `newrelic_telemetry_sdk` to send telemetry data to New Relic One.
+- A simulator service that generates dummy database traffic so you don't have to manually perform CRUD operations
+
+To spin up demo services, you first need to install [Docker](https://www.docker.com/) and also set **NEW_RELIC_INSERT_KEY** environment variable.
+
+> **Note:** **NEW_RELIC_INSERT_KEY** environment variable is your New Relic liscence key. [You can find your New Relic liscence key in your New Relic account](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/).
+
+## Spin up demo services
+
+Clone the lab repository from GitHub:
+>```bash
+> git clone https://github.com/mehreentahir16/FlashDB.git
+>```
+
+This repository contains the code for flashdb as well as the simulator for dummy database traffic. Navigate to the demo directory and execute the following commands to build and run docker image.
+
+> ```bash
+> docker build -t flashdb .
+> docker run flashdb
+>```
+
+Here, you build and run docker image that generates mock database traffic. You will observe this data in New Relic. Once the docker image is up and running, you see the following output in your terminal:
+
+
+
+>**Important:** Make sure you set NEW_RELIC_INSERT_KEY with your actual [license key](https://docs.newrelic.com/docs/accounts/accounts-billing/account-setup/new-relic-license-key/).
+
+The next step is to observe this data in New Relic.
+
+
+
+This procedure is a part of lab that teaches you how to build a quickstart. Continue on to next lesson: [_Create a dashboard_](/instant-observability/build-a-quickstart/create-a-dashboard).
+
+
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/index.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/index.mdx
index e655770c7..682718240 100644
--- a/src/markdown-pages/instant-observability/build-a-quickstart/index.mdx
+++ b/src/markdown-pages/instant-observability/build-a-quickstart/index.mdx
@@ -11,27 +11,32 @@ You’ve developed a new database called flashDB, the lightest and fastest datab
To achieve your goal, contribute a quickstart to New Relic I/O so other users can quickly monitor flashDB.
+## Why quickstarts?
+
+New Relic allow you to collect, monitor, and report data from different sources. While we offer a large variety of open-source integrations for telemetry tools, you can also use Telemetry SDKs to create your own telemetry data solutions. You can use New Relic One dashboards to view, explore, customize, understand, and correlate the data you collect using different user-friendly charts.
+You can also set alert policies to monitor key performance metrics and receive notification for anomalies.
+
+Often, you had to custom build these solutions to observe your applications in New Relic but now, we allow you to create and contribute **quickstarts** to help you and others quickly and easily observe it in New Relic.
New Relic One quickstarts provide immediate value for your specific use case. They include:
- Clear instructions for instrumenting your services
- Observbility building blocks like dashboards and alerts
-New Relic allow you to collect, monitor, and report data from different sources. While we offer a large variety of open-source integrations for telemetry tools, you can also use Telemetry SDKs to create your own telemetry data solutions. You can use New Relic One dashboards to view, explore, customize, understand, and correlate the data you collect using different user-friendly charts. You can also set alert policies to monitor key performance metrics and receive notification for anomalies.
-
-Until now, you had to custom build these solutions to observe your applications in New Relic but New Relic now allow you to create and contribute **quickstarts** to help you and others quickly and easily observe it in New Relic.
-
-Throughout this lab, you'll build a custom solution to observe flashdb in New Relic, package the solution as quickstart and contribute it to help others observe flashdb.
-
## Learning Objectives
-- Create New Relic dashboards to get insights from Database transactions
-- Create New Relic Alerts
-- Create quickstart
+Throughout this lab, you will .
+- Create a dashboard
+- Create alerts
+- Create a quickstart
- Package up your dashboards & alerts into quickstart
- Add quickstart description
-
+## Prerequisite
+
+- New Relic One account
+
+
-This lesson is a part of lab that teaches you to build quickstart. Before you proceed, make sure you have a New Relic Account. Continue on to first lesson: [_Send data to New Relic_](/instant-observability/build-a-quickstart/send-data-to-newrelic)
+This procedure is a part of lab that teaches you how to build a quickstart. Continue on to first lesson: [_Deploy your application_](/instant-observability/build-a-quickstart/deploy-your-application)
diff --git a/src/markdown-pages/instant-observability/build-a-quickstart/send-data-to-newrelic.mdx b/src/markdown-pages/instant-observability/build-a-quickstart/send-data-to-newrelic.mdx
deleted file mode 100644
index 02a5fb30e..000000000
--- a/src/markdown-pages/instant-observability/build-a-quickstart/send-data-to-newrelic.mdx
+++ /dev/null
@@ -1,49 +0,0 @@
----
-path: '/instant-observability/build-a-quickstart/send-data-to-newrelic'
-title: 'Send data to New Relic'
-template: 'GuideTemplate'
-description: 'Spin up your demo services and send data to New Relic'
-duration: '5 min'
----
-
-
-
-This lesson is a part of lab that teaches you to build quickstart. If you haven't already, checkout the introduction to [_build a quickstart_](/instant-observability/build-a-quickstart/index)
-
-
-
-Before you build a quickstart, you need to spin up demo services. The lab depends on two important services:
-- A python program that mimics the database and also provides functions for CRUD operations.
-- A simulator service that generates dummy database traffic and performs CRUD operations.
-To spin up demo services, you first need to install Docker and also set **NEW_RELIC_INSERT_KEY** environment variable.
-
-> **Note:** **NEW_RELIC_INSERT_KEY** environment variable is your New Relic liscence key. [You can find your New Relic liscence key in your New Relic account](https://docs.newrelic.com/docs/apis/intro-apis/new-relic-api-keys/).
-
-### Spin up demo services
-
-Clone the lab repository from GitHub:
->```bash
-> git clone https://github.com/mehreentahir16/FlashDB.git
->```
-
-This repository contains the code for flashdb as well as the simulator for dummy database traffic. Navigate to the demo directory and execute the following commands to build and run docker image.
-
-> ```bash
-> docker build -t flashdb .
-> docker run flashdb
->```
-
-The above application supply the mock database traffic that we will observe in New Relic with the help of New Relic telemetry sdk. Once the docker image is up and running, you see the following output in your terminal.
-
-
-
->**Important**
->Make sure you set NEW_RELIC_INSERT_KEY with your actual [license key](https://docs.newrelic.com/docs/accounts/accounts-billing/account-setup/new-relic-license-key/) to see the above output.
-
-The next step is to observe this data in New Relic.
-
-
-
-This lesson is a part of lab that teaches you to build quickstart. Continue on to next lesson: [_Create New Relic Dashboard_](/instant-observability/build-a-quickstart/create-dashboard).
-
-
diff --git a/src/markdown-pages/instant-observability/index.mdx b/src/markdown-pages/instant-observability/index.mdx
index a274f7608..80cb00a37 100644
--- a/src/markdown-pages/instant-observability/index.mdx
+++ b/src/markdown-pages/instant-observability/index.mdx
@@ -8,7 +8,8 @@ description: ''
New Relic have been providing different solutions for you to kick start your observability journey.
-But wouldn't it be cool if you wouldn't have to manually set up the observability building block. Instead you could just click, install and get value from your data?
+But wouldn't it be cool if you wouldn't have to manually set up the observability building block? Instead you could just click, install and get value from your data.
+
New Relic I/O equips you with integrations, dashboards, and other observability building blocks to get value from your data faster. We have a growing number of quickstarts that you can use for instant observability.
Didn't find what you're looking for? You're always welcome to create a quickstart and contribute it to help others instantly monitor and observe their services.