#DataScalability

[briskwinits]

Database services are essential for any business that wants to store and manage its data effectively. We offer a wide range of database services to meet your specific needs, including database design, development, implementation, and support.

For more, visit: https://briskwinit.com/

[simple-logic]

Simplify NoSQL Database Management with Simple Logic 🗂️

Database Optimization⚡ Enhance the performance of MongoDB, Cassandra, and more

Data Scalability📈 Seamlessly scale to meet evolving demands

Backup & Recovery🔄 Secure your data with robust recovery options

24/7 Monitoring👀 Proactively identify and resolve database issues

Partner with Simple Logic for NoSQL Success 📧 Email: marketing@simplelogic.in 📞 Phone: +91 86556 16540

[jcmarchi]

Vasu Murthy, SVP and Chief Product Officer at Cohesity – Interview Series

New Post has been published on https://thedigitalinsider.com/vasu-murthy-svp-and-chief-product-officer-at-cohesity-interview-series/

Vasu Murthy, SVP and Chief Product Officer at Cohesity – Interview Series

Vasu Murthy is the SVP and Chief Product Officer at Cohesity, bringing over 25 years of enterprise software experience across data security, protection, and analytics. Prior to joining Cohesity, he held leadership roles at Rubrik, Oracle, and DataScaler, contributing to product growth and large-scale innovation.

Cohesity is the leader in AI-powered data security. Over 13,600 enterprise customers, including over 85 of the Fortune 100 and nearly 70% of the Global 500, rely on Cohesity to strengthen their resilience while providing Gen AI insights into their vast amounts of data. Formed from the combination of Cohesity with Veritas’ enterprise data protection business, the company’s solutions secure and protect data on-premises, in the cloud, and at the edge

You co-founded DataScaler, which was later acquired by Oracle. What lessons from your startup journey still guide your decision-making today?

Finding product market fit was our primary goal in the early stages at DataScaler. While we had many enthusiastic prospects for the product, enthusiasm did not always translate into a repeatable use case. The power is in asking the right questions. If all you ask is “What would you like?” or “Would you use this?”, people are often in the mindset of their ideal self, thinking about what they’d like to use or need in a perfect world, and it doesn’t always reflect what they need in their day-to-day reality.

If something is truly important to a customer, chances are they’re already doing it, likely not efficiently or enjoyably. They might be using a clunky product they don’t like, spending more money, or handling things manually and wishing they could get time back. The better questions to ask are: “What are you doing today that’s hard?” or “What would save you time or money?” When you start with the right questions, you uncover problems that are worth solving.

What drove your decision to move from a giant like Oracle into the fast-paced world of Rubrik and later Cohesity?

I think of my career as a series of missions. Reid Hoffman calls it “Transformational Tours” in his book, The Alliance. A typical mission for me lasts 2-3 years and ends with a specific outcome for the business, and then it’s time to work on something new. While I was at Oracle, I was given a project that became a three-year mission. Once completed, I asked, “What’s next?” and they said, “Something even bigger!”, so I assembled a team and began the next mission. That cycle repeated itself, and each time, the challenge grew.

At the end of my third mission at Oracle, I was craving something at the pace and perspective of a high-growth startup, which led me to Rubrik. After Rubrik’s IPO, I took some time off to think about what was next, and set out to join a team with an exciting challenge, which is how I came into my role at Cohesity.

What unique opportunities did you see at Cohesity that convinced you this was the right next chapter in your career?

Cohesity’s recent acquisition of Veritas’ enterprise data protection business is exactly the kind of project that I was looking for. The opportunity to play a key role in integrating the companies while charting a smooth transition for the large customer base is both challenging and rewarding. I’m privileged to contribute to shaping the culture, influence product development, and making this transformation successful for our employees and customers.

You joined Cohesity just before the Veritas acquisition. What was your first focus as CPO coming into this high-stakes moment?

For a CPO, understanding the mindset of customers and employees is just as important as understanding the product and the market. Our customers are global, and our people have been through different experiences. Getting a message across that resonates with all of them is crucial.

Beyond communication, my top priority is to increase the pace of innovation we deliver to our customers, and earn the right to continue to expand our footprint. There’s an opportunity to guide our customers to the future of data security and AI.

Cohesity has a strong AI-first vision. How are you thinking about AI as a product layer versus an embedded capability?

Cohesity leverages AI in all aspects — from detecting anomalies and classifying data to helping customers accelerate and strengthen cyber recovery. With hundreds of exabytes of data under our management, there’s a big opportunity to unlock AI-driven insights from all across the platform.

Cohesity was built from the ground up as a platform, which makes us unique in this market. Designed to support multiple applications from the start, Cohesity has a strong position in many use cases on data. Customers pay us to bring their data into our platform, which gives us a powerful opportunity to build and deliver applications on top of it.

How do tools like Cohesity Gaia redefine how enterprises interact with their data?

80% of enterprise data is unstructured and traditionally difficult to manage or analyze, and generative AI has provided opportunities to extract insights and value from it.

To leverage unstructured data, it needs to be gathered from a variety of sources, cleaned to ensure it does not have unwanted private, sensitive data, and provided in immutable views for RAG and other ways to derive insights. Even when data is available, it takes significant effort to build the AI infrastructure to deliver insights.

Cohesity Data Platform already gathers and secures data from all locations, and we also built Gaia, a full-fledged RAG application to derive insights from data. This allows users to interact with their data using natural language, generate valuable insights, and seamlessly unify company knowledge across various data types and locations.

What are the most exciting customer use cases you’ve seen so far for AI-powered conversational search and threat detection?

There’s so much data worldwide that many customers don’t even know what they have. Being able to unlock that and leverage for more information is very powerful for business. One aspect I find particularly interesting is the concept of data sovereignty. In today’s geopolitical climate, countries are increasingly concerned about whether data stored within their borders gives their citizens control. A key question that’s been coming up, especially with AI, is whether these AI services are hosted in the cloud. People are worried about whether they can query their data and who can access it.

Cohesity stands out to me in situations like this because it offers a solution through enabling on-premises data management. With Cohesity, customers don’t need to move their data to the cloud or worry about entities managing it in other countries. The growing concern around data sovereignty and “data gravity” means that more organizations want to keep things on-premises, and we can provide exactly that solution, working with our hardware partners and NVIDIA.

How do you ensure alignment across product, design, and documentation—especially when launching AI-first experiences?

Success of a company depends on all functions operating in harmony – not just product, design and documentation. Ideas can come from anywhere and when people feel heard, they feel a sense of ownership that drives the best outcome.

It is important to include all stakeholders early on, listen to them, and ensure they all have a say in the outcome. Product teams need to be good idea curators and help prioritize, designers need to keep customer experience at the forefront, and documentation teams need to focus on minimizing the time spent in documents by working with designers, providing in-line guidance as necessary. AI has a huge role to play in developing and delivering this experience.

What frameworks help you prioritize between customer pain points, visionary innovation, and technical debt?

It pays to start from first principles when determining priorities and shaping our approach. Frameworks can be helpful for communicating this, especially when they’re well-aligned. That said, I believe most products can generally be categorized into three types.

First, there are new products with few customers, where innovation should be the main focus. Then, you have the core products that are the bread and butter. Innovation is important here, but addressing customer pain points should also be a priority. Lastly, you have long-term, mature products that are well-established. In this case, the focus shifts more to managing customer pain points and technical debt.

What are your goals for Cohesity’s product portfolio over the next 12 to 18 months?

We’ve found so much that fits between Cohesity and Vertias’ enterprise data protection business since the acquisition. It’s the fastest I’ve ever seen two product suites come together. In Veritas’ most recent iteration, they converted their backup solution into a set of microservices within containers. Conversely, Cohesity started as a container-based application platform built on a flexible data layer. Because of this, it’s possible to drop Veritas services onto the Cohesity platform, and things work seamlessly because the data platform works with both.

Over the next 12 to 18 months, we want our workload support, data security and AI services to be common for all our customers. We’re also building a seamless upgrade path for all customers to get to a future proof platform for their data.

A product that I’m particularly excited about is RecoveryAgent, Cohesity’s new Agentic AI cyber orchestration solution. The first new offering from the joint development efforts of Cohesity and Veritas, it provides customers with easy cyber recovery preparation, testing, and automation to strengthen security postures, increase confidence in incident response, and prove compliance.

What advice would you give to other CPOs navigating this AI-dominated landscape?

People are feeling the immediate need to incorporate AI into applications. Often this is in the form of making workflows easier and assisting people in being more productive. While this is useful for customers, it is unlikely that customers pay significantly more for this incremental productivity improvement.

True AI differentiation requires re-thinking the workflows completely driven by AI. The technology is evolving rapidly and will become more valuable as the AI accuracy improves. AI can be great for natural language interactions and some planning, the core logic still requires a lot of validation, monitoring, error-correction, and scaffolding. While AI driven apps will improve over time, there is money to be made in AI and data infrastructure.

Thank you for the great interview, readers who wish to learn more should visit Cohesity. 

[ramanidevi16]

Run K-means Cluster Analysis

To run a k-means cluster analysis, you'll use a programming language like Python with appropriate libraries. Here’s a guide to help you complete this assignment:### Step 1: Prepare Your DataEnsure your data is ready for analysis, including the clustering variables.### Step 2: Import Necessary LibrariesFor this example, I’ll use Python and the `scikit-learn` library.#### Python```pythonimport pandas as pdimport numpy as npfrom sklearn.preprocessing import StandardScalerfrom sklearn.cluster import KMeansimport matplotlib.pyplot as pltimport seaborn as sns```### Step 3: Load and Standardize Your Data```python# Load your datasetdata = pd.read_csv('your_dataset.csv')# Select the clustering variablesX = data[['var1', 'var2', 'var3', ...]] # replace with your actual variable names# Standardize the datascaler = StandardScaler()X_scaled = scaler.fit_transform(X)```### Step 4: Determine the Optimal Number of ClustersUse the Elbow method to find the optimal number of clusters.```python# Determine the optimal number of clusters using the Elbow methodinertia = []K = range(1, 11)for k in K: kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X_scaled) inertia.append(kmeans.inertia_)# Plot the Elbow curveplt.figure(figsize=(10,6))plt.plot(K, inertia, 'bo-')plt.xlabel('Number of clusters')plt.ylabel('Inertia')plt.title('Elbow Method For Optimal k')plt.show()```### Step 5: Train the k-means ModelChoose the number of clusters based on the Elbow plot and train the k-means model.```python# Train the k-means model with the optimal number of clustersoptimal_clusters = 3 # replace with the optimal number you identifiedkmeans = KMeans(n_clusters=optimal_clusters, random_state=42)kmeans.fit(X_scaled)# Get the cluster labelslabels = kmeans.labels_data['Cluster'] = labels```### Step 6: Visualize the ClustersUse a pairplot or other visualizations to see the clustering results.```python# Visualize the clusterssns.pairplot(data, hue='Cluster', vars=['var1', 'var2', 'var3', ...]) # replace with your actual variable namesplt.show()```### InterpretationAfter running the above code, you'll have the output from your model, including the optimal number of clusters, the cluster labels for each observation, and a visualization of the clusters. Here’s an example of how you might interpret the results:- **Optimal Number of Clusters**: The Elbow method helps determine the number of clusters where the inertia begins to plateau, indicating an optimal number of clusters.- **Cluster Labels**: Each observation in the dataset is assigned a cluster label, indicating the subgroup it belongs to based on the similarity of responses on the clustering variables.- **Cluster Visualization**: The pairplot (or other visualizations) shows the distribution of observations within each cluster, helping to understand the patterns and similarities among the clusters.### Blog Entry SubmissionFor your blog entry, include:- The code used to run the k-means cluster analysis (as shown above).- Screenshots or text of the output (Elbow plot, cluster labels, and cluster visualization).- A brief interpretation of the results.If your dataset is small and you decide not to split it into training and test sets, provide a rationale for this decision in your summary. Ensure the content is clear and understandable for peers who may not be experts in the field. This will help them effectively assess your work.

[krishnamanohari2108]

Run a K means cluster analysis

To run a k-means cluster analysis, you'll use a programming language like Python with appropriate libraries. Here’s a guide to help you complete this assignment:### Step 1: Prepare Your DataEnsure your data is ready for analysis, including the clustering variables.### Step 2: Import Necessary LibrariesFor this example, I’ll use Python and the `scikit-learn` library.#### Python```pythonimport pandas as pdimport numpy as npfrom sklearn.preprocessing import StandardScalerfrom sklearn.cluster import KMeansimport matplotlib.pyplot as pltimport seaborn as sns```### Step 3: Load and Standardize Your Data```python# Load your datasetdata = pd.read_csv('your_dataset.csv')# Select the clustering variablesX = data[['var1', 'var2', 'var3', ...]] # replace with your actual variable names# Standardize the datascaler = StandardScaler()X_scaled = scaler.fit_transform(X)```### Step 4: Determine the Optimal Number of ClustersUse the Elbow method to find the optimal number of clusters.```python# Determine the optimal number of clusters using the Elbow methodinertia = []K = range(1, 11)for k in K: kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X_scaled) inertia.append(kmeans.inertia_)# Plot the Elbow curveplt.figure(figsize=(10,6))plt.plot(K, inertia, 'bo-')plt.xlabel('Number of clusters')plt.ylabel('Inertia')plt.title('Elbow Method For Optimal k')plt.show()```### Step 5: Train the k-means ModelChoose the number of clusters based on the Elbow plot and train the k-means model.```python# Train the k-means model with the optimal number of clustersoptimal_clusters = 3 # replace with the optimal number you identifiedkmeans = KMeans(n_clusters=optimal_clusters, random_state=42)kmeans.fit(X_scaled)# Get the cluster labelslabels = kmeans.labels_data['Cluster'] = labels```### Step 6: Visualize the ClustersUse a pairplot or other visualizations to see the clustering results.```python# Visualize the clusterssns.pairplot(data, hue='Cluster', vars=['var1', 'var2', 'var3', ...]) # replace with your actual variable namesplt.show()```### InterpretationAfter running the above code, you'll have the output from your model, including the optimal number of clusters, the cluster labels for each observation, and a visualization of the clusters. Here’s an example of how you might interpret the results:- **Optimal Number of Clusters**: The Elbow method helps determine the number of clusters where the inertia begins to plateau, indicating an optimal number of clusters.- **Cluster Labels**: Each observation in the dataset is assigned a cluster label, indicating the subgroup it belongs to based on the similarity of responses on the clustering variables.- **Cluster Visualization**: The pairplot (or other visualizations) shows the distribution of observations within each cluster, helping to understand the patterns and similarities among the clusters.### Blog Entry SubmissionFor your blog entry, include:- The code used to run the k-means cluster analysis (as shown above).- Screenshots or text of the output (Elbow plot, cluster labels, and cluster visualization).- A brief interpretation of the results.If your dataset is small and you decide not to split it into training and test sets, provide a rationale for this decision in your summary. Ensure the content is clear and understandable for peers who may not be experts in the field. This will help them effectively assess your work.

[shwetha18112002]

To run a k-means cluster analysis, you'll use a programming language like Python with appropriate libraries. Here’s a guide to help you complete this assignment:### Step 1: Prepare Your DataEnsure your data is ready for analysis, including the clustering variables.### Step 2: Import Necessary LibrariesFor this example, I’ll use Python and the `scikit-learn` library.#### Python```pythonimport pandas as pdimport numpy as npfrom sklearn.preprocessing import StandardScalerfrom sklearn.cluster import KMeansimport matplotlib.pyplot as pltimport seaborn as sns```### Step 3: Load and Standardize Your Data```python# Load your datasetdata = pd.read_csv('your_dataset.csv')# Select the clustering variablesX = data[['var1', 'var2', 'var3', ...]] # replace with your actual variable names# Standardize the datascaler = StandardScaler()X_scaled = scaler.fit_transform(X)```### Step 4: Determine the Optimal Number of ClustersUse the Elbow method to find the optimal number of clusters.```python# Determine the optimal number of clusters using the Elbow methodinertia = []K = range(1, 11)for k in K: kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X_scaled) inertia.append(kmeans.inertia_)# Plot the Elbow curveplt.figure(figsize=(10,6))plt.plot(K, inertia, 'bo-')plt.xlabel('Number of clusters')plt.ylabel('Inertia')plt.title('Elbow Method For Optimal k')plt.show()```### Step 5: Train the k-means ModelChoose the number of clusters based on the Elbow plot and train the k-means model.```python# Train the k-means model with the optimal number of clustersoptimal_clusters = 3 # replace with the optimal number you identifiedkmeans = KMeans(n_clusters=optimal_clusters, random_state=42)kmeans.fit(X_scaled)# Get the cluster labelslabels = kmeans.labels_data['Cluster'] = labels```### Step 6: Visualize the ClustersUse a pairplot or other visualizations to see the clustering results.```python# Visualize the clusterssns.pairplot(data, hue='Cluster', vars=['var1', 'var2', 'var3', ...]) # replace with your actual variable namesplt.show()```### InterpretationAfter running the above code, you'll have the output from your model, including the optimal number of clusters, the cluster labels for each observation, and a visualization of the clusters. Here’s an example of how you might interpret the results:- **Optimal Number of Clusters**: The Elbow method helps determine the number of clusters where the inertia begins to plateau, indicating an optimal number of clusters.- **Cluster Labels**: Each observation in the dataset is assigned a cluster label, indicating the subgroup it belongs to based on the similarity of responses on the clustering variables.- **Cluster Visualization**: The pairplot (or other visualizations) shows the distribution of observations within each cluster, helping to understand the patterns and similarities among the clusters.### Blog Entry SubmissionFor your blog entry, include:- The code used to run the k-means cluster analysis (as shown above).- Screenshots or text of the output (Elbow plot, cluster labels, and cluster visualization).- A brief interpretation of the results.If your dataset is small and you decide not to split it into training and test sets, provide a rationale for this decision in your summary. Ensure the content is clear and understandable for peers who may not be experts in the field. This will help them effectively assess your work.

[ratthika]

To run a k-means cluster analysis, you'll use a programming language like Python with appropriate libraries. Here’s a guide to help you complete this assignment:### Step 1: Prepare Your DataEnsure your data is ready for analysis, including the clustering variables.### Step 2: Import Necessary LibrariesFor this example, I’ll use Python and the `scikit-learn` library.#### Python```pythonimport pandas as pdimport numpy as npfrom sklearn.preprocessing import StandardScalerfrom sklearn.cluster import KMeansimport matplotlib.pyplot as pltimport seaborn as sns```### Step 3: Load and Standardize Your Data```python# Load your datasetdata = pd.read_csv('your_dataset.csv')# Select the clustering variablesX = data[['var1', 'var2', 'var3', ...]] # replace with your actual variable names# Standardize the datascaler = StandardScaler()X_scaled = scaler.fit_transform(X)```### Step 4: Determine the Optimal Number of ClustersUse the Elbow method to find the optimal number of clusters.```python# Determine the optimal number of clusters using the Elbow methodinertia = []K = range(1, 11)for k in K: kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X_scaled) inertia.append(kmeans.inertia_)# Plot the Elbow curveplt.figure(figsize=(10,6))plt.plot(K, inertia, 'bo-')plt.xlabel('Number of clusters')plt.ylabel('Inertia')plt.title('Elbow Method For Optimal k')plt.show()```### Step 5: Train the k-means ModelChoose the number of clusters based on the Elbow plot and train the k-means model.```python# Train the k-means model with the optimal number of clustersoptimal_clusters = 3 # replace with the optimal number you identifiedkmeans = KMeans(n_clusters=optimal_clusters, random_state=42)kmeans.fit(X_scaled)# Get the cluster labelslabels = kmeans.labels_data['Cluster'] = labels```### Step 6: Visualize the ClustersUse a pairplot or other visualizations to see the clustering results.```python# Visualize the clusterssns.pairplot(data, hue='Cluster', vars=['var1', 'var2', 'var3', ...]) # replace with your actual variable namesplt.show()```### InterpretationAfter running the above code, you'll have the output from your model, including the optimal number of clusters, the cluster labels for each observation, and a visualization of the clusters. Here’s an example of how you might interpret the results:- **Optimal Number of Clusters**: The Elbow method helps determine the number of clusters where the inertia begins to plateau, indicating an optimal number of clusters.- **Cluster Labels**: Each observation in the dataset is assigned a cluster label, indicating the subgroup it belongs to based on the similarity of responses on the clustering variables.- **Cluster Visualization**: The pairplot (or other visualizations) shows the distribution of observations within each cluster, helping to understand the patterns and similarities among the clusters.### Blog Entry SubmissionFor your blog entry, include:- The code used to run the k-means cluster analysis (as shown above).- Screenshots or text of the output (Elbow plot, cluster labels, and cluster visualization).- A brief interpretation of the results.If your dataset is small and you decide not to split it into training and test sets, provide a rationale for this decision in your summary. Ensure the content is clear and understandable for peers who may not be experts in the field. This will help them effectively assess your work.

[deandacosta]

Datascale https://t.co/DZZwof6UbL

@deandacosta http://dlvr.it/SrY2Qh

[powerelec]

SambaNova Systems DataScale: the Platform for Innovation

SambaNova Systems DataScale: the Platform for Innovation

SambaNova Systems DataScale® is an integrated system optimized for dataflow from algorithms to silicon. SambaNova DataScale is the core infrastructure for organizations that want to quickly build and deploy next-generation AI technologies at scale. Built on SambaNova Systems Reconfigurable Dataflow Architecture™ (RDA), SambaNova DataScale enables you to achieve unparalleled efficiency and…

[chriscellman]

New DataScale Technology Services Platform Enables the Customer to Streamline Workflow Decision ...

Hanley Wood DataScale Technology Services Platform provides real-time data to customers with timely and accurate proprietary datasets. The dataService platform offers user with custom interfaces, distinct report outputs, segmentation analysis and data-driven content automation. Custom interface allows the customer to select projects or properties for performing specific analysis reports. The custom-built tool enables the customer to prepopulate workflow decision support tools with... from HVAC /fullstory/new-datascale-technology-services-platform-enables-the-customer-to-streamline-workflow-decision-support-processes-40011859 via http://www.rssmix.com/

[martechadvisor-blog]

DataStax Simplifies Delivering Cloud Applications at Scale

Santa Clara, CA: DataStax, a data management platform for cloud applications, today announced the availability of DataStax Managed Cloud, a fully-managed service of the DataStax Enterprise (DSE) data platform, which makes it easier and faster for enterprises to deliver cloud applications at scale. DataStax Managed Cloud combines DSE in a white glove service featuring the company’s proven support and professional services, and technology and expertise from the recently acquired company DataScale to help enterprises make the most of their data infrastructures to achieve business goals faster and focus on driving innovation.

“At DataStax, we understand the stakes are high for organizations to deliver engaging experiences in today’s right-now economy and we’re committed to helping our customers quickly get the best business returns from their data infrastructures,” said Billy Bosworth, CEO at DataStax. “DataStax Managed Cloud provides flexibility for our customers, which allows them to focus on higher-level pieces of their business. DataStax Managed Cloud makes our portfolio the most comprehensive in the data management industry and the most laser-focused on cloud applications that define computing today. I’m excited about what this means for DataStax and I’m even more excited about how this translates into real value for our customers.”

DataStax is focused on making data management available to customers who want take advantage of new technology options in an always-on, cloud-based, right-now economy. DataStax Managed Cloud eliminates the time spent on data management operations and allows customers to focus on their core business. DataStax Managed Cloud also provides customers with deployment flexibility in achieving real-time data management at scale in the cloud.

On how this announcement will help customer experience, Martin Van Ryswyk, Executive Vice President of Product and Engineering at DataStax, said, “Our platform is often used to power applications which provide real-time insights into customer experience as well as critical user-facing interaction. The technology is chosen for its ability to provide context, be always available, scale, and provide insanely quick response time because when you need to provide real-time customer experience these are all critical. For many customers, downtime is not only noticed by their customers, but may lead to national news coverage. Yet despite the high stakes, our customer support data shows that operational mistakes are the number one (by orders of magnitude) cause of urgent issues. The combination of the DataStax Managed Cloud infrastructure technology and human expertise is now available to reduce or eliminate those issues which improve your end-user customer experience.”

Key DataStax Managed Cloud benefits include:

Focus on business innovation by allowing organizations to offload operations to DataStax, simplifying data management and reducing risk within an environment managed by experts. DataStax Managed Cloud lets customers easily scale data management as their business expands.

Time-to-market acceleration on a single underlying data layer that can run both on-premises and on public clouds, which requires no re-write of applications against every cloud provider’s proprietary data services and allows organizations to create APIs and micro-services architectures for a consistent data layer

Choice and flexibility to support hybrid architecture needs by extending your data management platform to fit your hybrid cloud architectures, span or migrate across infrastructure models with 100% compatibility while avoiding cloud vendor lock-in by retaining data autonomy. Customers also have the option to use the DSE Operations Service to increase the operational effectiveness of their own private or public cloud environment of DSE.

More about DataStax:

A fully-managed data platform built on the distribution of Apache Cassandra™ that enables a faster time to market for customers

DataStax Managed Cloud offers choice and flexibility allowing enterprises to achieve business goals faster and focus on driving innovation

Available immediately on Amazon Web Services (AWS) and will expand to Microsoft Azure and Google Cloud Platform

This article was first appeared on MarTech Advisor