Emergency Steps to Keep Your Website Running

On December 3, 2025, the React team revealed a critical Remote Code Execution vulnerability in React Server Components (RSC). It affects several RSC packages and some of the most widely used React frameworks, including Next.js. A fix is already out, so the urgent step now is simply checking whether your project uses these packages—and updating to the patched versions if it does. Overview of the Vulnerability A newly reported flaw allows unauthenticated Remote Code Execution (RCE) on servers running React Server Components. Type: Unauthenticated Remote Code Execution CVE: CVE-2025-55182 (NIST , GitHub Advisory Database) Severity: CVSS 10.0 (Maximum severity) This means an attacker could execute arbitrary code on the server without any form of authentication, giving them full control of the affected environment. The issue is caused by a flaw in how React decodes payloads sent to React Server Function endpoints. A maliciously crafted HTTP request can trigger unsafe deserialization, leading to remote code execution. React will publish additional technical details once the patch rollout is fully completed. Scope of Impact Any application that supports React Server Components may be exposed, even if it never defines any Server Function endpoints. The vulnerability exists in the underlying RSC support layer used by multiple frameworks and bundlers. Your application is not vulnerable if: Your React code does not run on a server, or Your application does not use a framework, bundler, or plugin that supports React Server Components. Traditional client-only React applications are unaffected. Affected Versions and Components The vulnerability is tied to specific versions of the React Server Components packages and to the frameworks that depend on them. Identifying whether your project uses any of these versions is the first step in determining your exposure. Vulnerable Packages The issue affects the following packages in versions 19.0, 19.1.0, 19.1.1, and 19.2.0: react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack Affected Frameworks and Bundlers Several frameworks that rely on these packages are also impacted, including: Next.js React Router (when using unstable RSC APIs) Waku @parcel/rsc @vitejs/plugin-rsc Redwood SDK Security Fix and Recommended Actions The React team has released patched versions, and major frameworks have issued corresponding updates. Applying these fixes promptly is the only reliable way to remove the vulnerability from affected projects. Patched Versions The React team has released fixed versions: 19.0.1 19.1.2 19.2.1 (or any version newer than these) Upgrading to a patched release is mandatory to eliminate the vulnerability. Framework Updates Framework maintainers have also published security updates. For example, Next.js users must upgrade to one of the following patched versions: next@15.0.5 next@15.1.9 next@15.2.6 next@15.3.6 next@15.4.8 next@15.5.7 next@16.0.7 Other ecosystems (React Router, Redwood, Vite plugin, Parcel, Waku, etc.) also require upgrading to their latest patched versions. What Development Teams Should Do Now We recommend the following immediate steps: Audit all projects to confirm whether React Server Components or related frameworks are in use. Check package versions for the affected libraries listed above. Upgrade to the patched versions immediately if your application falls within the impacted scope. Review deployment environments for any unusual activity (optional but advisable for security). Document and report the findings to your internal security or project stakeholders. Conclusion This vulnerability (CVE-2025-55182) is one of the most severe vulnerabilities ever disclosed within the React ecosystem, and it may impact a wide range of modern React-based applications. To maintain security and prevent potential exploitation, all teams should: Review their applications, Identify affected components, and Apply the necessary upgrades without delay. If you need a security audit or patch support within your React-based web development projects, Haposoft is ready to step in.

When you submit an app to Google Play, most early failures surface in Closed Testing, not the final review. What we share here comes from real testing practice, and it’s what made handling those failures predictable for us. What Google Play Closed Testing Is Closed Testing is where Google first checks your app using real user activity, so it matters to understand what this stage actually requires. Where Closed Testing Fits in the Submission Process When you submit an app to Google Play, it doesn’t go straight to the final review. Before reaching that stage, every build must pass through Google’s internal testing tracks—Internal Testing → Closed Testing → Open Testing. Closed Testing sits in the middle of this flow and is the first point where Google expects real usage from real users. If the app fails here, it never reaches the actual “Submit for Review” step. That’s why many teams face repeated rejections without realizing the root cause comes from this stage, not the final review. Google Play Closed Testing in Simple Terms Google Play Closed Testing is a private release track where your app is shared with a small group of testers you select. These testers install the real build you intend to ship and use it in everyday conditions. The goal is straightforward: Google wants to see whether the app behaves like a complete product when real people interact with it. In this controlled environment, Google observes how users move through your features, how data is handled, and whether the experience matches what you describe in your Play Console settings. This is essentially Google’s early check to confirm that the app is stable, transparent, and built for genuine use—not just something assembled to pass review. What Google Expects During Closed Testing The core function of Google Play Closed Testing is to verify authenticity. Google wants evidence that your app is functional, transparent, and ready for real users, not a rushed build created solely to pass review. To make this evaluation, Google looks for a few key signals: Real testers using real, active Google accounts Real usage patterns, not one-off opens or artificial interactions Consistent engagement over time, typically around 14 days for most app types Actions inside your core features, not empty screens or placeholder flows Behavior that aligns with your Data Safety, privacy details, and feature declarations Evidence that the app is “alive”, such as logs, events, and navigation patterns generated from authentic interactions Google began tightening its review standards in 2023 after more unfinished and auto-generated apps started slipping into the submission flow. Instead of relying only on manual checks, Google now leans heavily on the activity recorded during Closed Testing to understand how an app performs under real use. This gives the review team a clearer picture of stability, data handling, and readiness—making Closed Testing a much more decisive step in whether an app moves forward. Why Google Play Closed Testing Is So Hard to Pass Most teams fail Closed Testing because their testing behavior doesn’t match the actual evaluation signals Google uses. The table below compares real developer mistakes with Google’s real criteria, so you can see exactly why each issue leads to rejection. Common Issues During Testing What Google Actually Checks Teams treat Closed Testing like internal QA. Testers only tap around the interface and rarely complete real user journeys. Google checks full, natural flows. It expects onboarding → core action → follow-up action. Shallow tapping does not confirm real functionality, so Google marks the test as lacking behavioral proof. Testers open the app once or twice and stop. Most activity happens on day 1, then engagement drops to zero. Google checks multi-day usage patterns. It needs recurring activity to evaluate stability and real adoption. One-off launches look like artificial or incomplete testing → fail. Core features remain untouched because testers don’t find or understand them. Navigation confusion prevents users from triggering important flows. Google checks whether declared core features are actually used. If users don’t naturally reach those flows, Google cannot validate them → flagged as “unverified behavior.” Permissions are declared but no tester enters flows that use them. e.g., camera, location, contacts, or other data-related actions never get triggered. Google cross-checks declared permissions with real behavior. If a permission never activates during testing, Google treats the Data Safety form as unverifiable → extremely high rejection rate. Engagement collapses after the first day. Testers lose interest quickly, resulting in long periods of zero activity. Google checks consistency over time (≈14 days). When usage dies early, the system sees weak, unreliable activity that does not resemble real-world usage → rejection. Passing Google Play Closed Testing: A Real Case Study Closed Testing turned out to be far stricter than we expected. What looked like a simple pre-release step quickly became the most decisive part of the review, and our team had to learn this the hard way—through three consecutive rejections before finally getting approved. The Three Issues That Held Us Back in Closed Testing These were the three recurring problems that blocked our app from moving past Google Play’s Closed Testing stage. #Issue 1: Having Testers, but Not Enough “Real” Activity In the first attempt, we only invited one person to join the test, so the app barely generated any meaningful activity. Most of the usage stopped at simple screen opens, and none of the core features were exercised in a way Google could evaluate. With such a small and shallow pattern, the system couldn't treat it as real user participation. The build was rejected right away for not meeting the minimum level of authentic activity. #Issue 2: Misunderstanding the “14-Day Activity” Requirement For the second round, we expanded the group to twelve testers, but most of them stopped using the app after just a few days. The remaining period showed almost no engagement, which meant the full 14-day window Google expects was never actually covered. Although the number of testers looked correct, the lack of continuous usage made the test inconclusive. Google dismissed the submission because the activity dropped off too early. #Issue 3: No Evidence of Real Activity (Logs, Tracking, or Records) By the third attempt, we finally kept twelve testers active for the entire duration, but we failed to capture what they did. There were no logs showing feature flows, no tracking to confirm event sequences, and no recordings for actions tied to sensitive permissions. From Google's viewpoint, the numbers in the dashboard had nothing to support them. Without verifiable evidence, the review team treated the activity as unreliable and rejected the build again. What Finally Helped Us Pass Google Play Closed Testing To fix the issues in the earlier attempts, the team reorganized the entire test instead of adding more testers at random. Everything was structured so Google could see consistent, authentic behaviour from real users. A larger tester group created a more reliable activity curve The previous rounds didn’t generate enough meaningful activity, so we increased the number of people involved. The larger group created a more natural engagement pattern that gave Google more complete usage signals to review. Extending the testing period from 14 to 17 consecutive days To avoid the early drop-off that hurt our earlier attempts, we kept the test running a little longer than the minimum 14 days. The longer duration prevented mid-test gaps and helped Google see continuous interaction across multiple days. Introducing a detailed daily checklist so testers covered the right flows Instead of letting everyone tap around freely, we provided a short list of the core actions Google needed to observe. A clear checklist guided testers through specific actions each day, producing consistent evidence for the features Google needed to verify. Enabling device-level tracking and full system logs Earlier data was too thin to validate behaviour, so we enabled device-level tracking and full system logs to review and later align with Google’s dashboard. This fixed the “invisible activity” issue from the earlier rounds and gave the review team something concrete to validate. Having testers record short videos of their actions Some flows involving permissions weren’t reflected clearly in logs, so testers recorded short clips when performing these tasks. These videos provided direct confirmation of how camera, file access and upload flows worked. Adding small features and content to encourage natural engagement The previous builds didn’t encourage repeated use, so we added minor features and content updates to create more realistic daily engagement. These adjustments helped testers interact with the app in a way that resembled real usage, not surface-level taps. Release Access Form: A Commonly Overlooked Step in the Approval Process After Closed Testing is completed, Google requires developers to submit the Release Access Form before the app can move forward in the publishing process. It sounds simple, but the way this form is written has a direct influence on the final review. Taking the form seriously, paired with the testing evidence we had already prepared, helped our final submission go through smoothly on the fourth attempt. Here’s what became clear when we worked through it: The answers must reflect the real behaviour of the app — especially the sections on intended use and where user data comes from. Any mismatch creates doubt. Google expects clear descriptions of features, user actions and the scope of testing. Vague explanations often slow the process down. Looking at how other developer communities handled this form helped us understand the phrasing that aligns with Google’s criteria. Final Thoughts Closed Testing is ultimately about proving that your app behaves like a real, ready-to-ship product. Most teams lose time because they only react after a rejection; we prevent 80% of those rejections long before you ship. If you want fewer surprises and a tighter, lower-risk review cycle, talk to us and Haposoft will run the entire review cycle for you.

As VOD libraries expand, broadcasters face rising storage demands and slower data access. To address that, we propose a model using Amazon S3 video storage that keeps media scalable, secure, and cost-efficient over time. Why Amazon S3 Video Storage Fits Modern VOD Workflows Launched on March 14 2006, Amazon S3 began as one of the first public cloud storage services. The current API version—2006-03-01—has remained stable for nearly two decades while continuously adding new capabilities such as lifecycle automation, reduced storage tiers, and improved console features. Over more than 15 years of updates, S3 has grown far beyond “a storage bucket” into a global object storage platform that supports replication, logging, and analytics at scale. According to Wikipedia, the number of stored objects increased from about 10 billion in 2007 to more than 400 billion in 2023—illustrating how it scales with worldwide demand for AWS cloud storage and video streaming workloads. Key technical advantages of Amazon S3 video storage: Scalability: Pay only for the data you use—no pre-provisioning or capacity limits. Durability: Designed for 99.999999999 percent (“11 nines”) data durability, ensuring media integrity over time. Cost flexibility: Multiple storage classes allow efficient tiering from frequently to rarely accessed content. Deep AWS integration: Works seamlessly with CloudFront, Lambda, Athena, and Glue to handle video processing and delivery. Security and compliance: Versioning, Object Lock, and CloudTrail logging meet broadcast-grade data-governance requirements. With this maturity, scalability, and reliability, Amazon S3 video storage has become the natural foundation for broadcasters building modern VOD systems. Solution Architecture: Multi-Tier VOD Storage on Amazon S3 The broadcasting team built its VOD system around Amazon S3 video storage to handle about 50 GB of new recordings each day — nearly 18 TB per year. The goal was simple: keep all video available, but spend less on storage that’s rarely accessed. Instead of treating every file the same, the data is separated by lifecycle. New uploads stay in S3 Standard for quick access, while older footage automatically moves to cheaper tiers such as Standard-IA and Glacier. Cross-Region Replication creates a copy in another region for disaster recovery, and versioning keeps track of every edit or replacement. This setup cuts monthly cost by more than half compared with storing everything in a single class. It also reduces manual work - files move, age, and archive automatically based on defined lifecycle rules. The rest of this section breaks down how the system works in practice. (AWS Best Practice) System Overview The storage system is split into a few simple parts, each doing one clear job. Primary S3 bucket (Region A – Singapore): This is where all new videos land after being uploaded from local studios. Editors and producers can access these files directly for a few months while the content is still fresh and often reused. Lifecycle rules for auto-tiering: After the first three months, the system automatically shifts older objects to cheaper storage tiers. It’s handled through lifecycle rules, so there’s no need to track or move files manually. Cross-Region Replication (Region B – Tokyo): Every new file is copied to another region for redundancy. If one region fails or faces downtime, all data can still be restored from the secondary location. Access control and versioning: Access policies define who can read or modify content, while versioning keeps a full history of changes — useful when editors replace or trim video files. Together, these components keep the VOD archive easy to manage: new content stays fast to access, archived footage stays safe, and everything costs far less than a one-tier setup. Optimizing with AWS Storage Classes Each phase of a video’s lifecycle maps naturally to a different AWS storage class. In the early stage, new uploads stay in S3 Standard, where editors still access them frequently for editing or scheduling broadcasts. After the first few months, when the files are mostly finalized, they shift to S3 Standard-IA, which keeps the same quick access speed but costs almost half as much. As the archive grows, older footage that is rarely needed moves automatically to S3 Glacier Instant Retrieval, where it remains available for years at a fraction of the price. Content that only needs to be retained for compliance or historical purposes can be stored safely in S3 Glacier Flexible Retrieval or Deep Archive, depending on how long it needs to stay accessible. This tiered structure keeps the storage lean and predictable. Costs fall gradually as data ages while every file remains retrievable whenever required, something that traditional on-premise systems rarely achieve. It allows broadcasters to manage expanding VOD libraries without overpaying for high-performance storage that most of their content no longer needs. Storage Class Use Case Access Speed Cost Level Typical Retention S3 Standard New uploads and frequently accessed videos Milliseconds High 0–90 days S3 Standard-IA Less-accessed content, still in rotation Milliseconds Medium 90–180 days S3 Glacier Instant Retrieval Older videos that may need quick access Milliseconds Low 6–12 months S3 Glacier Flexible Retrieval Archival content, rarely accessed Minutes to hours Very low 1–3 years S3 Glacier Deep Archive Historical backups or compliance data Hours Lowest 3+ years Automating Data Tiering with Amazon S3 Lifecycle Policy Manually tracking which videos are old enough to move to cheaper storage becomes unrealistic once the archive grows to terabytes. To avoid that, the team set up an Amazon S3 lifecycle policy that automatically transitions data between storage tiers depending on how long each object has been in the bucket. This approach removes manual work and ensures that every file lives in the right tier for its age and access frequency. The rule applies to all objects in the vod-storage-bucket. For roughly the first three months, videos remain in S3 Standard, where they are frequently opened by editors and producers for re-editing or rebroadcasting. After 90 days, the lifecycle rule moves those files to S3 Standard-IA, which keeps millisecond-level access speed but costs around 40% less. When videos reach about six months old, they are transitioned again to S3 Glacier Instant Retrieval, which provides durable, low-cost storage while still allowing quick restores when needed. After three years, the system automatically deletes expired files to keep the archive clean and avoid paying for data no one uses anymore. Below is the JSON configuration used for the policy: What this policy does: After 90 days, objects are moved from S3 Standard to S3 Standard-IA. After 180 days, the same objects move to S3 Glacier Instant Retrieval. After 3 years (1,095 days), the data is deleted automatically. This way, fresh content stays fast, older content stays cheap, and the archive never grows forever. Ensuring Redundancy with Cross-Region Replication (S3 CRR) When broadcasters archive years of video, the question isn’t just cost — it’s “what if a region goes down?” To keep content recoverable, the system enables S3 Cross-Region Replication (CRR). Each new or updated file in the primary bucket is automatically copied to a backup bucket in another AWS region. This setup uses a simple AWS CLI command: When CRR is active, every object uploaded to the vod-storage-bucket is duplicated in vod-backup-bucket, stored in a different region such as Tokyo. If the main region suffers an outage or data loss, the broadcaster can still restore or stream files from the backup. Besides disaster recovery, CRR supports compliance requirements that demand off-site backups and version protection. It also gives flexibility: the destination can use a lower-cost storage class, cutting replication expenses while keeping full data redundancy. Cost Analysis: Amazon S3 Pricing for VOD Workloads To evaluate the actual savings, the team estimated the monthly cost of storing roughly 18 TB of VOD data on Amazon S3. If everything stayed in S3 Standard, the cost would reach about $0.023 per GB per month, or nearly $414 USD in total. This flat setup is simple but inefficient, as older videos that are rarely accessed still sit in the most expensive storage class. With lifecycle tiering enabled, the same 18 TB is distributed across several classes based on how often each dataset is used. Around 4.5 TB of recent videos remain in S3 Standard for fast access, another 4.5 TB shifts to S3 Standard-IA, and the rest (about 9 TB) moves to S3 Glacier Instant Retrieval for long-term retention. Based on AWS’s current pricing, this mix brings the total monthly cost down to around $195–$200, cutting storage expenses by over 50 percent while keeping all assets available when needed. Storage Segment Approx. Volume Storage Class Price (USD / GB / month) Estimated Monthly Cost New videos (0–90 days) 4.5 TB S3 Standard $0.023 ~$103.5 90–180 days 4.5 TB S3 Standard-IA $0.0125 ~$56.25 180 days+ 9 TB S3 Glacier IR $0.004 ~$36 Total 18 TB — — ~$195.75 Final Thoughts The VOD storage model built on Amazon S3 shows how broadcasters can balance scale, reliability, and cost in one system. By combining lifecycle policies, multi-tier storage, and cross-region replication, the workflow stays simple while infrastructure costs drop sharply. With Amazon S3 video storage, broadcasters can scale their VOD systems sustainably and cost-effectively — turning storage from a fixed cost into a flexible, data-driven resource. If your team is looking to modernize or optimize an existing VOD platform, Haposoft can help assess your current setup and design a tailored AWS storage strategy that grows with your needs.