Priori is ranked a Chambers Tier 1 Global LawTech company and a Financial Times Intelligent Business, Priori is the game-changing legal technology platform for in-house legal teams to find and engage external counsel

Priori

In the digital age, where users expect lightning-fast loading times and seamless browsing experiences, optimizing web performance is paramount for businesses and developers alike. One key aspect of this optimization lies in efficient resource fetching and prioritization. In this article, we delve into various techniques and strategies, including pre-connect and dns-prefetch, fetchpriority, prefetch, and preload, as well as the utilization of async and defer attributes in JavaScript execution. By implementing these approaches, developers can significantly enhance page load times, improve user experience, and ultimately, bolster key performance metrics such as Largest Contentful Paint (LCP) and First Contentful Paint (FCP). Let's explore how each of these methods contributes to a faster and more responsive web. Establish Early Connections With and preconnect dns-prefetch Consider adding t or resource hints to establish early connections to important third-party origins. preconnec dns-prefetch Modern browsers what connections a page will need, but they cannot reliably predict them all. We can give them a (resource) hint. try their best to anticipate informs the browser that your page intends to establish a connection to another origin, and that you'd like the process to start as soon as possible. <link rel="preconnect"> The hint is best used for only the most critical connections. preconnect For all the rest, use to save time on the first step(round trip), the DNS lookup, which usually takes around <link rel=dns-prefetch> 20–120 ms. Preconnecting is only effective for domains other than the origin domain, so you shouldn't use it for your site. Only preconnect to critical domains you will use soon because the browser closes any connection that isn't used within 10 seconds. Unnecessary preconnecting can delay other important resources, so limit the number of preconnected domains and . test the impact preconnecting makes If a page needs to make connections to many third-party domains, preconnecting all of them is counterproductive. The preconnect hint is best used for only the most critical connections. For all the rest, use <link rel=dns-prefetch> to save time on the first step, the DNS lookup, which usually takes around . 20–120 ms is slightly different from , so dns-prefetch can serve as a fallback for browsers that don't support . Browser support for dns-prefetch preconnect support preconnect Effect on Largest Contentful Paint (LCP) Using dns-prefetch and preconnect allows sites to reduce the amount of time it takes to connect to another origin. The ultimate aim is that the time to load a resource from another origin should be minimized as much as possible. Where is concerned, it is better that resources are immediately discoverable, since are crucial parts of the user experience. Largest Contentful Paint (LCP) LCP candidates Optimizing Resource Loading With Priority Hints With fetchpriority is an attribute that allows you to hint at the relative priority of a resource (high or low). Priority Hints can help optimize the Core Web Vitals. Fetchpriority You can provide a Priority Hint using the HTML attribute. You can use the attribute with , , , and tags. The attribute allows you to specify the priority for resource types such as CSS, fonts, scripts, images, and iframe when downloaded using the supported tags. fetchpriority link img script iframe The fetchpriority attribute accepts one of three values: : This is used when the resource is considered a high priority. The browser is instructed to prioritize it, given that its heuristics don't hinder this. high : This is used when the resource is considered a low priority. The browser is instructed to deprioritize it if its heuristics allow. low : This is the default value used when there is no preference. The browser decides the appropriate priority. auto <img src="lcp-image.jpg" fetchpriority="high">
<link rel="preload" href="/js/script.js" as="script" fetchpriority="low">
<script>
fetch('https://example.com/', {priority: 'low'})
	.then(data => {
		// Trigger a low priority fetch
	});
</script> The attribute is a hint and not a directive. The browser will try to respect the developer's preference. It is also possible that the browser will apply its preferences for resource priority as deemed necessary in case of conflicts. fetchpriority Effect on Largest Contentful Paint (LCP) You can specify to boost the priority of the LCP or other critical images. fetchpriority="high" <img src="lcp-image.jpg" fetchpriority="high"> Prefetch Resources to Speed Up Future Navigations With prefetch Adding to a web page tells the browser to download entire pages or some of the resources (like scripts or CSS files), that the user might need in the future. <link rel=prefetch> The hint consumes extra bytes for resources that are not immediately needed, so this technique needs to be applied thoughtfully; only prefetch resources when you are confident that users will need them. prefetch <link rel="prefetch" href="/articles/" as="document"> Effect on Largest Contentful Paint (LCP) Prefetching images can significantly lower LCP times for LCP image elements. Prefetching stylesheets can improve both FCP and LCP, as the network time to download the stylesheet will be eliminated. Since stylesheets are render-blocking, they can reduce LCP when prefetched. In cases where the subsequent page's LCP element is a CSS background image requested via the background-image property, the image will also be prefetched as a dependent resource of the prefetched stylesheet. Prefetching JavaScript will allow the processing of the prefetched script to occur much sooner than if it were required to be fetched by the network first during navigation. This can have an effect on responsiveness metrics such as and . First Input Delay (FID) Interaction to Next Paint (INP) In cases where markup is rendered on the client via JavaScript, LCP can be improved through reduced resource load delays, and client-side rendering of markup containing a page's LCP element can occur sooner. If you're using , you can apply prefetch to routes or components that are not immediately necessary but will likely be requested soon. code-splitting <link rel="prefetch" as="script" href="1.bundle.js">

import(/* webpackPrefetch: true */ 'Pages/Step1/Step2'); Preload Critical Assets to Improve the Loading Speed With preload By preloading a certain resource, you are telling the browser that you would like to fetch it sooner than the browser would otherwise discover it because you are certain that it is important for the current page. <link rel="preload" as="script" href="critical.js">

Link: </css/style.css>; rel="preload"; as="style" Supplying the attribute helps the browser set the priority of the prefetched resource according to its type, set the right headers, and determine whether the resource already exists in the cache. Accepted values for this attribute include: , , , , and . as script style font image others Pacifico font is defined in the stylesheet with a rule. The browser loads the font file only after it has finished downloading and parsing the stylesheet. @font-face Pacifico font is preloaded, so the download happens in parallel with the stylesheet. Fonts defined with @font-face rules or background images defined in CSS files aren't discovered until the browser downloads and parses those CSS files. Preloading these resources ensures they are fetched before the CSS files have been downloaded. Because browsers don't preloaded files, preloading is useful to separate fetching from execution which can improve metrics such as Time to Interactive. Preloading works best if you your JavaScript bundles and only preload critical chunks. execute split Largest Contentful Paint (LCP) Preloading has a powerful effect on when it comes to fonts and images, as both images and text nodes can be . Hero images and large runs of text that are rendered using web fonts can benefit significantly from a well-placed preload hint and should be used when there are opportunities to deliver these important bits of content to the user faster. Largest Contentful Paint (LCP) LCP candidates However, you want to be careful when it comes to preloading—and other optimizations! In particular, avoid preloading too many resources. If too many resources are prioritized, effectively none of them are. The effects of excessive preload hints will be especially detrimental to those on slower networks where bandwidth contention will be more evident. Use or to Execute the Code async defer JavaScript execution is parser blocking. This means when the browser encounters a script it must pause DOM construction, hand this over to the JavaScript engine, and allow script execution before proceeding with DOM construction. The and attributes tell the browser that it may go on parsing the HTML while loading the script in the background, and then execute the script after it loads. This way, script downloads don't block DOM construction and page rendering. The result is that the user can see the page before all scripts have finished loading. async defer <script async src="script.js">
<script defer src="script.js"> The async and defer attributes change this behavior. With , the browser downloads the script asynchronously while it continues to parse the HTML document. When the script finishes downloading, parsing is blocked while the script executes. async With , the browser downloads the script asynchronously while it continues to parse the HTML document. The script doesn't run until the parsing is complete. defer Largest Contentful Paint (LCP) and First Contentful Paint (FCP) Proper configuration of high and low-priority scripts can give more sources to the parser to render the HTML while some of the scripts are being loaded as third-party scripts will not block the parser. And the browser is able to render the page as soon as possible.

Enhancing Web Performance: Strategies for Efficient Resource Fetching and Prioritization

Running all regression tests all the time can be impractical and inefficient and represent a paradigm shift in software development, promoting collaboration, automation, and a continuous feedback loop. These practices are instrumental in meeting the demands of a dynamic and competitive market, allowing organizations to deliver high-quality software quickly and efficiently. DevOps continuous deployment In this context, has undergone a transformation to align with the accelerated pace of development methodologies, emphasizing the roles of test automation and continuous testing practices. However, with the increasing complexity of applications, the number of automated tests tends to grow exponentially. This growth results in prolonged execution times even for automated tests, sometimes spanning hours or days, contradicting modern development practices that prioritize quick feedback loops. software testing This presents a unique challenge for testing teams: the necessity to due to resource constraints and time limitations. The sheer volume of tests can lead to a tipping point where it becomes impractical to execute every test in every regression cycle. strategically select and prioritize tests The team is then confronted with the critical task of , employing some type of prioritization criteria, and continually maintaining and updating the test suite to ensure relevance and effectiveness within the context of the adopted criteria. identifying and focusing on high-priority test cases Strategies for selecting and prioritizing test cases Considering the trade-offs between and more focused , the crucial challenge is to methodically select and prioritize test cases within the test suite, aiming to strike a delicate balance between comprehensive coverage and the effectiveness of the testing process while being mindful of resource limitations. comprehensive automated regression testing partial regression In the list below, you'll discover various methods to prioritize test cases, all intended to strike a balance between comprehensive coverage and reducing execution time. Keep in mind that this list is not exhaustive: In this article, our goal is to examine . By merging these approaches, testing teams can devise a prioritized test plan, optimizing the efficacy of their testing efforts and enhancing the overall quality of the application under test. how the integration of business impact and frequency of use methods can lead to a more comprehensive approach to test prioritization Combining the business impact and frequency of use to prioritize test cases Often, teams find themselves struggling with the challenge of quantifying the business impact and frequency of use, resorting to an intuitive and subjective approach. To elevate confidence levels, it becomes imperative for teams to transition towards a more formalized methodology. This involves the that integrates both the business impact and frequency of use for the application's functionality. This formalized approach empowers teams to prioritize test cases more effectively based on these crucial factors, minimizing reliance on guesswork. development of a systematic scoring system Here's a step-by-step guide to prioritize tests using these factors: Review the business requirements and features of your application or system. Identify those with the most substantial impact on business operations, customer satisfaction, or revenue. Identify critical business requirements and features: Analyze usage data or gather stakeholder feedback to pinpoint the most frequently used features or functionalities in production. Assess frequency of use: Develop a matrix that blends both business impact and frequency of use factors. Assign weights or scores based on their relative importance to your company. Create a prioritization matrix: Map your test cases to the corresponding requirements or features. Calculate a priority score for each test case by combining the scores or weights assigned to the business impact and frequency of use factors. Prioritize test cases: By following this approach, you can focus your testing efforts on the most business-critical and frequently used aspects of your application or system while ensuring a well-rounded test coverage. Gravity: Applying AI for test case prioritization introduces an test case weighting & scoring engine that helps optimize existing test suites by prioritizing test cases based on the business impact and frequency of use in the tested pages and flows covered by these test cases. This enables a , focusing test coverage on high-impact areas that directly affect the end-user experience. Gravity AI-powered data-driven test case prioritization It seamlessly correlates multiple dimensions, including test coverage, business impact, and frequency of use. This enables the generation of easily understandable reports and insights, empowering testing teams to prioritize tests based on concrete data rather than relying on guesswork. Gravity's ability to by processing the ingested data through machine learning algorithms. This involves translating raw data into meaningful insights using techniques such as pattern recognition, trend and correlation analysis, anomaly and outlier detection, and more. monitor usage within the production and testing environments allows it to generate comprehensive quality analytics It highlights information that allows testing teams to , pinpoint features that may be either over-tested or under-tested, and recognize redundant testing efforts in less critical areas. identify gaps in coverage If you want to learn more about Gravity, you can book a demo here: Book a demo Conclusion Embracing a focused and selective is crucial for optimizing testing resources, accelerating time-to-market, and elevating overall software quality. By directing efforts toward high-risk areas of the application, testing teams can ensure the early discovery of critical issues. test case prioritization approach Additionally, the adoption of a formalized scoring system for provides a considerable benefit for testing teams. This systematic method represents a significant improvement over relying solely on subjective opinions and the experiences of others. By employing a more , testing teams can significantly enhance their testing practices, ensuring a more rigorous and effective approach to identifying and addressing critical issues. prioritizing relevant test cases objective and data-driven methodology Author: Cristiano Caetano Head of Growth at Smartesting Software testing authority with two decades of expertise in the field. Brazilian native who has called London home for the past six years. I am the proud founder of Zephyr Scale, the leading Test Management application in the Atlassian ecosystem. Over the last ten years, my role has been pivotal in guiding testing companies to build and launch innovative testing tools into the market. Currently, I hold the position of Head of Growth at Smartesting, a testing company committed to the development of AI-powered testing tools.

Turbocharge Regression Testing: Prioritizing Test Cases Like a Pro with AI

টার্বোচার্জ রিগ্রেশন টেস্টিং: এআই সহ প্রো-এর মতো পরীক্ষার ক্ষেত্রে অগ্রাধিকার দেওয়া

Turbocharge-Regressionstests: Testfälle priorisieren wie ein Profi mit KI

Pruebas de regresión de turbocompresor: priorizar casos de prueba como un profesional con IA

Tests de régression Turbocharge : prioriser les cas de test comme un pro avec l'IA

टर्बोचार्ज रिग्रेशन परीक्षण: एआई के साथ एक पेशेवर की तरह परीक्षण मामलों को प्राथमिकता देना

ターボチャージ回帰テスト: AI を使用してプロのようにテスト ケースに優先順位を付ける

터보차지 회귀 테스트: AI를 사용해 전문가처럼 테스트 사례 우선순위 지정

Teste de regressão turbocharge: priorizando casos de teste como um profissional com IA

Регрессионное тестирование с турбонаддувом: расстановка приоритетов тестовых случаев с помощью искусственного интеллекта как профессионал

Turboşarj Regresyon Testi: Yapay Zeka ile Bir Profesyonel Gibi Test Durumlarına Öncelik Verme

Thử nghiệm hồi quy tăng áp: Ưu tiên các trường hợp thử nghiệm như một chuyên gia với AI

涡轮增压回归测试：像人工智能专家一样确定测试用例的优先级

Remarks of Principal Deputy U.S. Chief Technology Officer Deirdre K. Mulligan at the Public Interest Technology University Network Convening Thank you for having me here today. It’s great to be back with this group. I’ve spent my career in the public interest technology field. While I’m a lawyer by training, throughout my career in civil society, academia, and now in the federal government, I’ve collaborated with technologists, computer and data scientists, and social scientists who consider both the design and regulation of technical systems as essential to protecting democratic values and human rights, as well as our safety and security. Today, I have the privilege of serving as Principal Deputy U.S. Chief Technology Officer in the White House Office of Science and Technology Policy, or OSTP. At OSTP, a team of folks who embody the ethos of public interest technology work to maximize the benefits of science and technology to advance health, prosperity, security, environmental quality, and justice for all Americans. We carry out this mission by advising the President and White House senior staff on key issues related to science and technology, and by coordinating federal government technology policy and priorities. Our nation has immense aspirations: to achieve robust health and ample opportunity for each person in every community; to overcome the climate crisis by reimagining our infrastructure, restoring our relationship with nature, and securing environmental justice; to sustain global security and stability; to build a competitive economy that creates good-paying jobs; and to foster a strong, resilient, and thriving democracy. Technology plays a vital role in achieving each of these goals. Today, I’d like to do three things. First, I’ll tell you a bit about what the Biden-Harris Administration is doing to ensure AI and other technology is developed and implemented in ways that support democratic values and human rights as well as the public’s safety and security. Second, I’ll describe how we’re making it easier for members of the public interest technology field to serve in the federal government. And third, I’ll set out the vital role that universities play in shaping the future of the public interest technology field in government. President Biden and all of us in the Biden-Harris Administration are committed to using technology and data to support the public interest: ensuring technology works for every member of the public, protects our safety and security, and reflects and protects democratic values and human rights. While you might not read executive orders and federal regulations word for word—if you do, you’ll see this commitment threaded throughout the Administration’s actions. For example, on his first day in office, the President signed an executive order establishing a working group on equitable data focused on using data to evaluate and align federal programs and policies to ensure they are serving all Americans. In December 2021, the President signed an executive order directing the federal government to modernize and improve service delivery, and specifically, to leverage technology solutions to do so. In May 2022, the President signed an executive order directing the federal government to assess how data can inform equitable and effective policing, as well as identify privacy, civil rights, and civil liberties concerns related to the use of technology, including facial recognition and predictive algorithms. And this summer, the Department of Justice proposed a new rule that would establish accessibility standards for state and local governments’ web and mobile app-based services, which would help advance equal access to key programs and services for people with disabilities. This is only a sampling of key activities we are taking to make sure technology works for all Americans and supports democratic values and institutions. And then, of course, there is the Administration’s efforts to ensure we can use AI to tackle society’s most challenging problems and do so in a way that protects safety, security, equity, and civil rights. AI is one of the most powerful technologies of our times, and AI systems are increasingly touching every aspect of our lives. These systems have brought benefits across a wide range of domains: from detecting cancer earlier to improving agricultural yield to helping small business owners cut costs. Advances in AI can supercharge progress, making life better for everyone and helping to meet our greatest challenges. At the same time, as President Biden has said, to seize the benefits of AI, we must first manage its risks. It seems like every day we read another story, or another study, or hear from another person whose life has been negatively impacted by AI: high-quality images and text are being used to deceive consumers; more and more sensitive information is being used to train AI systems like facial recognition, which is further eroding privacy; and the harms of AI are being disproportionately felt by already underserved communities, such as how AI is being used to create and distribute non-consensual intimate images of women and girls. These systems are having dramatic impacts on Americans’ lives—putting our rights, our safety, and our security at risk. Since the start, this Administration has been working to ensure that AI is developed and used to bolster the public interest. In order to do that, we have been clear about our values and how they should be embedded into the systems that are influencing our daily lives. Just over a year ago—after hearing from hundreds of people across the United States and beyond—OSTP released the as a guide for how to leverage AI technologies in ways that reinforce our highest values, and help protect society from AI’s risks. Blueprint for an AI Bill of Rights Since then, President Biden issued an executive order directing agencies to root out bias in AI and to seek opportunities to involve civil rights experts within government in decisions about technology. The President, Vice President, and senior Administration leaders have continued meeting with experts, researchers, and civil society leaders to discuss risks from AI. The White House announced that leading AI companies would provide their AI systems for the first-ever public “red teaming” assessment, which was held at the DEF CON cybersecurity conference and included assessments of these AI systems against the broad range of risks outlined in the Blueprint for an AI Bill of Rights. This summer, President Biden secured voluntary commitments from 15 leading AI companies to follow a series of practices to limit risks to safety, security, and trust—helping to create a bridge to regulation for this fast-moving technology. And we’re not done yet. We are currently developing an executive order on AI and we will pursue bipartisan legislation to help America lead the way in responsible innovation in AI. The Office of Management and Budget will issue guidance for how federal agencies can leverage AI responsibly. The U.S. government has to lead by example—to harness the benefits of AI for the American public, we must establish what it means to responsibly and develop tech, and we must show how it can be done. Our ability to meet this moment depends on you. The federal government—all branches and levels of government—need the folks in this room. We can’t use AI to benefit the public, or regulate the AI marketplace to protect against risks without people with your talent and passion. That’s why we’re making it easier for the students and academics in this room to join us. The Office of Personnel Management is making it easier for agencies to quickly hire technical talent such as data scientists. Programs stood up in the Obama-Biden Administration like the Presidential Innovation Fellowship and the U.S. Digital Service continue to bring technical talent into the federal government. And programs launched by the Biden-Harris Administration, such as the U.S. Digital Corps, are now bringing on early-career technologists—something that might be of particular interest to the PIT-UN community. And there are also external fellowships that place technologists in federal agencies and the halls of Congress. Additionally, with the unprecedented investments coming into American communities through the Investing in America agenda, now is a great time for public interest technologists to serve in state and local government and local nonprofits to help deliver to those who need it the most. And as we recruit, we’re looking for individuals with the mix of technical and policy expertise that the public interest tech field cultivates. We need interdisciplinary teams that can apply AI to key problems and grapple with the societal impacts of AI. As you all know, we need technologists, social scientists, lawyers, ethicists, and others to build AI and to design the tools, methods, and regulations to ensure AI embeds our values and protects our rights. I thought sharing the Technology team’s mission statement would give you a strong sense of our alignment with this movement and how wide-open OSTP’s doors are to you, your ideas, and your work. We strive for: A world that uses technology and data to advance and protect civil rights and civil liberties, equity and accessibility, and democratic values along with economic prosperity, scientific progress, and national security. A world in which technologists, data scientists, and social scientists are partners in establishing and implementing public policy. It will take all of us to get this right. This brings me to the last point I want to stress today. Universities have a vital role to play in advancing public interest technology. You all know that—that’s why you’re here today. But I want to drill down on two specific ways that you can keep making progress here. First, you can create the multidisciplinary opportunities that allow students and faculty to grapple with these challenging problems in all their real-world messiness. From academic centers that cross multiple disciplines, to classes that bring together perspectives from different backgrounds, this group is already pushing the frontiers of interdisciplinary and experiential learning. From cybersecurity clinics, to interdisciplinary colloquium and courses, to capstone experiences in local government, these opportunities are necessary to cultivate the knowledge and skills of the next generation of public interest tech field. I urge you all to do more of this type of work. Second, you all can make it possible for folks from all walks of life to join the public interest technology field. Universities can do more to support faculty, students, and graduates joining the public interest technology field. Support can take many forms, including funding to support faculty stints of government service that bring needed expertise into government and bring public service and public value-oriented questions back into academic research; loan forgiveness and fellowships that ensure diverse graduates can pursue careers in government; externships and internships, co-ops, capstone programs, and clinics that expose students to public interest tech career opportunities, and expose all levels of government to the value of having members of the public interest field in their shops. My team and I are happy to chat with anyone who has started a program or is contemplating one that would grow the public interest tech field in government. And we’re happy to chat with those who are looking to grow the capacity needed in civil society organizations as well—these organizations also need your talent, and will benefit from loan forgiveness, fellowships, and tours of service. You all are vital partners in this work. The Administration looks forward to working with you and with students and academics across the country to leverage technology to create a better future for us all. We are at a pivotal moment, where everyone around the globe recognizes the importance of not only regulating but also proactively shaping and building and using technology to support our values. There could not be a better time to work in public interest technology. I look forward to working with you all to build the vision and workforce to seize the opportunities and manage the risks of AI. This content was originally published on October 13, 2023 in whitehouse.gov.

Deputy CTO Deirdre K. Mulligan Discusses Biden Administration's Tech Priorities

As many professionals reflect upon their workflow and try to identify opportunities for enhancement, it becomes more and more obvious that in all processes, including product management, prioritization can be the growth point. Poor prioritization can manifest in seemingly minor inconveniences, such as attempting to fit an excessive amount of work into a constrained timeframe – a predicament familiar to us all. Nevertheless, when these challenges persist consistently, the cumulative effect transforms these minor stresses into significant obstacles, resulting in the creation of subpar products and an immense waste of valuable time. The question then arises: how can one address prioritization challenges proactively, preventing them from evolving into significant hurdles? In this article, we'll explore proven prioritization techniques that can help product managers and teams make informed decisions. Each method offers unique insights into product development. The MoSCoW method sorts features into must-haves and nice-to-haves. The Kano Model focuses on customer satisfaction. The Eisenhower Matrix balances urgency and importance. These methods together form a toolkit helping product teams handle challenges, allocate resources wisely, and create products that connect with their audience. 1.MoSCoW Method The MoSCoW method was proposed by of Oracle UK Consulting in the mid-1990s. It is an efficient way to sort tasks into critical and non-critical categories. Dai Clegg The MoSCoW acronym stands for: These are the essential features or requirements without which the project or product would be considered a failure. They represent the core functionality that must be delivered for the project to be successful. Must-haves (M): These are important features that are not critical for the project's success but would significantly enhance its value. They are prioritized after addressing the must-haves. Should-haves (S): These are nice-to-have features that are desirable but not necessary for the project's success. They are typically considered after addressing must-haves and should-haves. Could-haves (C): These tasks are desirable (for example, "Would like to have…") but aren't included in this project. You can also use this category for the least critical activities. Won't-haves or Would-haves (W): Example of the MoSCoW Method Imagine we are developing a new e-commerce website, so we will have the following prioritization list: ecure online payment system, product listing and search functionality, user registration, and authentication. Must-haves (M): S Customer reviews and ratings, integration with social media for sharing products, wishlist functionality. Should-haves (S): Loyalty program for frequent customers, real-time customer support chat, advanced search filters. Could-haves (C): Augmented reality features for virtual product try-on (considered too complex for the initial release), cryptocurrency payment options (considered a low priority at the moment). Won't-haves (W): By categorizing features into these four groups, the project team can ensure that they focus on the most critical elements first. We also get a clear understanding of what must be delivered and what can be considered as additional enhancements. This helps in managing stakeholder expectations and resources effectively throughout the project lifecycle. Additionally, the MoSCoW method allows for flexibility in adapting to changing project requirements and priorities. 2. The Kano Model The Kano Model, developed by , is a framework for understanding and prioritizing customer needs and expectations in product development. It categorizes features into three main types: The model helps product teams identify which features will lead to increased customer satisfaction. Professor Noriaki Kano Basic Needs, Performance Needs, and Excitement Needs. Basic needs are fundamental requirements that, when met, do not necessarily increase customer satisfaction but can cause dissatisfaction if not fulfilled. Basic Needs: Performance needs are features where the level of satisfaction is directly proportional to the degree of fulfillment. Meeting or exceeding expectations in these areas can positively impact satisfaction. Performance Needs: Excitement needs are unexpected or innovative features that can significantly boost customer satisfaction when present but don't cause dissatisfaction if absent since customers don't expect them. Excitement Needs (Delighters): Example of the Kano Model This time let us take the process of a Fitness App development. Our is to accurately track steps and calories burned. Users expect the app to provide reliable data; if it consistently fails to do so, dissatisfaction will occur. Basic Need The will be a personalized workout recommendation based on user preferences and goals. As the app tailors workout suggestions more accurately, user satisfaction increases. Performance Need The last one is the — gamification features. It can be virtual rewards or challenges. These elements aren't necessary for the core functionality, but they can significantly enhance the user experience and satisfaction when present. Excitement need After completing the five-step method and having a prioritized list of features, you can enhance your planning by creating a benefit and cost model for each feature. This step allows you to identify features that, if implemented, could yield a substantial return on investment through increased sales. This insight becomes particularly valuable in guiding your product development cycle, especially when facing constraints in time and financial resources. 3. The Eisenhower Matrix The Eisenhower Matrix, also known as the Urgent-Important Matrix, is a productivity and prioritization tool named after former U.S. President Dwight D. Eisenhower, who famously said, "I have two kinds of problems: the urgent and the important. The urgent are not important, and the important are never urgent." The matrix categorizes tasks into four quadrants based on their urgency and importance: Tasks that are both urgent and important are given the highest priority and should be tackled immediately. These are critical tasks that have a significant impact on the project or product. Urgent and Important (Do First): Tasks in this quadrant are important for long-term goals but are not time-sensitive. They should be scheduled and planned so that they do not tend to become urgent in the future. Important, Not Urgent (Schedule): Tasks that are urgent but not important can be delegated to others if possible. They may not directly contribute to the project's success but still need attention. Urgent, Not Important (Delegate): Tasks in this quadrant are neither urgent nor important and can be postponed or eliminated. They do not contribute significantly to the project's success. Not Urgent and Not Important (Eliminate or Postpone): Example of the Eisenhower Matrix Let's say a product manager is working on software for a customer relationship management (CRM) system. Here's how they might apply the Eisenhower Matrix to prioritize product requirements: The CRM system has a critical security vulnerability that needs immediate attention to protect customer data. This becomes the top priority for the development team. Urgent and Important (Do First): Enhancing the user interface for a more intuitive user experience is important for customer satisfaction but not immediately urgent. The product manager schedules this task for the next development sprint. Important, Not Urgent (Schedule): A minor bug in a less critical feature has been identified. The product manager delegates this task to a junior developer while they focus on more critical issues. Urgent, Not Important (Delegate): A proposed feature that would add a decorative element to the user interface but doesn't contribute significantly to functionality is deemed not urgent and not important. Not Urgent and Not Important (Eliminate or Postpone): The product manager decides to postpone this feature until more critical tasks are addressed. As can be seen, the Eisenhower Matrix is a simple tool for considering the long-term outcomes of your tasks and focusing on what will make the project most effective. It helps to visualize all the acute tasks in a matrix of urgent/important and provides that all tasks of a bigger project will fall into one of the above-mentioned four quadrants. RICE Method The RICE scoring method is a prioritization framework used to rank and prioritize features or tasks based on their potential impact. The acronym "RICE" stands for Each of these factors is assigned a numerical score, and the total score is used to determine the priority of a particular item. Reach, Impact, Confidence, and Effort. Here's a breakdown of each component of the RICE method: Reach measures the number of users or customers who will be affected by the feature or task. It quantifies the potential audience impacted by the implementation. Reach: Assign a numerical value from 1 to 10, with 1 being a low reach and 10 being a high reach. For example, if a feature affects all users, it might receive a score of 10. Scoring: Impact assesses the potential positive effect or benefit of implementing the feature or task. It quantifies the level of positive change or improvement. Impact: Similar to reach, assign a numerical value from 1 to 10. A feature that significantly improves user engagement or key performance indicators might receive a high impact score. Scoring: Confidence reflects the level of certainty or confidence the team has in the estimates for reach, impact, and effort. It accounts for the level of uncertainty associated with the prioritization. Confidence: Assign a percentage score from 1% to 100%. A feature with high confidence in the estimates might receive a score of 90%, while a more uncertain estimate might get a lower score, such as 50%. Scoring: Effort measures the resources, time, and complexity required to implement the feature or task. It quantifies the cost or effort associated with the implementation. Effort: Similar to reach and impact, assign a numerical value from 1 to 10, with 1 being low effort and 10 being high effort. A straightforward task might receive a low effort score, while a complex feature might receive a high effort score. Scoring: The RICE score is calculated using the formula: (Reach x Impact x Confidence) / Effort. Example of the RICE Method: Now, we will try to prioritize features for an imaginable Mobile App using the RICE method. Let us compare Feature A and Feature B. Conclusion Each method in this compilation serves a common purpose: guaranteeing that your focus is consistently on the most crucial tasks. Ultimately, the specific technique chosen becomes secondary. Whether you opt for a single method, combine various techniques, or even customize your approach by integrating aspects from different methods, the key is to choose an approach that resonates with your workflow and fits your product the most. The paramount factor is taking action and initiating the work based on a method that aligns with your team's preferences and work style.

Mastering Prioritization: Strategies for Effective Product Management

The United States v Meta Platforms Court Filing October 24, 2023 is part of . You can jump to any part in this filing . This is part 88 of 100. HackerNoon’s Legal PDF Series here COUNT XLIII: VIOLATIONS OF OHIO CONSUMER SALES PRACTICES ACT – UNCONSCIONABLE CONSUMER SALES ACTS OR PRACTICES - OHIO REVISED CODE §1345.03 1101. Ohio realleges and incorporates herein by reference each of the allegations contained in the preceding paragraphs 1 through 850 as though fully alleged in this cause of action. 1102. Meta knowingly designed platforms that ignored the damaging effect said platforms have on young users’ psychological vulnerabilities. Meta made immoral, unethical, oppressive and unscrupulous decisions that prioritized Meta’s financial gain at the expense of its young users’ mental health. 1103. Meta’s conduct, acts or omissions, as described herein, constitute unconscionable acts and practices in violation of the CSPA, O.R.C. 1345.03(A). 1104. Each unconscionable act or practice engaged in by Meta as recited above constitutes a separate violation of the CSPA. 1105. The acts or practices described above have been previously determined by Ohio courts to violate the CSPA, Ohio Rev. Code §1345.01, et seq. Meta committed said violations after such decisions were made available for public inspection pursuant to Ohio Rev. Code §1345.05(A)(3). Continue Reading . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case 4:23-cv-05448 retrieved on October 25, 2023, from is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. Washingtonpost.com

Ohio Blasts Meta for Prioritizing Financial Gain Over Young Users' Mental Health 

is an API Gateway, which builds upon the reverse-proxy to offer a plugin-based architecture. The main benefit of such an architecture is that it brings structure to the configuration of routes. It’s a help at scale, when managing hundreds or thousands of routes. Apache APISIX OpenResty In this post, I’d like to describe how plugins, priority, and phases play together and what pitfalls you must be aware of. APISIX plugin’s priority When you configure a route with multiple plugins, Apache APISIX needs to execute them in a order so that the results are the same over time. For this reason, every APISIX plugin has a . You can check a plugin priority directly in the code. For example, here’s the relevant code fragment for the plugin: consistent hardcoded priority basic-auth local _M = {
    version = 0.1,
    priority = 2520,                                 #1
    type = 'auth',
    name = plugin_name,
    schema = schema,
    consumer_schema = consumer_schema
} Priority is 2520 For documentation purposes, the file lists the priority of all out-of-the-box plugins. Here’s an excerpt: default-config.yaml plugins:
  - ldap-auth                      # priority: 2540
  - hmac-auth                      # priority: 2530
  - basic-auth                     # priority: 2520
  - jwt-auth                       # priority: 2510
  - key-auth                       # priority: 2500
  - consumer-restriction           # priority: 2400
  - forward-auth                   # priority: 2002
  - opa                            # priority: 2001
  - authz-keycloak                 # priority: 2000
  #- error-log-logger              # priority: 1091
  - proxy-cache                    # priority: 1085
  - body-transformer               # priority: 1080
  - proxy-mirror                   # priority: 1010
  - proxy-rewrite                  # priority: 1008
  - workflow                        # priority: 1006
  - api-breaker                    # priority: 1005
  - limit-conn                     # priority: 1003
  - limit-count                    # priority: 1002
  - limit-req                      # priority: 1001 Imagine a route configured with and . Because of their respective priority, would run before . proxy-mirror proxy-rewrite proxy-mirror proxy-rewrite upstream:
  - id: 1
    nodes:
      "oldapi:8081": 1

routes:
  - id: 1
    uri: "/v1/hello*"
    upstream_id: 1
    plugins:
      proxy-rewrite:                                 #1-3
        regex_uri: ["/v1(.*)", "$1"]
      proxy-mirror:                                  #2
        host: http://new.api:8082 The plugin ordering in this file is not relevant has priority 1010 and will execute first proxy-mirror has priority 1008 and will run second proxy-rewrite The above setup has an issue. For example, if we call , APISIX will first mirror the request, and then remove the prefix. Hence, the new API receives instead of . It’s possible to override the default priority to fix it: localhost:9080/v1/hello /v1 /v1/hello /hello routes:
  - id: 1
    uri: "/v1/hello*"
    upstream_id: 1
    plugins:
      proxy-rewrite:
        _meta:
          priority: 1020                             #1
        regex_uri: ["/v1(.*)", "$1"]
      proxy-mirror:
        host: http://new.api:8082 Override the default priority Now, has higher priority than : the former runs before the latter. proxy-rewrite proxy-mirror In this case, it works flawlessly; in others, it might not. Let’s dive further. APISIX phases APISIX runs plugins not only according to their priorities but also through dedicated phases. Because APISIX builds upon OpenResty, which builds upon ngxinx, the phases are very similar to the phases of these two components. nginx defines several an HTTP request goes through: phases NGX_HTTP_POST_READ_PHASE NGX_HTTP_SERVER_REWRITE_PHASE NGX_HTTP_FIND_CONFIG_PHASE NGX_HTTP_REWRITE_PHASE NGX_HTTP_POST_REWRITE_PHASE NGX_HTTP_PREACCESS_PHASE NGX_HTTP_ACCESS_PHASE NGX_HTTP_POST_ACCESS_PHASE NGX_HTTP_PRECONTENT_PHASE NGX_HTTP_CONTENT_PHASE NGX_HTTP_LOG_PHASE Each phase focuses on a task, , verifies that the client is authorized to make the request. i.e. NGX_HTTP_ACCESS_PHASE In turn, OpenResty offers similarly named phases. From nginx documentation: Finally, here are the phases of Apache APISIX: rewrite access before_proxy header_filter body_filter log We have seen two ways to order plugins: and Now comes the most important rule: ! by priority by phase. order by priority only works inside a phase For example, the plugin has a priority of 900 and runs in phase ; the plugin has a priority of 995 and runs in phase . Regardless of their respective priorities, will happen before , because happens before . Likewise, changing a priority won’t "move" a plugin out of its phase. redirect rewrite gzip body_filter redirect gzip rewrite body_filter The example above with and worked because both run in the phase. proxy-mirror proxy-rewrite rewrite The main issue is that priority is documented in the file, while the phase is buried in the code. Worse, some plugins run across different phases. For example, let’s check the proxy plugin and, more precisely, the functions defined there: config-default.yaml proxy-rewrite local function is_new_headers_conf(headers) local function check_set_headers(headers) function _M.check_schema(conf) function _M.rewrite(conf, ctx) The name of the function is suspiciously similar to one of the phases above. Looking at other plugins, we see the same pattern repeat. Apache APISIX runs plugin functions with the same name as the phase. rewrite() I took the liberty of summarizing all plugins and their respective phases in a table. +----------------------+---------+--------+-------------+--------------+------------+-----+
| Plugin               | Phase                                                            |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| General              | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| redirect             | X       |        |             |              |            |     |
| echo                 |         |        |             | X            | X          |     |
| gzip                 |         |        |             | X            |            |     |
| real-ip              | X       |        |             |              |            |     |
| ext-plugin-pre-req   | X       |        |             |              |            |     |
| ext-plugin-post-req  |         | X      |             |              |            |     |
| ext-plugin-post-resp |         |        | X           |              |            |     |
| workflow             |         | X      |             |              |            |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Transformation       | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| response-rewrite     |         |        |             | X            | X          |     |
| proxy-rewrite        | X       |        |             |              |            |     |
| grpc-transcode       |         | X      |             | X            | X          |     |
| grpc-web             |         | X      |             | X            | X          |     |
| fault-injection      | X       |        |             |              |            |     |
| mocking              |         | X      |             |              |            |     |
| degraphql            |         | X      |             |              |            |     |
| body-transformer     | X       |        |             | X            | X          |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Authentication       | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| key-auth             | X       |        |             |              |            |     |
| jwt-auth             | X       |        |             |              |            |     |
| basic-auth           | X       |        |             |              |            |     |
| authz-keycloak       |         | X      |             |              |            |     |
| authz-casdoor        |         | X      |             |              |            |     |
| wolf-rbac            | X       |        |             |              |            |     |
| openid-connect       | X       |        |             |              |            |     |
| cas-auth             |         | X      |             |              |            |     |
| hmac-auth            | X       |        |             |              |            |     |
| authz-casbin         | X       |        |             |              |            |     |
| ldap-auth            | X       |        |             |              |            |     |
| opa                  |         | X      |             |              |            |     |
| forward-auth         |         | X      |             |              |            |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Security             | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| cors                 | X       |        |             | X            |            |     |
| uri-blocker          | X       |        |             |              |            |     |
| ua-restriction       |         | X      |             |              |            |     |
| referer-restriction  |         | X      |             |              |            |     |
| consumer-restriction |         | X      |             |              |            |     |
| csrf                 |         | X      |             | X            |            |     |
| public-api           |         | X      |             |              |            |     |
| chaitin-waf          |         | X      |             |              |            |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Traffic              | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| limit-req            |         | X      |             |              |            |     |
| limit-conn           |         | X      |             |              |            | X   |
| limit-count          |         | X      |             |              |            |     |
| proxy-cache (init)   |         | X      |             | X            | X          |     |
| proxy-cache (disk)   |         | X      |             | X            |            |     |
| proxy-cache (memory) |         | X      |             | X            | X          |     |
| request-validation   | X       |        |             |              |            |     |
| proxy-mirror         | X       |        |             |              |            |     |
| api-breaker          |         | X      |             |              |            | X   |
| traffic-split        |         | X      |             |              |            |     |
| request-id           | X       |        |             | X            |            |     |
| proxy-control        | X       |        |             |              |            |     |
| client-control       | X       |        |             |              |            |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Observability        | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| zipkin               | X       | X      |             | X            |            | X   |
| skywalking           | X       |        |             |              |            | X   |
| opentelemetry        | X       |        |             |              |            | X   |
| prometheus           |         |        |             |              |            |     |
| node-status          |         |        |             |              |            |     |
| datadog              |         |        |             |              |            | X   |
| http-logger          |         |        |             |              | X          | X   |
| skywalking-logger    |         |        |             |              |            | X   |
| tcp-logger           |         |        |             |              |            | X   |
| kafka-logger         |         |        |             |              | X          | X   |
| rocketmq-logger      |         |        |             |              | X          | X   |
| udp-logger           |         |        |             |              |            | X   |
| clickhouse-logger    |         |        |             |              | X          | X   |
| syslog               |         |        |             |              |            | X   |
| log-rotate           |         |        |             |              |            |     |
| error-log-logger     |         |        |             |              |            |     |
| sls-logger           |         |        |             |              |            | X   |
| google-cloud-logging |         |        |             |              |            | X   |
| splunk-hec-logging   |         |        |             |              |            | X   |
| file-logger          |         |        |             |              | X          | X   |
| loggly               |         |        |             |              | X          | X   |
| elasticsearch-logger |         |        |             |              |            | X   |
| tencent-cloud-cls    |         | X      |             |              | X          | X   |
| loki-logger          |         |        |             |              | X          | X   |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| Others               | rewrite | access | beforeproxy | headerfilter | bodyfilter | log |
+----------------------+---------+--------+-------------+--------------+------------+-----+
| serverless           |         | X      |             |              |            |     |
| openwhisk            |         | X      |             |              |            |     |
| dubbo-proxy          |         | X      |             |              |            |     |
| kafka-proxy          |         | X      |             |              |            |     |
+----------------------+---------+--------+-------------+--------------+------------+-----+ Conclusion I’ve detailed Apache APISIX plugin phases and priorities in this post. I’ve explained their relationship with one another. Icing on the cake, I documented each out-of-the-box plugin’s phase(s). I hope it will prove helpful. To go further: Default plugin priorities Apache APISIX plugin execution lifecycle Plugin execution code Originally published at , on December 10th, 2023 A Java Geek

Navigating Apache APISIX: A Strategic Approach to Plugin Priorities and Execution Phases

As the global startup investment slowdown begins to show signs of turning around, Southeast Asia’s startup ecosystem should prepare for a new fundraising landscape. A new report released this month by , Bain & Co, and Temasek, an investment firm owned by the government of Singapore, that investment into digital companies in Southeast Asia had reached its lowest level in six years. Google revealed Factors, including the global investment slowdown following the high-profile collapse of US-based , have played a role. In March, just after the bank’s implosion. Silicon Valley Bank Singapore Monetary Authority Chief Fintech Officer Sopnendu Mohanty , “Accessing capital will be the single biggest challenge” facing startups in the short term. said However, as the dark cloud that has hung over markets for the past year begins to of clearing, and the coffers of regional and global investors fill once more, Southeast Asia is poised as a region ripe for investment. Founders, though, should be aware of the changing fundraising landscape. show signs Founders should be laser-focused on profitability I have worked with Asian companies and governments for over a quarter century, organizing summits attended by heads of state, captains of industry, and entrepreneurs — most recently, the Horasis Asia Meeting being held in Binh Duong, Vietnam on December 3-4. My familiarity with the region gives me every confidence that Asian entrepreneurs will be able to emerge from the so-called “funding winter.” The region embraces a business culture of maximizing efficiency and profit — a mindset that will serve technology entrepreneurs courting tight-fisted investors who are increasingly worried about profitability over valuation. According to , Asian organizations have “pioneered many of the approaches that define world-class business practices today, from lean manufacturing to global business services.” McKinsey & Company Even as VC firms such as and are closing new, multi-million dollar funds for Southeast Asian startups, founders should be prepared to show a clear path to profitability and exit. During an investor conference in September, a general partner at Singapore-based Qualgro that the firm “passed one investment where founders were very good, the market was great … but we couldn’t see where the exit would be.” 500 Global Vertex told the audience Startups should keep sustainability at heart In recent years, some Southeast Asian countries have emerged as bright spots in the push toward sustainability. In 2021 Vietnam, a nation of just 97 million, became the world’s producer of solar power, and in August, Vietnamese electric vehicle (EV) company VinFast was than Ford and General Motors when it debuted on the NYSE. tenth-largest trading higher It is imperative that the next generation of startup unicorns coming out of the region keep sustainability at heart. Not only will this keep Southeast Asian countries on track to hit their goal of net-zero emissions by 2050, but it’s also likely to give them a leading edge in the current investor climate. While some startup sectors lagged during Q3 2023, late-stage companies in select industries such as semiconductors, AI, EVs and sustainability, received larger investments, according to from Crunchbase. And last year, global public and private investment into green energy hit $1 trillion for the first time, up from $32 billion in 2004, to BloombergNEF data. data according A recent of digital economy companies across Southeast Asia showed that while 85% of respondents showed interest in sustainability, less than 50% had actually implemented sustainable practices in their organizations. Startups must go beyond intention and act on sustainability practices, or risk being left behind in the global funding push towards sustainability. survey An end to the current global funding drought will come sooner than later, and Asian startups must remain poised to hit the ground running when the investment tides shift. *, Chairman, Horasis.* - Frank-Jürgen Richter Originally published on The Tech Panda.

Charting a Course: Strategic Priorities for Southeast Asian Startups in the Face of Funding Revival

Rise of Generative AI and GPU shortage Generative AI, enabled by large language models ( ) like , has caused shockwaves in the tech world. ChatGPT's meteoric rise has triggered the global tech industry to reassess and prioritize Generative AI, reshaping product strategies in real-time. LLMs GPT-4 Integration of LLMs has given product developers an easy way to incorporate AI-powered features into their products. But it's not all smooth sailing. A glaring challenge looms large for product leaders: the GPU shortage and spiraling costs. The increasing number of AI startups and services has led to high demand for high-end GPUs such as A100s and H100s, thereby overwhelming Nvidia and its manufacturing partner TSMC, both of whom are struggling to meet the supply. Online forums like Reddit are abuzz with frustrations over GPU availability, echoing the sentiment across the tech community. It's become so dire that both AWS and Azure have had no choice but to implement quota systems. This bottleneck doesn't just squeeze startups; it’s a stumbling block for tech giants like OpenAI. At a recent off-the-record meeting in London, OpenAI's CEO Sam Altman candidly acknowledged that the computer chip shortage is stymieing ChatGPT’s advancement. Altman reportedly lamented that the dearth of computing power has resulted in subpar API availability and has obstructed OpenAI from rolling out larger "context windows" for ChatGPT. Prioritizing AI Features On one hand, product leaders find themselves caught in a relentless push to innovate, facing the expectations to deliver cutting-edge features that leverage the power of Generative AI. On the other hand, they grapple with the harsh realities of GPU capacity constraints. It's a complex juggling act, where ruthless prioritization becomes not just a strategic decision but a necessity. Given that GPU availability is poised to remain a challenge for the foreseeable future, product leaders must think strategically about GPU allocation. Traditionally, product leaders have leaned on prioritization techniques like the Customer Value/Need vs. Effort Matrix. This method, however logical in a world where computational resources were abundant, now demands a bit of reevaluation. In our current paradigm, where computing is the constraint and not software talent, product leaders must redefine how they prioritize various products or features, bringing GPU limitations to the forefront of strategic decision-making. Planning around capacity constraints might seem unusual for the tech industry, but it's a commonplace strategy in other industries. The underlying concept is straightforward: the most valuable factor is the time spent on the constrained resource, and the objective is to optimize the value per unit of time spent on that constraint. As a former consultant, I've successfully applied this framework across various industries. I believe that tech product leaders can also use a similar approach to prioritize products or features while GPU constraints exist. When applying this framework, the most straightforward measure of value is profitability. However, in tech, profitability might not always be the appropriate metric, particularly when venturing into a new market or product. Thus, I have adapted the framework to align with the success metrics generally used in tech, outlining a simple four steps process: : First and foremost, identify your North Star metric. This is the contribution of each product or feature, something that encapsulates the essence of its worth. Some concrete examples might include: Contribution An increase in Revenue and Profit Gains in Market Share Growth in the Number of Daily/Monthly Active Users Gauge the number of GPUs needed for each product or feature. Focus on key factors like Number of GPUs Required: Number of Queries per User per Day Number of Daily Active Users The complexity of the Query (i.e., how many tokens each query consumes) : Break it down to the specifics. How does each GPU contribute to the overall goal? Understanding this will give you a clear picture of where your GPUs are best allocated. Calculate Contribution per GPU : Now, it's time to make the tough decisions. Rank your products by their Contribution per GPU, and then line them up accordingly. Focus on the products with the highest Contribution per GPU first, ensuring that your limited resources are channeled into the areas where they'll make the most impact. Prioritize Products Based on Contribution per GPU With GPU constraints no longer a blind spot, but a quantifiable factor in the decision-making process, your company can more strategically navigate the GPU shortage. To bring this framework to life, let's visualize a scenario where you, as a product leader, are grappling with the challenge of prioritizing among four different products: Product A Product B Product C Product D Revenue Potential (Contribution) $100M $80M $50M $25M Number of GPUs Required 1000 450 500 50 Contribution Per GPU $0.1M/GPU $0.18M/GPU $0.1M/GPU $0.5M/GPU Although Product A has the highest revenue potential, it doesn't yield the highest contribution per GPU. Surprisingly, Product D, with the least revenue potential, offers the most substantial return per GPU. By prioritizing based on this metric, you could maximize total potential revenue. Let's say you have a total of 1000 GPUs at your disposal. A straightforward choice might have you opting for Product A, generating a revenue potential of $100M. However, applying the prioritization strategy described above, you could achieve $155M in revenue: Priority Order Product Revenue Gain GPUs 1 Product D $25M 50 2 Product B $80M 450 3 Product C $50M 500 Total $155M 1000 The same method can be applied to other contribution metrics, such as market share gain: Product A Product B Product C Product D Market Share Gain (Contribution) 5% 4% 2.5% 1.25% Number of GPUs Required 1000 500 500 50 Contribution Per GPU 0.005%/GPU 0.008%/GPU 0.005%/GPU 0.025%/GPU Similarly selecting Product A would have led to a market share gain of 5%. However, applying the prioritization strategy described above, you could achieve 7.75% in market share gain: Priority Order Product Market Share gain GPUs 1 Product D 1.25% 50 2 Product B 4% 450 3 Product C 2.5% 500 Total 7.75% 1000 Benefits and limitations This alternative prioritization framework introduces a more nuanced and strategic approach. By zeroing in on the Contribution Per GPU, you're strategically aligning resources where they can make the most substantial difference, whether in terms of revenue, market share, or any other defining metric. But the advantages don't stop there. This method also fosters a greater sense of clarity and objectivity across product teams. In my experience, including my early days leading digital transformation at a healthcare company and later while working with various McKinsey clients, this approach has been a game-changer in scenarios where capacity constraints are a critical factor. It's enabled us to prioritize initiatives in a more data-driven and rational way, sidelining the traditional politics where decisions might otherwise fall to the loudest voice in the room. However, no one-size-fits-all solution exists, and it's worth acknowledging the potential limitations of this method. For instance, this approach may not always encapsulate the strategic importance of certain investments. Thus, while exceptions to the framework can and should be made, they ought to be carefully considered rather than the norm. This maintains the integrity of the process and ensures that any deviations are made with a broader strategic context in mind. Conclusion Product leaders are facing an unprecedented situation with the GPU shortage, so finding new ways of managing resources is needed. In the words of the great strategist Sun Tzu, "In the midst of chaos, there is also opportunity." The GPU shortage is indeed a challenge, but with the right approach, it may also be a catalyst for differentiation and success. The proposed prioritization framework, focusing on Contribution Per GPU, offers a strategic way to prioritize. By zeroing in on Contribution Per GPU, companies can maximize their return on investment, aligning resources where they'll make the most impact and focusing on what matters the most to the long-term success of their company. References https://nypost.com/2023/06/07/openais-sam-altman-complained-chip-shortage-is-delaying-chatgpt-plans/

PRIORI

priorilegal.com

-- employees

Since n.d.

COMPANY RANKING

PRIORI

EVERGREEN INDEX #8618

Representing this company? Click here to claim and customize this page!

Priori WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

PRIORI

priorilegal.com

-- employees

Since n.d.

COMPANY RANKING

PRIORI

EVERGREEN INDEX #8618

RELATED COMPANIESRANK

STORIES ABOUT PRIORI

Representing this company? Click here to claim and customize this page!

Priori WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!