Tibor Kiss

Editor’s note: The Jina AI Reader is a specialized tool that transforms raw web content from URLs or local files into a clean, structured, and LLM-friendly format.  In this post, Han Xiao details how Cloud Run empowers Jina AI to build a secure, reliable, and massively scalable web scraping system that remains economically viable. This post explores the collaborative innovation, technical hurdles, and breakthrough achievements behind Jina Reader, a web grounding system now processing 100 billion tokens daily.

When Jina Reader launched in April 2024, its explosive growth — serving more than 10 million requests and 100 billion tokens daily — confirmed huge demand for reliable, LLM-friendly web content. Jina Reader isn’t just another scraper; it takes a different approach to  how AI systems consume web content by transforming raw, noisy web pages into clean, structured markdown.

The core challenge for any AI system processing web data is the “web grounding problem.” Modern websites are a chaotic mix of content, ads, tracking scripts, and dynamic JavaScript, creating an overwhelming noise-to-signal ratio. Traditional scrapers struggle with this complexity, often failing on dynamic single-page applications or generating unusable, ungrounded data for LLMs. Jina Reader’s breakthrough, ReaderLM-v2, is a purpose-built 1.5-billion-parameter language model that intelligently extracts content, trained on millions of documents to understand web structure beyond simple rules.

Cloud Run: The engine behind Jina Reader’s scale

Jina Reader faced  inherent burstiness and unpredictability of web scraping workloads. Traditional virtual machine setups meant either costly over-provisioning or critical failures under load. Google Cloud Run became the essential solution, enabling Jina Reader to build a web scraping system that is secure, reliable, massively scalable, and economically viable.

• The web grounding app (the browser automation system that scrapes and cleans web content) is hosted on Cloud Run (CPU). It runs full Chrome browser instances.

• ReaderLM-v2 is a purpose-built 1.5-billion-parameter language model for HTML-to-markdown conversion that runs on Cloud Run with serverless GPUs.

Cloud Run directly addressed several critical issues:

• Optimized Performance: The deep collaboration between Jina Reader and Google Cloud engineering was essential. We jointly optimized container lifecycle management for browser automation, reducing startup times from over 10 seconds to under two seconds  through prewarming, optimized images, and intelligent resource allocation. For ReaderLM-v2, Google’s team helped create custom container configurations to efficiently run a 1.5-billion-parameter model on Cloud Run GPUs. The on-demand scaling and fast start capabilities of Cloud Run GPUs were critical in helping optimize model performance, directly impacting our ability to process 100 billion tokens daily.

• True Scale-to-Zero Serverless: Cloud Run’s ability to run full Chrome browser instances allowed cost-effective operations. Each request spawns an isolated container with its own headless Chrome, and crucially, these containers disappear when the request is done. This ephemeral nature is vital for processing untrusted web content, mitigating security risks and memory leaks.

• Global Multi-Regional Deployment: Cloud Run’s global presence ensures requests are processed close to both the users and target websites. This significantly minimizes latency and boosts success rates, even against geo-restricted content.

• Massive & Automatic Scaling: The platform seamlessly scales from a handful to over 1,000 container instances during peak traffic, handling the unpredictable nature of web scraping without manual intervention.

• Economic Viability: With Cloud Run’s pay-per-use model, Jina Reader can offer a generous free tier to end users while maintaining profitability even with substantial monthly usage. This pricing flexibility was fundamental to our widespread adoption.

• Resilience and Operational Excellence: During a recent sustained DDoS attack, Cloud Run’s serverless architecture proved invaluable. It scaled up to absorb massive loads (over 100,000 requests per minute), while intelligent rate limiting filtered malicious traffic. Critically, costs returned to normal immediately after the attack subsided due to its scale-to-zero capability.  The system has maintained over 99.9% uptime.

Conclusion

Building Jina Reader on Google Cloud Run proved that AI capabilities and cloud-native architecture are complementary. Cloud Run’s unique capabilities — serverless GPUs, container isolation, global deployment and scale-to-zero economics — made the architecture possible. Our close partnership demonstrates that deep integration between AI-first systems and modern cloud infrastructure can create capabilities previously thought impossible, enabling us to process 100 billion tokens every day.

You can discover more about Cloud Run GPUs on our product page, and if you want to learn how to host a large language model on Cloud Run, watch this video.

As one of India’s largest healthcare providers, Manipal Hospitals serves nearly 7 million patients annually across 37 hospitals. To deliver clinical excellence and patient-centric care at a high standard, we are continually embracing technology.  One of our most significant operational challenges we consistently face is the nurse handover process—a critical but time-consuming task. To make nurse handovers more efficient, safe and accurate, we entered a strategic partnership with the Google Cloud Consulting team to co-develop a generative AI solution, leveraging the power of  Google Cloud.

Rethinking time-consuming, error-prone nurse handoffs

The process of transferring essential information about a patient’s condition and care plan from an outgoing nurse to an incoming one is crucial for ensuring continuity of care and patient safety. However, with more than 10,500 beds across our hospitals, the sheer volume of data required for a comprehensive handover meant our nurses routinely added an extra 90 minutes to their shifts for both creating and receiving these reports. This lengthy process could directly affect patient care, as it could lead  to fatigue and potential mistakes, and also reduce job satisfaction for our vital nursing staff. We needed a way to make this process faster, more accurate, and less of a burden.

Building a trusted solution on Google Cloud

Our joint Manipal-Google team knew that for a clinical tool to be adopted by over 5,000 nurses, it had to be both fast and trustworthy. The primary challenge with any generative AI application in healthcare is ensuring accuracy and minimizing the risk of AI “hallucinations.”

The solution’s architecture, designed by the Google Cloud Consulting team, addresses this head-on by leveraging multiple Google Cloud components. Patient data from our TrakCare system is securely transferred in near real-time to a data lake on Google Cloud. When a nurse requests a handover summary, a serverless Cloud Run application orchestrates a multi-stage process.

Critically, instead of passing pages of raw data directly to the AI, the system first uses intelligent, time-based filters to extract only the most relevant clinical information for the specific shift. This structured, pre-processed data is then sent to Gemini on Vertex AI. This “controlled generation” approach was a key innovation; it ensures Gemini summarizes only the most pertinent facts, dramatically improving the accuracy and consistency of the final ISBAR (Identify, Situation, Background, Assessment, and Recommendation) report. The ability of Gemini to understand complex medical terminology, medication names, and clinical procedures without specialized fine-tuning was a game-changer, accelerating the entire development process.

How our partnership delivered results

By combining Manipal’s deep clinical expertise and Google Cloud Consulting’s technical leadership, our joint approach provides a blueprint for enterprise-grade AI implementation:

• From ideation to production: The Google Cloud Consulting team led the engagement from the initial idea all the way to a production-ready solution now used by thousands of nurses daily. The project started with a focused Minimum Viable Product (MVP) to prove the technology’s value before scaling.

• User-centric design: The solution was not built in a vacuum. The Google team conducted over eight rounds of deep discussion and evaluation sessions directly with our nurses. This ensured the final ISBAR summary format was not just technically impressive, but clinically useful from day one.

• Agile and iterative rollout: The solution was piloted at one hospital initially to test its performance and safety in a real-world setting. With a successful pilot, the solution is live in 23 of Manipal hospitals, and used by more than 5,000 every day. At full scale, it is projected to help save significant nurse hours on a daily basis.  This phased approach, managed jointly, has allowed us to gather feedback and ensure smooth adoption.

Ensuring better patient care

The generative AI solution we implemented has yielded impressive returns. The 70% reduction in handoff time—from 90 minutes down to 20—frees our nurses to focus more on direct patient needs and care. It also makes the process less vulnerable to errors that can arise from handwritten notes and human fatigue.

This project, delivered in partnership with Google Cloud Consulting, is a prime example of how we are pioneering the future of healthcare in India, helping us scale the delivery of quality care across the length and breadth of the country.

^{We’d like to give special thanks to Google Cloud Consulting team –  Naveen Poosarla, Gopala Dhar, Rupjit Chakraborty, Hem Anand, Amit Dutta, Nishant Welpulwar, Preetam Dey and Shikha Saxena – for designing and developing the solution. We are grateful to the Manipal Hospitals team – Saroja Jaykumar, Sunil Bhattacharjee –  in delivering this successful project.}

As Google Kubernetes Engine (GKE) deployments grow and scale, adopting a multi-project strategy in Google Cloud becomes a best practice for security and environment organization. Creating clear boundaries by using distinct projects for development, testing, and production environments provides isolation and helps manage access control.

However, isolation introduces a data protection challenge: How do you effectively manage backups across these project boundaries? Without a native solution, centralizing backups, ensuring a clear separation of duties with IAM, and enabling robust disaster recovery all become  complex tasks, often forcing teams to rely on custom scripts or inefficient manual processes.

Introducing cross-project backup and restore

To address this, Backup for GKE, now in preview, supports cross-project backup and restore. This new capability allows you to back up workloads from a GKE cluster in one Google Cloud project, securely store the backups in a second, and restore them to a cluster in a third. This streamlines data protection, enhances your security posture, and offers greater flexibility for your operational workflows.Storing backups in a separate, isolated project and region is essential for modern disaster recovery, safeguarding your recovery capability during a regional outage or a compromise in a primary Google Cloud project — the foundation of a resilient infrastructure. This separation also simplifies regulatory compliance, boosts security by limiting the blast radius of any potential incident, and helps you meet RTO/RPO objectives.

Key benefits of cross-project backup and restore 

• Centralized backup management: Consolidate GKE backups from multiple Google Cloud projects into a single project by pointing the backup plan for each cluster to the chosen backup project. This simple configuration provides your team with one control plane to oversee monitoring and manage backup policies.

• Enhanced disaster recovery: Storing GKE backups in a separate project and region provides a vital layer of isolation, boosting your resilience against events like regional outages. If your source region becomes unavailable, you can create a restore plan from your backup project to recover your workloads to a cluster in another project.

• Streamline operations: seeding, cloning, and collaboration

  Cross-project capabilities bring agility to your development lifecycle by simplifying how you copy data between environments. You can now leverage production backup data for testing or rapidly clone entire application environments.

• • Seed and clone environments: You can populate a staging environment with data from a prior backup or create a sandbox. Create a restore plan using an existing backup plan located in the backup project, then select a backup — such as one from production for seeding or a dev environment for cloning — and target a cluster in any other project as your destination. This lets you create test environments and isolated sandboxes.

  • Simplify cross-team collaboration: Since all backups are stored in a central backup project, you can grant a developer from another team a role like Delegated Restore Admin, and also provide them with read permission on the specific backup plan and all of its associated backups. They can then use it to restore to their cluster without needing access to the other team’s live source project.

• Achieve separation of duties for security and compliance

  Isolating backups in a dedicated project allows you to enforce the principle of least privilege by assigning distinct responsibilities. You can empower your application teams with self-service permissions to back up and restore applications within their own projects, without giving them control over the central backup repository. A central platform or operations team can be granted administrative control over the backup project to govern the entire data lifecycle — from setting retention policies with immutability to conducting audits, all without needing access to live production environments. This separation is key to reducing risk and simplifying audits.

  For detailed guidance on Backup for GKE IAM roles and permissions, see the documentation.

Cross-project backup and restore for GKE helps you protect your containerized workloads across multiple Google Cloud projects. This feature allows you to strengthen your disaster recovery capabilities, improve your security posture, and streamline operational workflows.

Get started today

Want to try this feature yourself? To enable it for your projects, please complete this form.

• Learn how to perform cross-project backups

• Learn how to perform cross-project restores

In the fast-paced world of AI, it can be challenging to pause and reflect on how we work. Yet this reflection is the cornerstone of continuous improvement. The 2025 DORA survey offers a unique opportunity for you and your team to do just that. By taking just 10-15 minutes to participate before July 18, you can gain valuable insights into your team’s current practices and identify immediate opportunities for growth.

The benefits of applying DORA principles are not just theoretical. Companies around the world have seen significant improvements in their software delivery and operational performance. For example, financial services giant Banorte was able to increase their deployment frequency from bi-weekly to multiple times a day. Similarly, by focusing on continuous improvement, SLB cut their deployment time from five days to just three hours.

These are not isolated incidents. GitLab reduced errors by an impressive 88%, enhancing platform stability, while Scoops accelerated their feature delivery by 700%. These organizations, and many others, have demonstrated that a commitment to getting better at getting better, supported by the insights from DORA, can lead to transformative results.

The 2025 DORA Survey is available in multiple languages, including English, French, Japanese, Portuguese, Simplified Chinese, and Spanish, to ensure that we can capture a truly global snapshot of the technology landscape. Your participation, regardless of your location or language, is invaluable.

Charting the future of AI in technology teams

DORA’s research has already shown that AI is transforming every stage of the software development lifecycle, with 76% of technologists reporting they rely on AI in their daily work. Our findings indicate that when organizations are transparent about their AI strategy and create policies to govern its adoption, they see a significant increase in the use of these powerful new tools. We’ve also seen that AI can have a positive impact on developer well-being, leading to higher job satisfaction and less burnout, but that organizations must be mindful of how AI affects the perceived value of development work.

This year’s DORA survey will take an even deeper look into how we can all improve the impact of AI across the entire software lifecycle. We’ll be building on our previous research into the importance of fostering trust in AI and how to best support teams as they adopt these new capabilities. 

What’s in it for you?

The act of taking the DORA survey is, in itself, a valuable team-assessment. It provides a structured way to think about your team’s workflows, from initial idea to end-user delivery. This reflection can spark immediate ideas for improvement. Perhaps you’ll identify a bottleneck in your review process or an opportunity to enhance your documentation. High-quality documentation, for instance, has been shown to substantially improve team performance.

Your participation also contributes to a larger body of research that helps the entire technology community understand what it takes to build and maintain high-performing teams. By sharing your anonymous experiences, you help shape the industry’s understanding of the impact of AI and the characteristics of high-performing teams. This research is strongest when it includes diverse perspectives, which is why we are calling on a wide range of roles to participate. Whether you are a software engineer, a product manager, a CISO, or a UX designer, or anyone else who participates in the creation and delivery of software, your voice is critical.

Take the DORA survey today

Ready to take the first step towards improving your team’s performance? The 2025 DORA Survey is open until July 18, 2025. Take 15 minutes to reflect on your team’s practices, contribute to industry-leading research, and discover how you can get better at getting better.

SQL has been the cornerstone of data management for over 50 years, valued for its declarative nature and robust ecosystem. However, traditional SQL has limitations, including rigid clause structures, verbose syntax, and complex nested queries that can hinder readability and maintenance. To address these challenges, Google introduced pipe syntax, an extension to GoogleSQL that reimagines how queries are written and processed. A pipe-structured data flow makes SQL more easier to read and write than ever before.

As we discussed in a previous blog post, pipe syntax introduces a linear, top-down approach to SQL queries, using the pipe operator (|>) to chain operations like filtering, aggregating, and joining in a logical sequence. This structure aligns with the natural flow of data transformations, making queries more intuitive, readable, and maintainable. Unlike standard SQL, which enforces a strict order (SELECT, FROM, WHERE, etc.), pipe syntax allows operations to be applied in any order, reducing the need for cumbersome subqueries or Common Table Expressions (CTEs). 

Since pipe syntax became generally available in April, we have seen you embrace it across a myriad of use cases — from streamlining data transformations, building insightful reports to efficiently analyzing logs, and many more. In this blog, we are highlighting three different use cases from customers about how they are using pipe syntax to simplify data transformations and log data analysis.

1.Supercharging data analysis with a linear data flow 

Imagine you want to build a recommendation report to suggest whether a logical or physical pricing model is more cost effective for long-term data storage in BigQuery. While physical storage is generally cheaper, costs can vary based on factors like data compressibility.

You might write a query like this using standard SQL:

Using pipe syntax, the query can be written as:

Pipe syntax eliminates the need for CTEs, allowing users to chain operations linearly. This reduces the query’s complexity and makes it easier to follow, especially for cost analysis tasks requiring multiple transformations. Now you can build a report faster, and share the queries across teams that are easier for them to understand. 

2. Simplifying data transformations in data pipelines 

Suppose you are building a data pipeline for a dashboard. You want to process customer order data to calculate total revenue per customer, filter high-value customers, and then rank them.

In standard SQL:

Using pipe syntax, the query can be written as:

Building a data pipeline is a multi-step process involving data cleaning, transformation and aggregation. Pipe syntax simplifies developers’ workflows by allowing them to chain operations like aggregation and filtering in a logical and sequential way. The simplicity of the code allows developers to focus more time on solving business problems instead of writing and debugging cumbersome SQL code. Fewer lines of code and higher productivity eventually translate to faster business outcomes. 

3. Simpler log analysis in Google Cloud Logging 

Log Analytics in Google Cloud Logging is a powerful tool for storing, searching, analyzing, and monitoring application and system log data through SQL. When you need to perform complex analysis, aggregations, or transformations on their logs, the Log Analytics feature gives you the full strength of SQL.

When helping enterprises to migrate their workloads and logging tooling to Cloud Logging, translating pipe-like structure into standard SQL queries for typical log analysis tasks can sometimes feel cumbersome; it involves subqueries and common table expressions (CTEs) that might not feel immediately intuitive. Pipe syntax offers a more linear, pipe-based syntax, often making common log analysis patterns easier to read and write.

Let’s look at a concrete example.

The challenge: Analyzing log frequency by time, severity, and resource attribute

Imagine you want to analyze your logs to find patterns where specific log messages (identified by severity and tags) occur frequently (more than 5 times per minute), excluding certain messages (like those containing “CookieIncluded=False”).

Using standard SQL in Log Analytics, you might write a query like this:

Using pipe syntax, the query can be written as:

Beyond looking different, pipe syntax fundamentally changes how you build and read queries for sequential log processing. It tackles two common pain points of standard SQL: nested subqueries and “inside-out” logic.

PipeSQL eliminates this nesting for common sequential tasks. Each pipe (|>) feeds the previous command’s output into the next. Aggregation results from the summary are immediately available for filtering in the subsequent WHERE clause without needing an explicit nested structure. The query remains flat and linear. By tackling nesting and promoting a linear flow, pipe syntax significantly lowers the cognitive load for many common log analysis tasks, making powerful analytics more accessible.

Customer love for pipe syntax 

“I was very excited when BigQuery first introduced pipe syntax. As someone who is familiar with R, it is very natural for myself and our team of analysts to use pipe-like syntax for more streamlined data transformation via Dataform. I am happy to share that I have seen >30% reduction in my code compared to standard SQL. This eventually transferred to time saving to read, write and debug queries. I am looking forward to onboarding more analysts to use pipe syntax across my organization.” – Shanker Venkatachalam, Senior Manager, Business Strategy, Northwell.edu

“The pipe syntax has proven to be a revelation in my analytical work. Although I initially had concerns about the learning curve, it was surprisingly smooth. The linear flow facilitates step-by-step query construction, ensuring each transformation is correct before moving on. This reduces complexity and improves long-term maintainability. Notably, it also naturally encourages a ‘micro-transformations’ mindset, resulting in significantly more organized and understandable queries.”– Axel Thevenot, Google Developer Expert, Venom Engineering

“At Bindplane, we specialize in accelerating migrations to Cloud Observability with our telemetry pipeline built on OpenTelemetry. Once the data arrives, using pipe syntax makes it much easier to build key observability assets like dashboards, alerts, and queries. Once pipe syntax is available, I’m done writing regular SQL. It’s just so much easier for helping enterprises get up and running with Cloud Logging/Log Analytics.” – Keith Schmitt, Senior Software Engineer, Bindplane 

What’s next for pipe syntax?

As shared at Cloud Next, BigQuery supports Gemini-powered Data Preparation Agents, which can analyze your data and auto-generate data pipelines to clean and transform your data. You will soon be able to use pipe queries to validate generated queries, which simplifies your pipelines and makes it easier to review and verify code.

In short, pipe syntax is more than a syntactic upgrade. It’s a paradigm shift that makes SQL more accessible and productive for analysts, engineers, and data teams. Its modular, pipeline-based approach aligns with modern data workflows, saving development time and improving efficiency. Whether you’re building reports, developing data pipelines, or analyzing logs, pipe syntax delivers shorter, clearer, and more efficient queries, empowering you to focus on insights rather than syntax. 

Ready to simplify your SQL workflows? Learn how to use pipe syntax from this tutorial, and check out the following resources: 

• Pipe syntax documentation and detailed reference guide 

• Demo video, tutorial 

• Blog post on using pipe syntax for log data analysis

• Research publication (VLDB 2024) with more background and language design details

• Open-source GoogleSQL implementation, ZetaSQL

As your operational needs change, sometimes you need to move data residing within Google’s Cloud Storage to a new location, to improve resilience, optimize performance, meet compliance needs, or simply to reorganize your infrastructure. Yet moving buckets can be a daunting, complex, risky endeavor that involves manual scripting, painstaking coordination, and the risk of data loss, or worse yet, extended downtime. This can discourage organizations from making the changes they need to their storage environments.

We recently introduced Cloud Storage bucket relocation, a unique feature among leading hyperscalers that makes it easy  to change your bucket’s location. Bucket relocation eliminates the need for complex manual planning and helps prevent extended downtime, for an easy transition with minimal application disruption, and strong data integrity. Your bucket’s name, and all the object metadata within it, remain identical throughout the relocation, so there are no path changes, and your applications experience minimal downtime while the underlying storage is moved. Furthermore, your objects retain their original storage class (e.g., Standard, Nearline, Coldline, Archive) and time-in-class in the new location. This is key for many cost efficiency strategies, helping ensure capabilities such as Autoclass continue to operate intelligently to optimize your storage costs post-migration.

Bucket relocation is a key capability within the Storage Intelligence suite, alongside tools like Storage Insights, which  provides deep visibility into your storage landscape and identifies optimization opportunities. Bucket relocation then lets you act on these insights, and move your data between diverse Cloud Storage locations — regional locations for low latency, dual-regions for high availability and disaster recovery, or multi-regions for global accessibility — to meet your  business, performance, and compliance objectives.

Bucket relocation under the hood

Bucket relocation relies on two critical techniques. 

• Asynchronous data copy: Bucket relocation leverages a unique and optimized asynchronous data transfer mechanism that copies data in the background to  minimize impact to ongoing operations. Existing operations like writing, reading, and updating objects continue while the entire dataset is being copied.

• Metadata preservation: Historically, Google Cloud customers moved data with the Storage Transfer Service, which copied the objects to a new bucket and deleted existing ones. Bucket relocation, on the other hand, automatically and meticulously moves all your bucket’s and objects’ associated metadata, thereby preserving state. This includes information like:

• Storage class: Your objects retain their original storage class (e.g., Standard, Nearline, Coldline, Archive) in the new location.

• Bucket and object names: The naming structure of your buckets and objects remains identical.

• Creation and update timestamps: These markers are preserved, so that features like object lifecycle management (OLM) rules continue to operate.

• Access Control Lists (ACLs) and IAM policies: Bucket- and object-level permissions are transferred to help maintain your security posture.

• Custom metadata: Any user-defined metadata associated with your objects is also migrated.

By handling the complexities of asynchronous data transfer and automatic metadata migration, bucket relocation minimizes the risks and overhead associated with a manual bucket migration. Crucially, because the bucket name is preserved throughout the relocation process, applications accessing the bucket don’t need to be modified.

Relocate your bucket in a few simple steps

With bucket relocation, you can move your Cloud Storage buckets in three simple steps. Here’s a breakdown:

1. Initiate a dry run:

• Before starting the actual relocation, it’s highly recommended to perform a dry run. This simulates the process without moving any data, allowing you to identify potential issues early on, such as incompatible configurations.
• The dry run checks for incompatibilities like customer-managed encryption keys (CMEK), locked retention policies, objects with temporary holds, and bucket tags, without you having to manually validate each of them.
• Make sure to add the --dry-run flag!

Replace BUCKET_NAME with the name of your bucket and LOCATION with the desired destination.

2. Start the relocation process:

• This step initiates the actual data transfer from the source bucket to the destination bucket. During this phase, you can still read, modify, and delete objects in the bucket. However, the bucket metadata (i.e., bucket-level  parameters and configurations) is write-locked to prevent changes that could affect the relocation.
  Note: Removing the --dry-run flag from the dry-run command initiates the relocation.

3. Finalize the relocation process:

• Once the incremental data copy is complete, you’re ready to trigger the final synchronization step (except when moving between multi-region and configurable dual-region). This involves a brief period where writes to the bucket are disabled to help ensure their data integrity; any last-second changes made to the objects within the bucket while the incremental copy was in progress are copied to the destination. After the data’s integrity is verified, the bucket’s location is updated, and all requests are automatically redirected to the new location. During the final synchronization step, attempts to update objects in the bucket will result in an HTTP 412 error.
• Do not initiate the final synchronization process until the relocation process progress reaches ~99%. This helps you minimize downtime because most of the data has already been synchronized in the background. 

Note: If you’re moving between multi-regions and configurable dual-regions within the same multi-region code, you’re all set — bucket relocation handles the transition in the background, no finalization or downtime required!

The OPERATION_ID is provided as output from Step-2. The OPERATION_ID is listed with the keyword name. For instance:

name: projects/_/buckets/my-bucket/operations/AbCJYd8jKT1n-Ciw1LCNXIcubwvij_TdqO-ZFjuF2YntK0r74

And there you have it — In just three steps, you’ven moved your entire bucket, its data, and metadata, to its new location.

Early users of bucket relocation have had great success with the new feature. 

“With Storage Intelligence and bucket relocation, we effortlessly transitioned to dual-region buckets. The seamless process, powered by the bucket relocation, minimized downtime and ensured data integrity. We migrated the buckets with peace of mind and without the manual headaches.” – Adam Steele, Product Manager, Spotify

“We recently utilized the bucket relocation feature of Storage Intelligence to successfully complete a ~300 bucket migration and PBs of data project from multi-region to regional storage, to optimize network data transfer costs. Without bucket relocation, this process would have required extensive automation and scripting, resulting in increased downtime and effort.” – Deepak Mahato, Data Platform Infrastructure Manager, GroupOn

Experience the ease and efficiency of managing your Cloud Storage buckets with bucket relocation in Storage Intelligence. To learn more, visit the bucket relocation documentation and the Storage Intelligence overview.

In today’s hyperconnected world, delivering personalized content at scale requires more than just aggregating information – it demands deep understanding of context, relationships, and user preferences. Glance, a leading content discovery platform that delivers personalized, real-time content experiences on mobile lock screens across the globe, serves over 300 million users worldwide across 450 million devices. Beyond news aggregation, Glance curates diverse content including entertainment, sports, gaming, shopping, and lifestyle content, making every glance at the phone screen meaningful and engaging.

However, with the exponential growth of digital content, particularly the overwhelming volume of daily news articles, Glance faced a critical challenge: how to effectively navigate this information while maintaining the personalized, contextual experiences users expect. The existing search and content discovery capabilities needed significant enhancement to uncover emerging trends, improve search relevance, provide deeper context, and most importantly, deliver truly personalized content recommendations that resonate with individual user preferences and behaviors.

Glance partnered with Google Cloud Consulting team to build a sophisticated Content Knowledge Graph (CKG) that addresses these challenges head-on. This solution leverages Google Cloud’s advanced AI and data processing capabilities, including Gemini models, BigQuery, Vertex AI, and Google Cloud partner Neo4j, to ingest, process, extract, standardize, classify, and structure news data into a dynamic network of interconnected entities and relationships. The Content Knowledge Graph has dramatically improved search relevance, enhanced personalized content discovery, provided deeper contextual insights, increased user engagement, and improved scalability and efficiency.

Tackling the content discovery and personalization challenge  

Glance’s mission extends far beyond traditional content aggregation. As a platform serving hundreds of millions of users globally, Glance must deliver hyper-personalized content experiences that anticipate user interests and adapt to evolving preferences in real-time. The challenge was multifaceted:

• Uncovering trends at scale – Identifying emerging topics, viral content, and the complex relationships between different content categories across news, entertainment, sports, and lifestyle domains

• Enhancing personalized search – Improving the accuracy and relevance of search results based on individual user behavior patterns, preferences, and contextual signals

• Providing intelligent context – Offering users deeper understanding not just of individual pieces of content, but how different stories, events, and topics connect across the broader content ecosystem

• Scaling personalization – Delivering these sophisticated experiences across 300+ million users while maintaining real-time responsiveness and relevance

Manually analyzing and connecting the dots within this vast, multi-dimensional content landscape was simply not scalable. Glance needed an intelligent, automated approach that could understand content at both granular and contextual levels while powering personalized recommendations at unprecedented scale.

Building a Gemini-powered content intelligence engine

Glance and Google Cloud Consulting team collaborated to architect and implement a comprehensive Content Knowledge Graph that transforms how content is understood, connected, and delivered. This sophisticated system leverages the full spectrum of Google Cloud’s AI and data processing capabilities:

• Intelligent content ingestion and processing – The system ingests content from diverse sources beyond news, including entertainment articles, sports updates, lifestyle content, and trending topics, storing them in BigQuery for efficient, scalable processing.

• Advanced entity extraction and relationship mapping – Using Gemini foundational models, the system extracts key entities (people, organizations, locations, events, brands) and identifies complex relationships between them across different content categories.

• Entity standardization and knowledge linking – Extracted entities are normalized using Gemini’s advanced language understanding and linked to authoritative knowledge sources like Wikipedia, ensuring consistency and enabling sophisticated cross-content analysis.

• Multi-dimensional content classification – Gemini foundation models classify content into granular categories using the IAB content taxonomy while also identifying sentiment, urgency, and relevance signals for personalization.

• Intelligent content summarization and tagging – Gemini generates contextual tags, compelling short headlines, and category labels, enabling users to quickly grasp content essence while powering recommendation algorithms.

• Dynamic Knowledge Graph construction – The extracted information is structured into a Neo4j graph database, creating a living, breathing network of interconnected entities, topics, relationships, and user interaction patterns.

• Real-time trend analysis and prediction – The system integrates with external trend APIs and analyzes user engagement patterns to identify and predict trending topics, providing actionable insights for content curation.

• Interactive analytics dashboard – NeoDash powers an interactive dashboard for monitoring trending content, analyzing entity relationships, and visualizing content performance across different user segments.

Diagram 2:

Engineering for Global Scale and Performance

Glance enhanced the Content Knowledge Graph solution to handle 50,000+ daily articles across multiple content categories. The engineering team implemented several critical optimizations:

• Event-driven architecture transformation – Migrating to a Kafka-based event-driven architecture with intelligent retries and asynchronous operations resulted in 4x throughput improvement, enabling real-time content processing at massive scale.

• Graph database optimization – Neo4j query optimization and indexing strategies drastically reduced query response times from seconds to milliseconds, enabling real-time content recommendations.

• Kubernetes-native deployment – Moving to managed Google Kubernetes Engine (GKE) with auto-scaling capabilities improved system reliability and resource utilization.

• Strategic performance optimization – Applying the 80-20 principle to focus on high-impact optimizations, coupled with Redis caching and Cloud Spanner for critical data, reduced processing latency by 80% and boosted recommendation coverage from under 60% to over 85%.

• Intelligent load balancing – Implementing smart load distribution across processing pipelines ensured consistent performance even during viral content spikes and peak traffic periods.

 Business impact

The Content Knowledge Graph has delivered measurable improvements across key business metrics:

• Enhanced content discovery performance – CKG-powered content recommendations boosted Cards per Session (CPS) by 24%, directly improving user engagement and platform stickiness.

• Significantly increased user engagement – More relevant and contextually aware content delivery resulted in higher click-through rates and a 5% increase in swiping sessions, particularly in the related content sections.

• Real-time trend intelligence – Users now discover trending topics instantly across news, entertainment, sports, and lifestyle categories, with faster trend detection compared to previous systems.

• Data-driven content strategy – The CKG provides comprehensive, actionable insights into content performance, user preferences, and emerging trends, enabling data-driven editorial and curation decisions.

• Global scalability and efficiency – The cloud-native architecture seamlessly handles Glance’s ever growing global content pool while maintaining cost efficiency and performance.

Shaping the Future of content discovery

The Glance Content Knowledge Graph transforms  raw, unstructured content into a sophisticated, interconnected knowledge network, and has  has empowered Glance to deliver truly engaging content experiences that anticipate user needs.The solution’s success lies not just in its technical sophistication, but in its ability to enhance the human experience of content discovery – making every interaction with Glance more meaningful, relevant, and engaging.

As content continues to proliferate and user expectations for personalization grow, the principles and technologies demonstrated in this project provide a blueprint for the future of intelligent content platforms. We’re excited to see how Glance leverages this powerful foundation to further innovate in personalized content discovery and set new standards for user experience in the digital content ecosystem.

At Google Cloud, we are committed to making it as seamless as possible for you to build and deploy the next generation of AI and agentic applications. Today, we’re thrilled to announce that we are collaborating with Docker to drastically simplify your deployment workflows, enabling you to bring your sophisticated AI applications from local development to Cloud Run with ease. 

Deploy your compose.yaml directly to Cloud Run

Previously, bridging the gap between your development environment and managed platforms like Cloud Run required you to manually translate and configure your infrastructure. Agentic applications that use MCP servers and self-hosted models added additional complexity. 

The open-source Compose Specification is one of the most popular ways for developers to iterate on complex applications in their local environment, and is the basis of Docker Compose. And now, gcloud run compose up brings the simplicity of Docker Compose to Cloud Run, automating this entire process. Now in private preview, you can deploy your existing compose.yaml file to Cloud Run with a single command, including building containers from source and leveraging Cloud Run’s volume mounts for data persistence. 

Supporting the Compose Specification with Cloud Run makes for easy transitions across your local and cloud deployments, where you can keep the same configuration format, ensuring consistency and accelerating your dev cycle.

“We’ve recently evolved Docker Compose to support agentic applications, and we’re excited to see that innovation extend to Google Cloud Run with support for GPU-backed execution. Using Docker and Cloud Run, developers can now iterate locally and deploy intelligent agents to production at scale with a single command. It’s a major step forward in making AI-native development accessible and composable. We’re looking forward to continuing our close collaboration with Google Cloud to simplify how developers build and run the next generation of intelligent applications.” – Tushar Jain, EVP Engineering and Product, Docker

Cloud Run, your home for AI applications

Support for the compose spec isn’t the only AI-friendly innovation you’ll find in Cloud Run. We recently announced general availability of Cloud Run GPUs, removing a significant barrier to entry for developers who want access to GPUs for AI workloads. With its pay-per-second billing, scale to zero, and rapid scaling (which takes approximately 19 seconds for a gemma3:4b model for time-to-first-token), Cloud Run is a great hosting solution for deploying and serving LLMs. 

This also makes Cloud Run a strong solution for Docker’s recently announced OSS MCP Gateway and Model Runner, making it easy for developers to take the AI applications locally to production in the cloud seamlessly. By supporting Docker’s recent addition of ‘models’ to the open Compose Spec, you can deploy these complex solutions to the cloud with a single command.  

Bringing it all together

Let’s review the compose file for the above demo. It consists of a multi-container application (defined in services) built from sources and leveraging a storage volume (defined in volumes). It also uses the new models attribute to define AI models and a Cloud Run-extension defining the runtime image to use:

Building the future of AI

We’re committed to offering developers maximum flexibility and choice by adopting open standards and supporting various agent frameworks. This collaboration on Cloud Run and Docker is another example of how we aim to simplify the process for developers to build and deploy intelligent applications. 

Compose Specification support is available for our trusted users — sign up here for the private preview.