Select your cookie preferences

We use essential cookies and similar tools that are necessary to provide our site and services. We use performance cookies to collect anonymous statistics, so we can understand how customers use our site and make improvements. Essential cookies cannot be deactivated, but you can choose “Customize” or “Decline” to decline performance cookies.

If you agree, AWS and approved third parties will also use cookies to provide useful site features, remember your preferences, and display relevant content, including relevant advertising. To accept or decline all non-essential cookies, choose “Accept” or “Decline.” To make more detailed choices, choose “Customize.”

AWS Logo
Menu
Unlocking Live Streaming Analytics: Amazon IVS and Datadog Integration - Part 2

Unlocking Live Streaming Analytics: Amazon IVS and Datadog Integration - Part 2

Learn how to build a Datadog dashboard to monitor Amazon IVS playback metrics in real-time.

Tony Vu
Amazon Employee
Published Mar 3, 2025
This is the second article in a three part series.
Before proceeding, you should have already signed up for a Datadog account by this point if you have already read the first article in the series
In the first article in this series, we covered how we can use the Datadog Real User Monitoring (RUM) Browser SDK to capture playback data using state updates and events emitted by the Amazon IVS Player. In this article, we will cover how to create a playback quality dashboard using those data points. This will help us understand the quality of experience (QoE) for viewers in Datadog.
We can visualize the playback data in Datadog by creating dashboard widgets. Dashboard widgets will let us visualize our data over time, by count, against other data points and a whole host of other dimensions. We can create several of these dashboard widgets on a single page within Datadog to form an informative picture of the quality of experience for end stream viewers on the Amazon IVS Player.
Let’s create dashboard widgets that graph the metrics we previously calculated including the following:
  • Time to Video is the time it takes for the player to get the first frame of video and play it. The lower the time to video the better. This data point is crucial for engaging users and preventing them from abandoning the video.
  • Playback Latency Percentiles measures the distribution of delays between the time a video is sent from Amazon IVS servers and the time it is received and displayed by the Amazon IVS Player. This metric reports the 50th, 75th, 90th, and 95th percentile values of the playback latency distribution, providing insights into the higher end of the latency range experienced by viewers. Unlike an average, these percentile values are not skewed by outliers and better represent the typical and worst-case latency experienced by most viewers.
  • Unique Users by Rendition provides insights into the viewing experience of your live stream audience. It tracks the number of distinct users watching at each available video quality or "rendition" of the stream. This metric can help us understand the distribution of users across different bitrates and resolutions.
  • Errors Per Minute Per Channel is the number of errors that occur during video playback per minute of watched video by Amazon IVS channel. The IVS Player emits three possible error types. We will also create a widget on our dashboard to display the total number of errors emitted in a given time period and what those errors are.
  • Rebuffering Percentage measures the proportion of a viewer's total watch time that was spent waiting for video segments to download. This metric captures the average amount of time a viewer had to pause playback and wait for the video stream to buffer, relative to their total viewing time. A higher rebuffering percentage indicates more interruptions and a poorer viewing experience, as viewers had to spend a greater fraction of their session waiting for the video to resume playing.
  • Average playback time measures the average duration viewers spend watching the live stream, providing insights into audience engagement and content popularity.
  • Unique users is the number of distinct users that have accessed the live stream, providing insights into the overall audience size and reach of the content. To achieve this, recall that the data we sent to Datadog in the previous article was enriched with a custom generated unique user ID.
  • Unique User Count Per Top 10 Channels tracks the number of distinct users that have accessed the live stream on a specific Amazon IVS channel for the top 10 channels. This metric helps provide insights into the overall audience size and engagement for a particular channel.
  • Unique Users by Client Platform tracks the number of distinct users viewing the live stream, categorized by the operating system or device type (e.g. iOS, Android, web browser). This will help us understand the distribution of our audience across different client platforms, allowing us to prioritize features that would enhance the viewing experience for the most popular platforms.
  • Percent Time Buffering by Channel Watched measures the percentage of time viewers spend waiting for the video to buffer during playback, broken down by the specific channel they are watching. This metric helps identify any issues with video delivery or encoding that may be causing increased buffering for viewers on certain channels, allowing you to troubleshoot and optimize the experience.
  • Unique Users by Region will show a color coded map of unique users by region. Darker regions indicate more users while lighter regions indicate less users. Hovering over a region will show a popup of the number of users viewing from that region. The Datadog RUM Browser SDK collects the end viewer’s country by default among other default attributes.
Before we can create dashboard widgets, we need to create facets and measures to turn the attributes in our JSON payload that were sent to Datadog into data points that we can further leverage.
  • Facets are attributes we can use to filter and group our data. These are typically categorical or discrete values. The user_id attribute for example would be a facet. 
  • Measures are numerical values we can perform calculations on (sum, average, etc.). The live_latency_ms attribute would be a measure for example.
By creating these facets and measures, we can query against them in Datadog to create visualizations and dashboard widgets as will be seen in a moment.
With that said, navigate to RUM Explorer in your Datadog account by clicking Digital Experience -> Explorer from the submenu that pops under the Real User Monitoring heading.
Image not found
Navigating to RUM Explorer in your Datadog account
By default, we will be shown all sessions that occurred in the past day. A session represents the journey of a user on an application. It begins when a user starts browsing, and contains high-level information about the user (such as browser, device, and geolocation). It aggregates all events collected during the user journey, across multiple pages, and expires after 15 minutes of inactivity or 4 hours, whichever comes first. After 4 hours, a new session is automatically created. Learn more about the RUM data model here.
From there, click on a session row. This will bring up all the events and custom actions for that session.
 
Image not found
Datadog RUM Explorer
We will then be taken to a list of all actions that occurred on that session so far. Click on any of the custom user actions named PLAYBACK_SUMMARY
Image not found
Datadog RUM Explorer - Custom User Actions
This will bring up a detailed view of the custom user action. From here, click the Custom Attributes section, to reveal the JSON payload that we sent from our code. You may recognize this JSON payload from our previous article where we discussed how to send them to Datadog using the RUM Browser SDK. Hover over any of the attributes, click the gear icon and click Create facet. In this example, we select live_latency_ms.
Image not found
Seeing the JSON payload of a custom user action
A popup will appear where we can select whether the attribute should be a facet or measure. Live latency is a metric that will be used in calculations like finding averages, maximums and minimums so we will want it to be a measure. 
  1. In the popup window, select the Measure tab.
  2. Leave the checkbox on “Use path as display name”. Path is used when we build a query to graph the data which will cover later.
  3. Select Integer from the Type dropdown
  4. Select Millisecond (ms) from the Unity dropdown.
Click Add
Image not found
Creating a measure
After adding live_latency_ms as a facet, this takes us back to the custom attributes screen. While we are here, repeat this step for the following attributes creating them as either a measure of facet and selecting the appropriate type and unit as noted in the following table. The metrics we will derive from them by building queries in Datadog is also noted alongside each attribute.
AttributeMeasure/FacetTypeUnitDerived Metric
live_latency_msMeasureIntegerMillisecond (ms)Playback Latency Percentiles
buffering_time_msMeasureIntegerMillisecond (ms)Rebuffering Percentage Per Channel Watched
channel_watchedFacetStringN/AUnique Session Count Per Channel
client_platformFacetStringN/ASessions by client platform
error_countMeasureIntegerNoneAverage Error Count
playing_time_msMeasureIntegerMillisecond (ms)Average Playback Time
rendition_nameFacetStringN/AUnique Sessions by Rendition
session_idFacetStringN/AUnique Session Count Per Channel
startup_latency_msMeasureIntegerMillisecond (ms)Time to video
user_idFacetStringN/AUnique sessions
After creating these facets and measures from our custom action attributes, let’s get started with creating dashboard widgets in Datadog. 

Importing a dashboard

To create your dashboard with just a couple of clicks, you can optionally use this JSON file from Github. This JSON file is an exported copy of a dashboard that contains graphs for visualizing all of the metrics in this article.
Alternatively, if you would prefer to create each widget individually just to learn the process, move on to the next section on creating dashboard widgets individually. 
Follow this get started guide from Datadog to create a new dashboard. Once you have created a new dashboard, you will be taken to a blank canvas to add dashboard widgets. Click “Configure” in the upper right hand corner select “Import Dashboard JSON”. From there, specify the JSON file you downloaded and confirm.
Image not found
Importing a dashboard JSON

Once confirmed, you should then see a dashboard similar to the following. If you don’t, follow the steps in the next section to create the widgets individually.
With our dashboard now created, skip over the next section on the manual approach to creating the dashboard widgets and head to the section on how to interpret the data.

Creating dashboard widgets individually

Time to Video

The first widget we will create will be to graph the time to video metric. After logging in to your Datadog account, navigate to the Dashboards section in the main navigation bar and either create a new dashboard or open an existing one. We will name our dashboard “Amazon IVS Playback Analytics”
Image not found
Creating a new dashboard menu
Click on Add Widgets on your dashboard and select a Timeseries visualization 
Image not found
Adding a widget to your dashboard
Under the Graph your data heading, select RUM as the data source and add a filter on Actions
Image not found
Creating the query for time to video
Beneath the dropdown, specify @context.startup_latency_ms for the attribute of the query and select Avg of to calculate the average
Image not found
Configuring your time to video widget
Now that you have the hang of creating facets/measures from your attributes, building a query, and creating a dashboard widget, let’s make some more widgets.

Playback Latency Percentiles

This metrics uses the live_latency_ms attribute to calculate the playback latency percentiles. 
Add a new widget and select the “Query Value” graph/visualization in your dashboard. 
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter @context.live_latency_ms:* as action to filter on
  • The calculation method should default to “Measure of”
  • Enter “context.live_latency_ms” as the measure
  • Select a distribution of all points
Image not found
Creating the query for playback latency percentiles
Beneath the query set your desired time preference. In this example, we set it to the past 1 hour. Finally, give your widget a title of “Playback Latency Percentiles”
Image not found
Widget for playback latency percentiles

Unique Users by Rendition

Add another widget and select the Treemap graph. Feel free to use the pie graph if you prefer.
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id as the measure and select the “Count unique of” operation from the dropdown and group by “context.rendition_name”. The group by field shows “Rendition Name” because in this example 
  • There are only five possible renditions (160p, 360p, 480p, 360p,and 1080p)
Image not found
Creating a query for unique users by rendition
Beneath the query set your desired time preference. The dashboard will then similar to the following.
Image not found
Widget for unique users by rendition

Errors Per Minute Per Channel

Add a widget and select the top list from the list of graphs.
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.error_count as the measure and select the “Sum of” operation from the dropdown
  • Enter context.channel_watched in the group by field Limit it to the top 1,000 channels being watched by selecting “top” and then “1000” in the operation field. 
Image not found
Creating the query for errors per minute per channel
Beneath the query set your desired time preference. In this example, we set it to one hour.
Title your graph Errors per Channel Watched. Your widget will look like this:
Image not found
Widget for errors per minute per channel

Error List

Add another widget and select the “List” graph. This will display the error code, the type of error, and a message describing the error which we sent to Datadog in the last article. In this widget, you will just need to give it a name of “IVS Player Errors” and set a time preference of your choice. Feel free to adjust the sorting preference if you’d like.
Image not found
Creating the query for error list
We have added some mock error data to give you an idea what this widget would display. In practice, only one of the error types emitted by the IVS Player would be displayed, if any errors occurred.
 
Image not found
Widget for error list

Rebuffering Percentage

Add another widget and select the Timeseries graph. The rebuffering percentage is calculated with the following formula
Total buffering time / Total playback time * 100
We will need to create two queries. One for the total buffering time and one for the total playback time. Then, we apply a formula to the queries as you will see in a moment to do the calculation to arrive at the rebuffering percentage
Create a query for the total buffering time:
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.buffering_time_ms as the measure
  • Select “Sum of” as the calculation next to the measure
Create a query for the total playback time:
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.playing_time_ms as the measure
  • Select “Sum of” as the calculation next to the measure
Add a formula
  • Click add formula and enter the following expression
    • a / b * 100
Click on the blue shaded “a” and “b” letters next to each to hide them from being displayed. We only want the graph for the rebuffering percentage to be displayed.
Image not found
Creating the query for rebuffering percentage
Beneath the query set your desired time preference. 
Title your graph Rebuffering Percentage.
Image not found
Rebuffering percentage widget

Average Playback Time

Add another widget and select the query value graph.
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.playing_time_ms as the measure and select the “Avg of” operation from the dropdown
  • Leave everything else as default
Image not found
Creating the query for average playback time
Beneath the query set your desired time preference. The widget will then look as follows.
Image not found
Widget for average playback time

Unique users

Let’s create the unique users widget next. This KPI uses the user_id attribute to calculate how many unique users we had over time.. In the previous article, we generated a unique ID for our live streaming application using a randomly generated UUID. In practice, you could instead use a unique ID you assign to your end users that you store in your database. When they log in to your live streaming application for example, you could  have some unique identifier for them that you could send to Datadog instead of the UUID we are using in this example
Add a new times series widget in your dashboard and build the query as follows
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter @context.user_id:* as the attribute to filter on
  • Enter context.user_id as the measure 
  • Group by “Everything”
The query should then look as follows.
Image not found
Creating the query for unique users
Right underneath the query editor, select “Bars” as the display type.
Image not found
Unique users display type
Set your desired time preference,
Image not found
Setting your desired time preference
Give your graph a title of "Unique Users" and click Save. After saving it should look similar to the following.
Image not found
Widget for unique users

Unique User Count Per Top 10 Channels

With the channel_watched attribute and the session count, let’s build this widget.
Click Add Widgets from the dashboard and select Top List. This will create a visualization of a horizontal bar chart with channel names on the y-axis and user count on the x-axis
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id as the measure
  • Enter context.channel_watched in the group by field
  • Limit it to the top 10 channels watched by selecting “top” and then “10” in the operation field
Image not found
Creating the query for unique user count per top ten channels
Beneath the query set your desired time preference
Title your graph “Unique User Count Per Top 10 Channels” and click save. The widget should look like this. The combination of letters and numbers you see in each bar are the unique IDs associated with each channel. That unique ID comes from the last few characters that come after the forward slash in a channel ARN (e.g. arn:aws:ivs:us-west-2:123456789012:channel/abcdABCDefgh)
Image not found
Widget for unique user count per top ten channels

Unique Users by Client Platform

Add another widget and select the Pie Chart graph. 
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id as the measure
  • Enter context.cleint_platform in the group by field
  • Limit it to the top 5 platforms by selecting “top” and then “5” in the operation field. We only have three client platforms, including web, iOS, and Android so this will capture all of them.
Image not found
Creating the query for unique users by client platform
Beneath the query set your desired time preference
Title your graph Unique Users by Client Platform and click Save. Your widget will look like this:
Image not found
Widget for unique users by client platform

Rebuffering Percentage Per Channel Watched

Add another widget and select the Top List graph. This widget is useful to let us know which channels are buffering the most, if at all, as a percentage of the amount of time it is viewed.
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.buffering_time ms as the measure and select the “Sum of” operation from the dropdown
  • Enter context.channel_watched as the group by field limiting to the top 1,000 channels
Click Add Query to add a second query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.playing_time_ms as the measure and select the “Sum of” operation from the dropdown
  • Enter context.channel_watched as the group by field limiting to the top 1,000 channels
Beneath the second query, click Add formula and enter:
(a/1000) / (b/1000)
This formula takes the first query, the total buffer time (dividing by 1,000 to convert it to seconds) and divides by the total playing (dividing by 1,000 to convert it to seconds) to arrive at the percent time buffering by channel watched metric
Image not found
Query for percent time buffering by channel watched
Finally, click Unit Override beneath the query to display this as a percentage
Image not found
Selecting percentage as the unit
The widget will then look like the following.
Image not found
Widget for Rebuffering Percentage Per Channel Watched

Unique Users by Region

This graph will show a color coded map of regions. Regions with higher numbers of unique sessions will be darker. 
Add another widget and select Geomap as the graph type
Create a query
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id ms as the measure and select “Count unique of” from the dropdown next to it if it isn’t selected by default
  • Leave the group by field as “Country ISO Code” as is. You can choose to leave it as top 10 or another value of your choice
Image not found
Query for unique users by region
Beneath the query set your desired time preference and your graph should look similar to the following.
Image not found
Widget for unique users by region
With all these graphs and widgets in place, let’s discuss how to interpret the data and what to do about it to improve the viewing experience for our end users.

Average playing time per channel

Another widget we can add is to take a look at the average playtime per channel. A stacked barchart can help quickly identify the longer viewed channels over others. This can be a helpful indicator for doubling down on content that is proving to work well.
Image not found
Average playing time by channel watched

Hours played by country

Another widget we can add is the hours of playing time by country. This geographical distribution widget provides valuable insights into where your content is being consumed most heavily and helps identify regional viewing patterns. By visualizing viewing hours across different countries, you can make data-driven decisions about content localization and regional marketing strategies.
Image not found
Hours played by country

Creating correlation widgets

Correlation widgets help us understand the relationship between two metrics. In this section, we will go over a couple of useful correlation widgets.
Buffering to User Correlation 
The first widget is the buffering time to user correlation widget. This widget helps visualize the relationship between video buffering time and viewer engagement by plotting these two metrics against each other. By analyzing this correlation, we can identify if increased buffering times are leading to viewer drop-off and determine the threshold at which buffering starts to significantly impact the user experience.
Image not found
Buffering to user correlation
To create this widget, select a time series visualization**.**
Next, create a query as follows
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.buffering_time_ms as the measure and select the “Average” operation
Create a second query as follows:
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id as the measure making sure to select the “Unique” operation to count only unique user_ids
Image not found
Buffering to user correlation queries

Playing Time By to Time to Video Correlation

Another widget that is useful to have is the playing time to time to video correlation widget. This widget displays the correlation between how long users spend watching content and how quickly the video loads for them initially. This insight is valuable for understanding if slow video start times are affecting overall watch duration and helps identify optimal loading time targets that maximize viewer engagement
Image not found
Playing time by time to video correlation
To create this widget, select a time series visualization**.**
Next, create a query as follows
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.playing_time_ms as the measure and select the “Average” operation
  • Group by “Country ISO Code” limiting it to the top 10
  • For the display type, select “Bars”
Create a second query as follows:
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.startup_latency as the measure making sure to select the “Average” operation
  • For the display type, select “Lines”
Image not found
Playing time by time to video correlation queries

Time to Video and Unique Users

A final graph we can create to explore how quality of experience can affect engagement is by creating a graph that shows time to video and unique users. If a live stream takes too long to load, users will naturally drop off out of frustration. It’s informative to see how the number of unique users may drop in the case a time to video is abnormally high. Let’s create a widget that shows the relationship between these two metrics.
Image not found
Time to Video and Unique Users
To create this widget, select a time series visualization**.**
Next, create a query as follows
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.startup_latency_ms as the measure and select the “Average” operation
Create a second query as follows:
  • Select RUM as the metric category to filter from the dropdown menu
  • Select Actions from the next dropdown to filter on custom actions
  • Enter context.user_id as the measure making sure to select the “Count unique of” operation
Image not found
Time to video and unique users correlation

Leveraging the KPIs in your dashboard

Using the data for proactive and reactive monitoring is often done through pattern analysis and correlation. Now that the RUM data is viewable in various widgets in our Datadog platform, we can better understand the playback experience for all users. Our tendency is often to evaluate data at a high level for any trends or changes that have occurred, then to slowly drill into various metrics as more patterns emerge. Due to this model of thinking, this section is split into three parts; High, Medium, and Low Level metrics.
High Level KPIs: These KPI provide an overview of all collected data points without filtering. Often these KPIs will be used for proactive monitoring to alert when there is a widespread occurrence happening. We often look to set either threshold or standard deviation alarms on these KPI to be alerted when a desired boundary is passed. An example of alerting on these data points would be to look at the  standard deviation for total count of errors, in which if the count of errors exceeds the threshold an alert would trigger to warn appropriate individuals. 
Examples of High Level KPIs:
  • Unique Users
  • Time to Video
  • Average playback time
  • Playback Latency Percentiles
Medium Level KPIs: More often than not, KPI at this level show a wide arrange of data filtered or grouped by a certain criteria. These KPI are useful to evaluate if a certain subset of users are experiencing a behavior.  Medium level KPI are often not going to provide a root cause when troubleshooting playback issues, but can often be used as a guide to understand who may be impacted. A common example of this would be if the Total Count of Errors alert is triggered, an Errors per Channel widget may indicate if a single channel is responsible for the spike or if all channels are experiencing the same behavior.
Examples of Medium Level KPIs:
  • Unique Sessions by Region
  • Unique Sessions By Client Platform
  • Unique Users by Rendition
Low Level KPI: We classify these KPI as anything that is filtered/grouped by two or more criteria or the raw RUM events themself. KPI at this level are often used in an attempt to correlate various pieces of data to form a root cause analysis. For example, if a specific error type increases on a specific device OS version, then the errors may be a result of the specific OS version integration. Additionally, the raw RUM events can be used to perform a more in-depth analysis of specific play sessions. In retroactive analysis situations, the raw RUM events can be used to look at the specific playback session(s). 
Example of Low Level KPIs:
  • Unique User Count Per Top 10 Channel 
  • Rebuffering Percentage
  • Percent Time Buffering by Channel Watched
  • Errors per Minute per Channel
KPIs can also provide valuable business insights into the engagement and demographics of your live stream viewership. The "Unique Users" and "Unique Users per Top 10 Channel" KPIs give you a high-level understanding of the size of your viewership and reach of your content. By analyzing trends in unique user counts over time, you can gauge the popularity and growth of your live streams.
The "Unique Users by Client Platform" KPI is insightful for understanding the device and operating system preferences of your viewers. This data can inform your content optimization and distribution strategies, allowing you to prioritize features and experiences that cater to the most popular platforms used by your viewers.
Combining these demographic insights with metrics like "Average Playback Time" can paint a comprehensive picture of viewer engagement highlighting which content resonates best with your viewers.

Conclusion

In this article, we have explored how to leverage the integration between Amazon IVS and Datadog to gain valuable insights into the playback quality of your live streaming content. By capturing and visualizing key playback metrics such as time to video, average playback latency, unique viewers by rendition, and buffer time, you can proactively identify and address issues that may impact the viewing experience.
The dashboard widgets we created in Datadog provide a comprehensive view of the various factors that contribute to overall playback quality. By monitoring these KPIs over time, you can make informed decisions to optimize your live streaming infrastructure, content encoding, and delivery strategies. This will help ensure your viewers enjoys a seamless and engaging viewing experience, ultimately driving increased viewer satisfaction and retention.
As you continue to scale your live streaming operations, the insights gained from this Amazon IVS and Datadog integration will be invaluable in maintaining high-quality and reliable viewing experiences for your viewers. In the next and final article in this series, we will explore how to leverage Amazon IVS stream health metrics to further enhance your live streaming monitoring and troubleshooting capabilities.

About the authors

Tony Vu is a Senior Partner Engineer at Twitch. He specializes in assessing partner technology for integration with Amazon Interactive Video Service (IVS), aiming to develop and deliver comprehensive joint solutions to our IVS customers. Tony enjoys writing and sharing content on LinkedIn.
Maël Lilensten is a Senior Product Manager at Datadog, in charge of the RUM, Tracing, and Logs SDK for mobile devices and smart TVs. He aims at building products for companies to monitor the performance of their frontend applications. As part of his scope, he’s working closely with streaming and broadcasting companies to break data silos and consolidate observability and video QoS on a single Datadog instance.
Riley Beadles is a Senior Customer Success Engineer at Amazon IVS. He combines his technical expertise with a customer centric mindset to ensure customers of IVS achieve their desired implementation with IVS. Riley enjoys maximizing value, while reducing effort.
Jason Mimick is a Senior Partner Solutions Architect at AWS supporting Datadog working closely with the product, engineering, marketing, and sales teams daily. He’s spent the last 25+ years in tech, working for companies like Microsoft, Intersystems, and MongoDB before finding a home at AWS, Jason now focuses on enabling product development and sales success for partners and customers across all industries
Sumir Kumar is a Solutions Architect at AWS, specializing in designing and implementing cloud-based solutions that solve complex business challenges. He collaborates closely with key AWS customers, helping them leverage the cloud for scalability, efficiency, and innovation**.** Passionate about data analytics and machine learning, he enables organizations to align data-driven insights with business goals, empowering them to make informed decisions and drive success.
 

Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.

Comments

Log in to comment