diff --git a/daprdocs/content/en/developing-applications/building-blocks/bindings/bindings-overview.md b/daprdocs/content/en/developing-applications/building-blocks/bindings/bindings-overview.md
index a2a229425..ccc1007d2 100644
--- a/daprdocs/content/en/developing-applications/building-blocks/bindings/bindings-overview.md
+++ b/daprdocs/content/en/developing-applications/building-blocks/bindings/bindings-overview.md
@@ -6,51 +6,67 @@ weight: 100
description: Overview of the bindings API building block
---
-Using Dapr's bindings API, you can both trigger your app with events coming in from external systems and interface with external systems. In addition, the Dapr binding API enables you to:
+Using Dapr's bindings API, you can trigger your app with events coming in from external systems and interface with external systems. With the bindings API, you can:
-- Remove the complexities of connecting to and polling from messaging systems, such as queues and message buses
-- Focus on business logic, instead of the implementation details of how to interact with a system
-- Keep your code free from SDKs or libraries
-- Handle retries and failure recovery
-- Switch between bindings at run time
-- Build portable applications with environment-specific bindings set up and no code changes required
+- Avoid the complexities of connecting to and polling from messaging systems, such as queues and message buses.
+- Focus on business logic, instead of the implementation details of interacting with a system.
+- Keep your code free from SDKs or libraries.
+- Handle retries and failure recovery.
+- Switch between bindings at runtime.
+- Build portable applications with environment-specific bindings set-up and no required code changes.
For example, with bindings, your microservice can respond to incoming Twilio/SMS messages without:
- Adding or configuring a third-party Twilio SDK
-- Worrying about polling from Twilio (or using websockets, etc.)
+- Worrying about polling from Twilio (or using WebSockets, etc.)
{{% alert title="Note" color="primary" %}}
- Bindings are developed independently of Dapr runtime. You can [view and contribute to the bindings](https://github.com/dapr/components-contrib/tree/master/bindings).
-
+Bindings are developed independently of Dapr runtime. You can [view and contribute to the bindings](https://github.com/dapr/components-contrib/tree/master/bindings).
{{% /alert %}}
## Input bindings
-With input bindings, you can trigger your application when an event from an external resource has occurred. An optional payload and metadata may be sent with the request.
+With input bindings, you can trigger your application when an event from an external resource occurs. An optional payload and metadata may be sent with the request.
-In order to receive events from an input binding:
+To receive events from an input binding:
-1. Define the component YAML that describes the type of binding and its metadata (connection info, etc.).
-2. Listen on an HTTP endpoint for the incoming event, or use the gRPC proto library to get incoming events.
+1. Define the component YAML that describes the binding type and its metadata (connection info, etc.).
+1. Listen for the incoming event using:
+ - An HTTP endpoint
+ - The gRPC proto library to get incoming events.
{{% alert title="Note" color="primary" %}}
- On startup, Dapr sends [an OPTIONS request]({{< ref "bindings_api.md#invoking-service-code-through-input-bindings" >}}) for all defined input bindings to the application and expects a status code 2xx or 405 if this application wants to subscribe to the binding.
+ On startup, Dapr sends [an OPTIONS request]({{< ref "bindings_api.md#invoking-service-code-through-input-bindings" >}}) for all defined input bindings to the application. If the application wants to subscribe to the binding, Dapr expects a status code of 2xx or 405.
{{% /alert %}}
-Read the [Create an event-driven app using input bindings]({{< ref howto-triggers.md >}}) page to get started with input bindings.
+Read the [Create an event-driven app using input bindings guide]({{< ref howto-triggers.md >}}) to get started with input bindings.
## Output bindings
With output bindings, you can invoke external resources. An optional payload and metadata can be sent with the invocation request.
-In order to invoke an output binding:
+To invoke an output binding:
-1. Define the component YAML that describes the type of binding and its metadata (connection info, etc.).
+1. Define the component YAML that describes the binding type and its metadata (connection info, etc.).
2. Use the HTTP endpoint or gRPC method to invoke the binding with an optional payload.
-Read the [Use output bindings to interface with external resources]({{< ref howto-bindings.md >}}) page to get started with output bindings.
+Read the [Use output bindings to interface with external resources guide]({{< ref howto-bindings.md >}}) to get started with output bindings.
+
+## Try out bindings
+
+### Quickstarts and tutorials
+
+Want to put the Dapr bindings API to the test? Walk through the following quickstart and tutorials to see bindings in action:
+
+| Quickstart/tutorial | Description |
+| ------------------- | ----------- |
+| [Bindings quickstart]({{< ref bindings-quickstart.md >}}) | Work with external systems using input bindings to respond to events and output bindings to call operations. |
+| [Bindings tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/bindings) | Demonstrates how to use Dapr to create input and output bindings to other components. Uses bindings to Kafka. |
+
+### Start using bindings directly in your app
+
+Want to skip the quickstarts? Not a problem. You can try out the bindings building block directly in your application to invoke output bindings and trigger input bindings. After [Dapr is installed]({{< ref "getting-started/_index.md" >}}), you can begin using the bindings API starting with [the input bindings how-to guide]({{< ref howto-triggers.md >}}).
## Next Steps
@@ -58,4 +74,4 @@ Read the [Use output bindings to interface with external resources]({{< ref howt
- [How-To: Trigger a service from different resources with input bindings]({{< ref howto-triggers.md >}})
- [How-To: Use output bindings to interface with external resources]({{< ref howto-bindings.md >}})
- Try out the [bindings tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/bindings/README.md) to experiment with binding to a Kafka queue.
-- Read the [bindings API specification]({{< ref bindings_api.md >}})
+- Read the [bindings API specification]({{< ref bindings_api.md >}})
\ No newline at end of file
diff --git a/daprdocs/content/en/developing-applications/building-blocks/bindings/howto-bindings.md b/daprdocs/content/en/developing-applications/building-blocks/bindings/howto-bindings.md
index e0829287c..cec770ff3 100644
--- a/daprdocs/content/en/developing-applications/building-blocks/bindings/howto-bindings.md
+++ b/daprdocs/content/en/developing-applications/building-blocks/bindings/howto-bindings.md
@@ -6,23 +6,31 @@ description: "Invoke external systems with output bindings"
weight: 300
---
-With output bindings, you can invoke external resources without depending on special SDK or libraries. An output binding represents a resource that Dapr uses to invoke and send messages to. For a complete sample showing output bindings, [walk through the tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/bindings).
+With output bindings, you can invoke external resources. An optional payload and metadata can be sent with the invocation request.
-
+
-This guide uses a Kafka binding as an example. You can find your preferred binding spec from [the list of bindings components]({{< ref setup-bindings >}}).
+This guide uses a Kafka binding as an example. You can find your preferred binding spec from [the list of bindings components]({{< ref setup-bindings >}}). In this guide:
+
+1. The example invokes the `/binding` endpoint with `checkout`, the name of the binding to invoke.
+1. The payload goes inside the mandatory `data` field, and can be any JSON serializable value.
+1. The `operation` field tells the binding what action it needs to take. For example, [the Kafka binding supports the `create` operation]({{< ref "kafka.md#binding-support" >}}).
+ - You can check [which operations (specific to each component) are supported for every output binding]({{< ref supported-bindings >}}).
+
+{{% alert title="Note" color="primary" %}}
+ If you haven't already, [try out the bindings quickstart]({{< ref bindings-quickstart.md >}}) for a quick walk-through on how to use the bindings API.
+
+{{% /alert %}}
## Create a binding
-Create a new binding component with the name of `checkout`.
+Create a `binding.yaml` file and save to a `components` sub-folder in your application directory.
-Within the `metadata` section, configure Kafka-related properties, such as:
+Create a new binding component named `checkout`. Within the `metadata` section, configure the following Kafka-related properties:
- The topic to which you'll publish the message
- The broker
-Create the following `binding.yaml` file and save to a `components` sub-folder in your application directory.
-
{{< tabs "Self-Hosted (CLI)" Kubernetes >}}
{{% codetab %}}
@@ -89,7 +97,7 @@ spec:
## Send an event (output binding)
-Below are code examples that leverage Dapr SDKs to interact with an output binding.
+The code examples below leverage Dapr SDKs to invoke the output bindings endpoint on a running Dapr instance.
{{< tabs Dotnet Java Python Go JavaScript>}}
@@ -277,22 +285,12 @@ function sleep(ms) {
{{< /tabs >}}
-Invoke the output bindings endpoint on a running Dapr instance.
-
You can also invoke the output bindings endpoint using HTTP:
```bash
curl -X POST -H 'Content-Type: application/json' http://localhost:3601/v1.0/bindings/checkout -d '{ "data": 100, "operation": "create" }'
```
-As seen above:
-
-1. The example invoked the `/binding` endpoint with `checkout`, the name of the binding to invoke.
-1. The payload goes inside the mandatory `data` field, and can be any JSON serializable value.
-1. The `operation` field tells the binding what action it needs to take. For example, [the Kafka binding supports the `create` operation]({{< ref "kafka.md#binding-support" >}}).
-
-You can check [which operations (specific to each component) are supported for every output binding]({{< ref supported-bindings >}}).
-
Watch this [video](https://www.youtube.com/watch?v=ysklxm81MTs&feature=youtu.be&t=1960) on how to use bi-directional output bindings.