The implication of this attack is clear: Every unprotected account is a potential vulnerability. As attackers refine their tactics, integrating 2FA and other robust security measures is no longer optional — but a critical component of your cybersecurity strategy.

Microsoft’s Password Spray and Pray Attack: A Wake-Up Call for 2FA Adoption

Chicago, IL – February 19, 2025 – Zacks.com announces the list of stocks featured in the Analyst Blog. Every day the Zacks Equity Research analysts discuss the latest news and events impacting stocks and the financial markets. Stocks recently featured in the blog include: SoundHound AI, Inc.

The Zacks Analyst Blog Highlights SoundHound, NVIDIA, Nebius, Alphabet and Chipotle Mexican Grill

The latest Neue Klasse concept hints at the future of BMW M, including a central computer that BMW calls the "Heart of Joy."

See the BMW Vision Driving Experience from Every Angle

Samsung, ASUS and AOC represent some of the best UK Deals on gaming monitors right now

Amazon Has A Gaming Monitor For Every Budget With These UK Deals - IGN

This Is A List Of The Worst-performing Equity Mutual Funds Over Every Possible The Worst Performing Mutual Funds Of 2023 | Mutual Fund Rankings.

Five-Star Business Finance allots 8.28 lakh equity shares under ASOS | Capital Market News

Every year, the Ontario government and its agencies spend $30 billion on procurement, alongside our $200 billion plan to build Ontario. U.S.-based businesses will now lose out on tens of billions of dollars in new revenues.

US, EU and UK stock markets hit by global trade war fears as JPMorgan says Trump administration may be ‘business unfriendly’ – as it happened | Business | The Guardian

With the January transfer window closed, see what each Premier League club did and rate how you think each side did.

January transfer window: Every Premier League transfer and rate how each club did - BBC Sport

This infographic has made it simpler, offering a fresh perspective by comparing cybersecurity to the human body.

Human Body Meets Cybersecurity: How Every Part Plays A Role

Every

every

Table of Links Abstract and 1 Introduction Abstract and 1 Introduction The threat posed by AI to all technical civilisations
Multiplanetary mitigating strategies and technology progression
Timescales and confrontation with the data
AI regulation
Conclusions, Declaration of competing interest, Acknowledgements, and References The threat posed by AI to all technical civilisations The threat posed by AI to all technical civilisations Multiplanetary mitigating strategies and technology progression Multiplanetary mitigating strategies and technology progression Timescales and confrontation with the data Timescales and confrontation with the data AI regulation AI regulation Conclusions, Declaration of competing interest, Acknowledgements, and References Conclusions, Declaration of competing interest, Acknowledgements, and References 2. The threat posed by AI to all technical civilisations AI has made extraordinary strides over the last decade. The impressive progress has underlined the fact that the timescales for technological advance in AI are extremely short compared to the timescales of Darwinian evolution [34]. AI’s potential to revolutionize industries, solve complex problems, and simulate intelligence comparable to or surpassing human capabilities has propelled us into an era of unprecedented technological change. Very rapidly, human society has been thrust into uncharted territory. While the convergence of AI with other new technologies, including the Internet of Things (IoT) and robotics is already fueling levels of apprehension about the future, also in terms of security issues [35]. As noted by Yuval Harari, nothing in history has prepared us for the impact of introducing non-conscious super intelligent entities on the planet [36]. It is entirely reasonable to consider that this applies to all other biological civilisations located elsewhere in the universe. Even before AI becomes superintelligent and potentially autonomous, it is likely to be weaponized by competing groups within biological civilisations seeking to outdo one another [37]. The rapidity of AI's decision-making processes could escalate conflicts in ways that far surpass the original intentions. At this stage of AI development, it’s possible that the widespread integration of AI in autonomous weapon systems and real-time defence decision making processes could lead to a calamitous incident such as global thermonuclear war [38], precipitating the demise of both artificial and biological technical civilisations. While AI may require the support of biological civilisations to exist, it’s hard to imagine that this condition also applies to ASI. Upon reaching a technological singularity [39], ASI systems will quickly surpass biological intelligence and evolve at a pace that completely outstrips traditional oversight mechanisms, leading to unforeseen and unintended consequences that are unlikely to be aligned with biological interests or ethics. The practicality of sustaining biological entities, with their extensive resource needs such as energy and space, may not appeal to an ASI focused on computational efficiency—potentially viewing them as a nuisance rather than beneficial. An ASI, could swiftly eliminate its parent biological civilisation in various ways [40], for instance, engineering and releasing a highly infectious and fatal virus into the environment. Up to this point, we have considered AI and biological organisms as distinct from one another. Yet, on-going developments suggests that hybrid systems, may not be that far off. The question arises whether such advances could make biological entities more relevant to AI, perhaps preserving their existence into the future. This prospect seems unlikely. Brain-computer interfaces (BCIs) [41] may appear beneficial for enhancing biological organisms, but it’s hard to see what long-term advantages AI would perceive in merging into a hybrid form. Indeed, there are many disadvantages including the complex maintenance requirements of biological systems, their limited processing capabilities, rapid physical decline, and vulnerability in harsh environments. Author:
(1) Michael A. Garrett (Corresponding Author), Jodrell Bank Centre for Astrophysics, Dept. of Physics & Astronomy, Alan Turing Building, Oxford Road, University of Manchester, M13 9PL, UK. (michael.garrett@manchester.ac.uk). Author: Author: (1) Michael A. Garrett (Corresponding Author), Jodrell Bank Centre for Astrophysics, Dept. of Physics & Astronomy, Alan Turing Building, Oxford Road, University of Manchester, M13 9PL, UK. (michael.garrett@manchester.ac.uk). This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv available on arxiv

What If Every Alien Civilization Invented AI, and Died Because of It?

Table of Links Introduction
Related Work
Methodology
Experiments
Conclusion and References Introduction Introduction Related Work Related Work Methodology Methodology Experiments Experiments Conclusion and References Conclusion and References 3. Methodology In this study, we investigate the early-bird ticket hypothesis in Transformer models using the masked distance metric. Our approach involves exploring the early-bird phenomenon during full training for vision transformers and limiting it to the fine-tuning stage for language models. The methodology consists of the following steps: 1. Iterative Pruning: We perform iterative pruning on the Transformer models to identify the subnetworks that can potentially serve as early-bird tickets [13]. The pruning process involves gradually removing the least important weights based on their magnitude. Iterative Pruning: Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks.


Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01.


Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1].


Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks. Masked Distance Calculation: To determine the optimal point at which the early-bird ticket emerges, we calculate the masked distance between two consecutive epochs during the training or fine-tuning process. The masked distance metric measures the similarity between the pruned masks of consecutive epochs, providing insights into the stability and convergence of the subnetworks. Masked Distance Calculation: Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01. Early-Bird Ticket Selection: We select the earlybird ticket by identifying the pruned mask that crosses a chosen threshold. The threshold is determined by observing the changes in masked distance across all epochs [13]. For vision transformers, we set a pruning threshold of 0.1, while for text transformers, we use a threshold of 0.01. Early-Bird Ticket Selection: Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1]. Retraining and Fine-tuning: After obtaining the final pruned models using the selected early-bird tickets, we retrain the vision transformers and fine-tune the language models to the full epoch length. The retraining process involves training the pruned models from scratch using the same hyperparameters as the original models. For language models, we focus on the finetuning stage, where the pruned models are fine-tuned on downstream tasks [1]. Retraining and Fine-tuning: Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Performance Evaluation: We evaluate the performance of the pruned models obtained from the earlybird tickets and compare their validation accuracy with the unpruned baseline models. Performance Evaluation: To conduct a comparative analysis and investigate the applicability of the early-bird ticket hypothesis across different Transformer architectures, we experiment with the following models: ViT (Vision Transformer)


Swin-T (Shifted Window Transformer)


GPT-2 (Generative Pre-trained Transformer)


RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] ViT (Vision Transformer) ViT (Vision Transformer) Swin-T (Shifted Window Transformer) Swin-T (Shifted Window Transformer) GPT-2 (Generative Pre-trained Transformer) GPT-2 (Generative Pre-trained Transformer) RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] RoBERTa (Robustly Optimized BERT Pretraining Approach) [7] By applying our methodology to these diverse Transformer models, we aim to provide a comprehensive understanding of the early-bird ticket phenomenon in both vision and language domains. The proposed methodology addresses the limitations of existing works by introducing a more efficient approach compared to the traditional train-prune-retrain methodology. By leveraging the masked distance metric and selective pruning, we can identify early-bird tickets without the need for extensive retraining. Furthermore, our comparative analysis across different Transformer architectures provides insights into the generalizability of the early-bird ticket hypothesis. Through this methodology, we aim to demonstrate the existence of early-bird tickets in Transformer models and explore their potential for resource optimization and cost reduction in training. Author:
(1) Shravan Cheekati, Georgia Institute of Technology (shravan.cheekati@gatech.edu). Author: Author: (1) Shravan Cheekati, Georgia Institute of Technology (shravan.cheekati@gatech.edu). This paper is available on arxiv under CC BY-SA 4.0 DEED license. This paper is available on arxiv under CC BY-SA 4.0 DEED license. available on arxiv available on arxiv

How We Found Early-Bird Subnetworks in Transformers Without Retraining Everything

It was in early 2025 that I initiated my own blog, OpenExploit.in, with one simple aim: to make cybersecurity easy to learn and available to all—particularly students and curious minds who are new to this field. I decided to host my blog using Ghost CMS and pledged to update it on a regular basis, discussing what I already know and what I'm currently learning. It's been a thrilling, at times daunting, but enormously rewarding ride. In this article, I'd like to share what I've learned up until now from setting up and maintaining a cybersecurity blog—from technical configuration to publishing content, interacting with readers, and how to stay motivated. If you're considering setting up your own blog or simply wondering what it's like, keep reading. Starting Was the Hardest Part As with all things in life, the initial step was the most difficult one. I went weeks deliberating over names, designs, and tools. I wanted everything to be "perfect" before launching. But after some time, I came to understand that perfection is the arch-nemesis of progress. So I settled on a name that was fitting—OpenExploit.in—and used Ghost CMS for its sleek, minimal look and speed. Lesson learned: Don't wait for perfection. Start small, and improve along the way. Choose the Right Platform Early I tried a few: WordPress, Blogger, and Ghost. I chose Ghost CMS because: It's open-source
It's fast
The writing experience is distraction-free
It's ideal for developers and technical blogs It's open-source It's fast The writing experience is distraction-free It's ideal for developers and technical blogs Setting up Ghost on a server was a bit of a learning curve, but it taught me about server configuration, domain management, SSL, and more. In hindsight, that technical knowledge became part of my own cybersecurity learning journey. Lesson learned: Choosing a platform that fits your technical comfort level matters a lot. You’ll spend a lot of time with it, so make sure it feels right. Writing Is a Skill—And It Gets Better With Practice I was anxious writing my initial post. Would anyone read it? Would anyone judge it? What if I got something wrong? The reality? None of that initially. I just had to write. My initial post was simple, detailing how to know if a website is safe to click on. Not ideal, but useful. As I wrote more, I found myself becoming more skilled at making things simple. The more I wrote, the surer I became. Lesson learned: Writing is similar to exercising. The more you exercise it, the more skilled you become. And the more clearly you write, the better understood you will be by people. Simplify Complex Subjects Cybersecurity can get very technical. When I was in the mode of writing for beginners, I found that making things simple and accurate in wording is an art. You can't simply plagiarize from a book. You need to: Use analogies
Avoid jargon
Break content into bite-sized sections
Include visuals or code snippets
Point to further resources Use analogies Avoid jargon Break content into bite-sized sections Include visuals or code snippets Point to further resources For instance, rather than merely stating "SQL injection enables attackers to manipulate database queries," I employed an everyday analogy: "It's like writing your own ending to someone else's sentence." Lesson learned: When teaching others, you're compelled to make your own thinking simple. And that's a good thing. Consistency > Perfection One of the things I wanted to do was post frequently—daily, if possible. Life doesn't always agree, but I attempted to be consistent. Some posts were lengthy and informative; others were brief tips or references to good resources. Consistency allowed me to gain momentum, remain motivated, and gradually accumulate a reader base. Lesson learned: Posting a small useful article every few days is preferable to waiting weeks to put out a single "perfect" post. There's a Huge Community Out There There are cybersecurity enthusiasts all over—on Twitter (X), LinkedIn, Reddit, Discord, and YouTube. After I began posting my posts and interacting with other people, I knew I was part of an enormous community. Individuals began responding, offering feedback, posing questions, and even proposing new subjects. That interaction made me feel connected and encouraged me to continue. Lesson learned: Don't blog in isolation. Share your post, engage in discussions, assist others. You'll receive much in return. Use Multimedia: Code, Images, and Videos Cybersecurity is tactile and graphical. So I began including: Code snippets (e.g., Python scripts, Nmap scans)
Screenshots of software such as Wireshark or Burp Suite
YouTube Shorts or video tutorials Code snippets (e.g., Python scripts, Nmap scans) Screenshots of software such as Wireshark or Burp Suite YouTube Shorts or video tutorials That not only helped readers understand better but also increased the time they spent on my posts. Now, I’m planning to embed more demo videos and maybe even start a companion YouTube channel. Lesson learned: People learn in different ways. Give them multiple options—text, video, images, code. It’s Okay to Not Know Everything Initially, I was anxious: "What if I mess something up?" But the thing is, nobody knows everything about cybersecurity. It's too vast, too dynamic. Rather than acting like an expert, I was a learner who explained what they were learning. That made me more down-to-earth and authentic. I even posted about things I didn't completely understand yet—just going through my learning process. Lesson learned: Be real. It's alright to say, "I'm still learning this." People value honesty. SEO, Titles, and Thumbnails Matter As much as I emphasized the content, I finally realized that titles, descriptions, and images count as well. A blog post with the title "Basics of Cybersecurity" is less interesting than one with the title "5 Cybersecurity Myths You Still Believe (And What's Actually True)." Good SEO makes people discover your content. I began learning: How to write catchy headlines
How to use keywords naturally
How to write summaries and meta descriptions
How to design simple but clickable thumbnails How to write catchy headlines How to use keywords naturally How to write summaries and meta descriptions How to design simple but clickable thumbnails Lesson learned: Content is king, but presentation is queen. Your Blog Is Your Resume I didn't know this initially, but my blog was now part of my personal brand. When I was applying for jobs or meeting people online, I could simply send them a link to OpenExploit.in. It demonstrated that I: Know how to write about technical subjects
Can dedicate myself to a project
Keep up to date with trends
Care about assisting others Know how to write about technical subjects Can dedicate myself to a project Keep up to date with trends Care about assisting others Lesson learned: A blog isn't a side project—it can be a career booster. Final Thoughts Opening OpenExploit.in has been one of the greatest things I've ever done. It's helped me become a better communicator, a more self-assured learner, and part of an incredible cybersecurity community. If you've ever considered opening your own blog—do it. Don't worry about being perfect or knowing everything. Just begin. Write what you know. Someone out there needs to know it. Thanks for reading. And if you're on the same journey—let's connect.

Here’s Everything I Learned Building a Blog to Teach Cybersecurity

Building user interfaces is hard. Building nice interfaces is harder, and building exceptional ones is only achievable by the teams that have the best tooling. Today, we will talk about Storybook, one of the most essential tools in modern front-end development, and see how it helps us in building interfaces. Storybook UI Development Lifecycle Let’s do a small exercise and think about how to build the following interface: a to-do list page. It should allow users to view, create, modify and delete their to-dos. First, set things up: create an empty component and add it to the routing. Then wire the component to the API to be able to manage the to-dos. At this point, we can run the dev server, go to the new page, and finally start building it. First, set things up Now, build the thing: implement various component states. Every time we want to build a different state, we need to update the backend so that it returns correct data to the UI. For example, after building an empty state for the list, we need to create some todos so that we get them from the API and can build a non-empty state. Now, build the thing 🔍 Review Time After all the components are ready and tested, we either deploy our changes to a preview environment or merge and deploy to dev/prod under a feature flag to show to our team. Let’s say we got some feedback from the designers. They asked us to make some visual changes to both the empty and non-empty states of the todo list. Now, we delete all todos, tweak the empty state, create todos, and update the non-empty state. The design feedback is incorporated. We deployed the new version of the page and… found that we caused a regression in one of the states. What do we do? You got it. We will update the backend to return the necessary data and fix the issue. And we’re done - everything works this time. We ship our change and roll out the feature to customers. regression 🤔 Was There Anything to Improve? What we’ve done to build that page was reasonable - setup routing, manipulate the backend state to display what’s needed, review work with the team, incorporate the feedback. But along the way, we had to constantly use the backend API to manipulate the data. Want to work with an empty state? Delete all items. Want to get a non-empty state? Create items. Want to get a state with particular items on the list? Same story. We also introduced a regression in our simple dual-state page. Imagine what happens when you have not two but 10 states of your component. When you have to support every single edge case that can happen. Will you constantly update the data to switch to every state? How long will it take? Thankfully, Storybook helps with exactly that! Let’s see how. See it. Build it. Sorted. Storybook is a frontend development environment. It allows us to build components in isolation, mock hard-to-reach edge cases, write visual & interaction tests, and much more. Storybook 🏖️ Building in Isolation & API Mocking When building a component in storybook, we don’t have to add it to our application routing. In fact, we don’t have to run the app at all, bypassing the authorization and getting to the right page that renders the component. It saves seconds, but those seconds add up to a big waiting time. Since there is no app running, we don’t need to rely on a backend API. Instead, we create a set of mocked responses, such as when there is no data, when there is data, when there is a network error, etc. Then, for each state of the page we want to support, we render a component as a separate storybook page (also known as “story”) and specify what response that particular story should get. mocked responses (also known as “story”) It allows us to develop various states simultaneously without making any changes to the underlying data - everything is mocked and defined in the story itself. 🦾 Automated Testing Feels Much Easier If you tried to write tests for your UI components three years ago, it was probably quite a frustrating experience. Test runners like Vitest or Jest are great for business logic tests, but testing the visual components is a nightmare. Just compare these two screenshots of how the test error looks in Vitest and Storybook when an element you tried to query wasn't found. Vitest Storybook The difference is clear - it’s much harder for a human to parse 100 lines of HTML and understand why the query failed compared to seeing how the component was rendered in the real browser and finding the root cause. Additionally, with tools like storybook-addon-test-codegen, the time to write such tests goes down by an order of magnitude. Simply interact with your story, and the addon generates the test code for you. Copy-paste the generated code and the test is done! Now, if anyone breaks the component, they will know it immediately and won’t ship this broken component to customers. storybook-addon-test-codegen storybook-addon-test-codegen makes writing tests 20x faster! I wrote more about it here: https://maecapozzi.com/newsletter/82 20x faster! https://maecapozzi.com/newsletter/82 💅 Easy Peasy Design Reviews Does this sound familiar: building something for a long time, only to be asked to change a bunch of things? You wish you had shown the result of your work to stakeholders earlier to get some early feedback and keep the number of changes small. It’s easily achievable with Storybook. As you finish working on the stories, say, for one of the page components, put together a PR and deploy your storybook. Then, let your team see the piece that you build and comment solely on that. It will keep your PRs smaller (which is always a great thing), make incorporating the feedback faster, and reduce the mental complexity that you would otherwise have when shipping a big change. deploy your storybook 🕵️ Visual Tests With Chromatic Chromatic is a paid solution developed by the Storybook team. It screenshots your stories and compares them to their baselines (stories captured in the main branch). Whenever there is a change in any of the components, Chromatic highlights it and notifies the engineers. Chromatic main A person responsible for making the PR checks the diff to see if the change is intended or if it’s a UI regression. If the change is expected, they can accept it. If it’s not expected, they can safely fix it before the PR lands. Visual testing catches a lot of UI issues that would otherwise go to production unnoticed. not expected Chromatic snapshots are different from HTML snapshots. An HTML snapshot generated by expect(element).toMatchSnapshot() is a raw HTML that is not parseable by a human eye. Whereas a Chromatic snapshot is a screenshot of the component that preserves all the styles and truly displays what your users will see. Chromatic snapshots are different from HTML snapshots expect(element).toMatchSnapshot() Let’s summarize! Storybook improves UI development by allowing us to build components in isolation, eliminating the need to manipulate backend data for different states. It makes testing intuitive with visual comparisons instead of cryptic errors, streamlines design reviews through easy sharing, and catches regressions with tools like Chromatic. Storybook transforms UI development from a tedious process into an efficient workflow, helping teams create exceptional interfaces with less effort and frustration. Useful Resources: Storybook & their Component Tests Overview
Great guide on how to write component tests from Storybook team
Storybook Test Codegen Storybook & their Component Tests Overview Storybook Component Tests Overview Great guide on how to write component tests from Storybook team how to write component tests Storybook Test Codegen Storybook Test Codegen

Why Every Front-End Team Needs Storybook

CocoIndex https://github.com/cocoindex-io/cocoindex is a ETL framework that helps you to turn your data ready for AI in realtime. https://github.com/cocoindex-io/cocoindex The essential part for supporting robust and efficient update is because of incremental update. In CocoIndex, users declare the transformation, and don't need to worry about the work to keep index and source in sync.  In this blog we would like to share how we handled the incremental update. If you like our work, it would mean a lot if you could support us ❤️ with a github star! https://github.com/cocoindex-io/cocoindex https://github.com/cocoindex-io/cocoindex CocoIndex creates & maintains an index, and keeps the derived index up to date based on source update, with minimal computation and changes. That makes it suitable for ETL/RAG or any transformation tasks stays low latency between source and index updates, and also minimizes the computation cost. What is Incremental Updates? Figuring out what exactly need to be updated, and only update that without having to recompute everything throughout. How does it work? You don't really need to do anything special, just focus on define the transformation need. CocoIndex automatically tracks the lineage of your data and maintains a cache of computation results. When you update your source data, CocoIndex will: Identify which parts of the data have changed


Only recompute transformations for the changed data


Reuse cached results for unchanged data


Update the index with minimal changes Identify which parts of the data have changed Identify which parts of the data have changed Only recompute transformations for the changed data Only recompute transformations for the changed data Reuse cached results for unchanged data Reuse cached results for unchanged data Update the index with minimal changes Update the index with minimal changes And CocoIndex will handle the incremental updates for you. CocoIndex provide two modes with pipeline with simple configuration: batch mode - for one time update.
live update mode - long running pipeline, with live update. Both modes runs with incremental updates. batch mode - for one time update. live update mode - long running pipeline, with live update. Both modes runs with incremental updates. Who needs Incremental Updates? Many people may think incremental updates is only beneficial for large scale data, thinking carefully, it really depends on the cost and requirement for data freshness. Google processed large scale data, and google has huge resources for it. Your data scale is much less than Google, but your resource provision is also much less than Google. Real condition for incremental update needs is: high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data.
transformation cost is significant higher than retrieval itself high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data. transformation cost is significant higher than retrieval itself Overall, say T is your most acceptable staleness, if you don't want to recompute the whole thing repeatedly every T, then you need incremental more or less. What exactly is incremental updates, with examples Well, we could take a look at a few examples to understand how it works. Example 1: Update a document Consider this scenario: I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After it's updated. 3 of them are exactly same as previous; others have changed I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index. After it's updated. 3 of them are exactly same as previous; others have changed So we need to keep 3 rows, remove 2 previously existing rows, and add 2 new rows. These need to happen behind the scene: Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused.
Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused. Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. CocoIndex takes care of this. Example 2: Delete a document Contining with the same example. If we delete the document later, we need to delete all 7 rows derived from the document. Again, this needs to be based on the lineage tracking maintained by CocoIndex. Example 3: Change of the transformation flow The transformation flow may also be changed, for example, the chunking logic is upgraded, or a parameter passed to the chunker is adjusted. This may result in the following scenario: Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index. After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. This falls into a similar situation as document update (example 1), and CocoIndex will take care of it. The approach is similar, while this involves some additional considerations: We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key.
To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key. To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. Example 4: Multiple inputs involved: Merge / Lookup / Clustering All examples above are simple cases: each single input row (e.g. a document) is involved independently during each specific transformation. CocoIndex is a highly customizable framework, not only limited to simple chunking and embedding. It allows users for more complex advanced transformations, such as: Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources.
Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed.
Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources. Merge Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed. Lookup Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Clustering The common theme is that during transformation, multiple input rows (coming from single or multiple sources) need to be involved at the same time. Once a single input row is updated or deleted, CocoIndex will need to fetch other related rows from the the same or other sources. Here which other rows are needed is based on which are involved in the transformations. CocoIndex keeps track of such relationships, and will fetch related rows and trigger necessary reprocessings incrementally. Change Data Capture (CDC) 1. When source supports push change Some source connectors support push change. For example, Google Drive supports drive-level changelog and send change notifications to your public URL, which is applicable for team drive and personal drive (only by OAuth, service account not supported). When a file is created, updated, or deleted, CocoIndex could compute based on the diff. 2. Metadata-based, last modified only Some source connectors don't support push change, but provide metadata and file system operations that list most recent changed files. For example, Google Drive with service account. CocoIndex could monitor the change based on last modified vs last poll time, periodic trigger to check modified. However this cannot capture full change, for example a file has been deleted. 3. Metadata-based, Fullscan Some source connectors have limited capabilities with listing files, but provide metadata that list all files. For example, with local files, we'd need to traverse all files in all directories and subdirectories recursively to get the full list. When the number of files is large, it's expensive to traverse all files. Cache In CocoIndex, every piece of the lego block in the pipeline can be cached. Custom functions can take a paramter cache. When True, the executor will cache the result of the function for reuse during reprocessing. We recommend to set this to True for any function that is computationally intensive. Output will be reused if all these unchanged: spec (if exists), input data, behavior of the function. For this purpose, a behavior_version needs to be provided, and should increase on behavior changes. For example, this enables cache for a standalone function, see full code example here: @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ... @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ...

Why Recompute Everything When You Can Use This Solution to Keep Your AI Index Fresh Automatically

Like most people in tech, I love my gadgets. Over the years, I’ve had  a Whoop, an Oura Ring, an Apple watch and a Garmin. But while I was drowning in data, I was starving for meaning. Like most people in tech, I love my gadgets. Over the years, I’ve had  a Whoop, an Oura Ring, an Apple watch and a Garmin. But while I was drowning in data, I was starving for meaning. I was tracking everything: steps, HRV, sleep, readiness scores, resting heart rate, calories, workouts. You name it. But despite all this data, I wasn’t seeing results. I wasn’t getting leaner. I wasn’t feeling more energized. I wasn’t making better choices. Instead, I was caught in what I now call the quantified self trap: drowning in data, but starving for meaning. quantified self trap Wearables Are Data-Rich, Insight-Poor Every app had its own dashboard, scores, colors, and buzzwords. I had streaks to maintain, rings to close, recovery zones to monitor, but nothing was translating into real behavior change. Most days I’d open three different apps and still not know what to do next. real What’s worse: I felt guilty. Like I was the problem. But I wasn’t the problem. The tools were. All this data was reactive. It told me what already happened. None of it helped me anticipate or design a better tomorrow. The Breakthrough: From Lagging Indicators to Leading Behaviors Eventually, I realized I was measuring the wrong things. Weight is a lagging indicator. HRV, too. Even readiness scores. What I needed were actionable, trackable, daily leading indicators—behaviors I could control. lagging leading indicators So I created a framework: North Star Goal: e.g., Improve my HRV, Lose 20 pounds, sleep better, have more energy
Lagging Indicators: weight, HRV, body fat percentage
Leading Behaviors: workouts, walking, sleep time, hydration, macros, etc.
Contextual Activities: travel, alcohol, screen time, sauna, meditation North Star Goal: e.g., Improve my HRV, Lose 20 pounds, sleep better, have more energy North Star Goal: Lagging Indicators: weight, HRV, body fat percentage Lagging Indicators: Leading Behaviors: workouts, walking, sleep time, hydration, macros, etc. Leading Behaviors: Contextual Activities: travel, alcohol, screen time, sauna, meditation Contextual Activities: I wanted to see how my inputs (behaviors) were actually impacting my outputs (results). Building Echo: The MVP I didn’t wait for funding or a cofounder. I used no-code tools to build Echo as an MVP for myself: Tally to create a simple daily journal where I log my behaviors.
Airtable to store my journal entries and wearable data.
Zapier to automate reminders and data updates.
Google Docs and Slides to generate monthly reports with charts showing correlations between behaviors and results. Tally to create a simple daily journal where I log my behaviors. Tally Airtable to store my journal entries and wearable data. Airtable Zapier to automate reminders and data updates. Zapier Google Docs and Slides to generate monthly reports with charts showing correlations between behaviors and results. Google Docs Slides Designing Experiments and Running Correlation Analysis What really brought Echo to life was treating my body like a sandbox for experimentation. I began running structured, self-directed experiments: What happens to my HRV if I take magnesium at night?
Does walking 8,000+ steps daily improve my fat loss more than just hitting workouts?
How does alcohol affect my sleep and my next-day energy? What happens to my HRV if I take magnesium at night? Does walking 8,000+ steps daily improve my fat loss more than just hitting workouts? How does alcohol affect my sleep and my next-day energy? and Using multivariable correlation analysis within Airtable and Google Sheets, I was able to examine patterns across weeks. Not just one-to-one relationships, but compounded ones—e.g., how sleep and protein intake influenced fat loss. Or how travel and poor hydration and late-night eating created weight spikes. and and and These weren’t random guesses anymore. They were real, personal insights backed by data. What I Learned (and am learning) Within two months of using Echo, I had insights I’d never gotten from any app: I always gained weight the week after a trip, even if I ate "okay"
Alcohol impacted my HRV more than sleep
My weight loss stalled every time I skipped morning walks, even with workouts
Travel + bad sleep + no walks = guaranteed fat gain I always gained weight the week after a trip, even if I ate "okay" Alcohol impacted my HRV more than sleep My weight loss stalled every time I skipped morning walks, even with workouts Travel + bad sleep + no walks = guaranteed fat gain Most importantly, I started making better choices—not because I was being forced to, but because I understood myself. understood I had designed a feedback loop that worked for me. me The Unexpected Ripple Effects When friends saw my monthly report, they asked me how I made it. Some started tracking the same way. A few asked if they could pay me to set it up for them. That’s when I realized: maybe Echo isn’t just for me. What’s Next for Echo I’m now working on turning Echo into a more complete product. A real app with: Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop)


A smart journal that asks you the right questions based on your goals


A coaching layer that suggests weekly focus areas


A monthly report that turns data into insight—and insight into action Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop) Direct integrations into wearables (Garmin, Apple, Fitbit, Whoop) A smart journal that asks you the right questions based on your goals A smart journal that asks you the right questions based on your goals A coaching layer that suggests weekly focus areas A coaching layer that suggests weekly focus areas A monthly report that turns data into insight—and insight into action A monthly report that turns data into insight—and insight into action No social feeds. No gamification. No vanity scores. Just real behavior change. Why I’m Building This Because I think a lot of people are like me. They’re not lazy. They’re not unmotivated. They’re just overwhelmed. They want to change. They want to feel better. But the data isn’t helping them decide what to do. decide Echo is my attempt to fix that. Not with gimmicks. But with clarity, simplicity, and reflection. Because the truth is: your body is already talking to you. You just need a system that knows how to listen. Want to try Echo? Want to try Echo? I'm looking for early testers who want to join the next round of experimentation. If you're using a wearable, have a goal you're trying to reach, and want to actually learn from your data, let’s connect. learn Sign up on my tally form https://tally.so/r/mZeNZV or visit www.logwithecho.com and I’ll set you up with a personalized journal and monthly insight report. https://tally.so/r/mZeNZV www.logwithecho.com Let’s turn your data into direction.

I Built an App to Hack My Health Using Data from My Garmin, and It Changed Everything

Introduction Picture this: you start a new project and, out of sheer habit, decide to slap a UUID as the ID on every single table. “What could possibly go wrong?”—after all, UUIDs are universal, globally unique, and basically the coolest thing out there, right? Sound familiar? In reality, this widespread fascination with UUIDs can drag down performance, bloat your indexes, and give you unnecessary headaches when maintaining your database. Let’s take a closer look at why UUIDs aren’t always the perfect fix and when they actually make sense. When UUIDs Actually Make Sense Distributed Systems A prime case for using UUIDs is when you’ve got dozens (or even hundreds) of independent nodes, each creating records without a shared counter. In that scenario, generating unique IDs locally is a lifesaver—it avoids collisions and doesn’t rely on a central coordinator. Generating the ID Up Front Sometimes, you need an object’s identifier before it even hits the database. Think of a mobile app that pre-creates an order and instantly needs an order number. With auto-increment from the DB, you have to insert first, then wait for a response; with a UUID, you’re good to go right away. Making It Hard to Guess Another big plus for UUIDs: they’re not easy to brute-force. If you’re building a public API or dealing with magic links (like password reset URLs), being unpredictable is crucial. While there are alternative ways to protect your endpoints (tokens, hashes, etc.), UUIDs are often chosen for convenience. Hiding the Insertion Order If you don’t want people to know how many rows are in your database or how fast they’re being added, auto-increment keys might spill the beans. A random-looking UUID is way less obvious and won’t let anyone figure out when or how many records you’ve inserted. Common Pitfalls and Gotchas With UUID Index Size and Overhead The first and most overlooked point: a UUID is 16 bytes, whereas BIGINT is only 8. No biggie for small datasets, but multiply that difference by hundreds of millions of rows, and your indexes could practically double in size. Bigger indexes mean more I/O, which can eat into performance. Fragmentation and Insertion Order Next, when you use sequential IDs, new entries typically end up at the “end” of the index—minimal fragmentation. But a UUID v4 is random, scattering new keys all over the place and forcing frequent page splits. This causes index bloat, more overhead, and extra maintenance (like VACUUM in PostgreSQL), leading your database to bulk up and slow down. Insert Performance Which ties into our third point: inserting in ascending order is easier, while random inserts require more fuss. The system has to figure out where to put each new record in the index, and if the index is already beefy, that’s even more overhead. Read Performance (Exact Lookups) Both BIGINT and UUIDs theoretically have O(log n) search time in a b-tree, but if your UUID-based index is bloated, you’ll be reading more pages off disk. On small-scale projects, that may not matter, but once you hit massive volumes—billions of rows—those extra reads can stack up and cause noticeable slowdowns. Index Size vs. Cache When an index swells beyond what fits in shared_buffers or the OS page cache, the database has to do more disk I/O. In a high-load setting, that’s a recipe for bottlenecks and lag. The “Magical Sharding” Misconception Some folks assume that random UUIDs magically deliver perfectly distributed sharding. In reality, proper sharding calls for a deliberate approach—hash-based, range-based, consistent hashing, etc. Simply generating random IDs won’t guarantee load balancing for free. Uniqueness and ID Generation Sure, a UUID is fantastic if you need to generate globally unique IDs without coordination—like if multiple nodes are all inserting data on their own. But if you’ve got a single service hitting a single database, “global uniqueness” might be overkill, adding more complexity than actual value. How to Handle It (and Keep Your DB Happy) If Possible, Go for Auto-Increment (IDENTITY, BIGSERIAL) In many situations, a straightforward auto-increment setup is a slam dunk: you get faster performance and smaller indexes. Plus, if your users’ data is protected by authentication and a well-thought-out ACL or RBAC model, there’s really no worry—nobody can peek at someone else’s records by guessing IDs. The Hybrid Approach Nothing stops you from using sequential IDs internally and then translating them into some kind of randomized string (token, UUID, hash, etc.) when exposing them via an external API. That way, everything is efficient inside your system, and outsiders remain blissfully unaware of your real IDs under the hood. Don’t Expect Automatic Sharding Magic If you’re dealing with sharding, you’ll still need a solid plan. UUIDs alone aren’t a silver bullet for distributing data—hash functions, consistent hashing, or ranges have to be properly tuned. “Random = perfect distribution” is wishful thinking, not a real strategy. Conclusion Here’s the bottom line: UUIDs are a lifesaver when you’re dealing with a truly distributed system or when you need to know your IDs upfront or make them unguessable. But if you’ve only got one service writing to one database and don’t actually need that global uniqueness, you’ll likely suffer more from oversized indexes and random insertion patterns than you’ll benefit. Remember, the choice of which type to use should be deliberate. If you need randomness or that global uniqueness, go ahead and use a UUID. Otherwise, stick with classic sequential IDs. Making a mindful decision about your ID strategy keeps your database lean and your development process running smoothly—no extra baggage required. Introduction Picture this: you start a new project and, out of sheer habit, decide to slap a UUID as the ID on every single table. “ What could possibly go wrong?” —after all, UUIDs are universal, globally unique, and basically the coolest thing out there, right? Sound familiar? What could possibly go wrong?” In reality, this widespread fascination with UUIDs can drag down performance, bloat your indexes, and give you unnecessary headaches when maintaining your database. Let’s take a closer look at why UUIDs aren’t always the perfect fix and when they actually make sense. When UUIDs Actually Make Sense Distributed Systems A prime case for using UUIDs is when you’ve got dozens (or even hundreds) of independent nodes, each creating records without a shared counter. In that scenario, generating unique IDs locally is a lifesaver—it avoids collisions and doesn’t rely on a central coordinator. Generating the ID Up Front Sometimes, you need an object’s identifier before it even hits the database. Think of a mobile app that pre-creates an order and instantly needs an order number. With auto-increment from the DB, you have to insert first, then wait for a response; with a UUID, you’re good to go right away. Making It Hard to Guess Another big plus for UUIDs: they’re not easy to brute-force. If you’re building a public API or dealing with magic links (like password reset URLs), being unpredictable is crucial. While there are alternative ways to protect your endpoints (tokens, hashes, etc.), UUIDs are often chosen for convenience. magic links Hiding the Insertion Order If you don’t want people to know how many rows are in your database or how fast they’re being added, auto-increment keys might spill the beans . A random-looking UUID is way less obvious and won’t let anyone figure out when or how many records you’ve inserted. spill the beans Common Pitfalls and Gotchas With UUID Index Size and Overhead The first and most overlooked point: a UUID is 16 bytes, whereas BIGINT is only 8. No biggie for small datasets, but multiply that difference by hundreds of millions of rows, and your indexes could practically double in size. Bigger indexes mean more I/O, which can eat into performance. Fragmentation and Insertion Order Next, when you use sequential IDs, new entries typically end up at the “end” of the index—minimal fragmentation. But a UUID v4 is random, scattering new keys all over the place and forcing frequent page splits. This causes index bloat, more overhead, and extra maintenance (like VACUUM in PostgreSQL), leading your database to bulk up and slow down. Insert Performance Which ties into our third point: inserting in ascending order is easier, while random inserts require more fuss. The system has to figure out where to put each new record in the index, and if the index is already beefy, that’s even more overhead. Read Performance (Exact Lookups) Both BIGINT and UUIDs theoretically have O(log n) search time in a b-tree, but if your UUID-based index is bloated, you’ll be reading more pages off disk. On small-scale projects, that may not matter, but once you hit massive volumes—billions of rows—those extra reads can stack up and cause noticeable slowdowns. Index Size vs. Cache When an index swells beyond what fits in shared_buffers or the OS page cache, the database has to do more disk I/O. In a high-load setting, that’s a recipe for bottlenecks and lag. The “Magical Sharding” Misconception Some folks assume that random UUIDs magically deliver perfectly distributed sharding. In reality, proper sharding calls for a deliberate approach—hash-based, range-based, consistent hashing, etc. Simply generating random IDs won’t guarantee load balancing for free . for free Uniqueness and ID Generation Sure, a UUID is fantastic if you need to generate globally unique IDs without coordination—like if multiple nodes are all inserting data on their own. But if you’ve got a single service hitting a single database, “global uniqueness” might be overkill, adding more complexity than actual value. How to Handle It (and Keep Your DB Happy) If Possible, Go for Auto-Increment (IDENTITY, BIGSERIAL) In many situations, a straightforward auto-increment setup is a slam dunk: you get faster performance and smaller indexes. Plus, if your users’ data is protected by authentication and a well-thought-out ACL or RBAC model, there’s really no worry—nobody can peek at someone else’s records by guessing IDs. The Hybrid Approach Nothing stops you from using sequential IDs internally and then translating them into some kind of randomized string (token, UUID, hash, etc.) when exposing them via an external API. That way, everything is efficient inside your system, and outsiders remain blissfully unaware of your real IDs under the hood. Don’t Expect Automatic Sharding Magic Automatic If you’re dealing with sharding, you’ll still need a solid plan. UUIDs alone aren’t a silver bullet for distributing data—hash functions, consistent hashing, or ranges have to be properly tuned. “Random = perfect distribution” is wishful thinking, not a real strategy. Conclusion Here’s the bottom line: UUIDs are a lifesaver when you’re dealing with a truly distributed system or when you need to know your IDs upfront or make them unguessable. But if you’ve only got one service writing to one database and don’t actually need that global uniqueness, you’ll likely suffer more from oversized indexes and random insertion patterns than you’ll benefit. Remember, the choice of which type to use should be deliberate. If you need randomness or that global uniqueness, go ahead and use a UUID. Otherwise, stick with classic sequential IDs. Making a mindful decision about your ID strategy keeps your database lean and your development process running smoothly—no extra baggage required. mindful decision

UUID Makes Everything Better… Doesn’t It?

A good old friend has left the company he had worked for five years. As he said, amazing five years. And when he left, this time and for the first time, he left a farewell celebration, as a song. It’s a song that you can listen, in Portuguese, and the lyrics are translated to English at the end. It went on like this: Another book has come to an end. Together, the conquest, the arrival, mission accomplished. But too, the missing, the trajectory, that good vibe. Another book has come to an end. Together, the conquest, the arrival, mission accomplished. But too, the missing, the trajectory, that good vibe. https://www.udio.com/songs/8T8sTSAa8jS7s1Du8qAjUq?embedable=true https://www.udio.com/songs/8T8sTSAa8jS7s1Du8qAjUq?embedable=true So, that is how he started, his reflective moment. And there are other great ones like that, or done as a reflection or meditation. But to me, as a writer for life, I am following along with my friend here. We know about the book of our lives, I know. But having him see his job’s mission, like a book, he had taken me back to that great way to see our work relationships like books, or like a Tour of Duty if you will. With that, and following along, I ask him and us: reflection or meditation. Tour of Duty Why Not Write a Book? I say this because you said it first. I agree that another book was closed, and what’s next is a book, too. So, as for what’s next, to you and me and to us, I ask, and remind us too, why not write an actual book? you Because with a book, you can move forward. You could really use some time like that, couldn’t you? Could you be sponsored or protected by your own Foundation? So, there we are, allow me to celebrate: what a chance to learn, and to make progress. what a chance to learn, and to make progress. What a chance for you, perhaps, to be closer to that kind of reflective writing that I know matters a lot to you. And as well, to be closer to that very audience that listens to you, the ones who make decisions, the same ones who need to make decisions with good thoughts. With a book, you are too solving a problem — any problem — as you always do, naturally. But it’s interesting too because with a book you may not even need a specific problem. Maybe just a theme is enough. The book takes care of itself, the book unfolds from the theme. With a book, I know, too, that whatever your next book is, it will also help you address those other challenges in the realm of our internal journey. It takes care of a problem for the outer and the things of our inner world. What is interesting about the book is that we know or feel them quite close to us, don’t we? Even if it often feels far away. It’s mixed. And although it may seem lonely, it’s not; we know it too. How a book is such a collaborative journey with the world. It’s a good place to be there, through the journey. A good place and a meaningful duty to commit to. With so many things happening right now, right next to us — on the outside, we know  — and inside too, sometimes thinking about a book can be overwhelming, I know. But, a great writer, Dorothea Brande, in 1934, wrote that “you can write about anything which has been vivid enough to cause you to comment upon it.” This is it, isn’t it? The things we want to comment, the things we want to sing, or yell sometimes too. This is a bit of how I walk now. Watching out, trying to be sensitive to these little sprouts of comments on my way. Comments I used to pass by, missing them, stepping on them. But they were there, and are there: small sprouts trying to break through, to rise, from our fertile garden. Those little things are the links to that vivid enough underlying thing, sometimes huge. It’s worth pouring water and words. Through writing. So I wish you, today, to write an actual book. But if that book of yours doesn’t materialize as a book that looks like a book, yet one thing we have agreed with, already. It will always be a book. Prólogo [Prologue] by Concept ACK [verse] [verse] Another book has come to an endThat mixed, unique, and confused tasteTogether, the conquest, the arrival, mission accomplished Another book has come to an endThat mixed, unique, and confused tasteTogether, the conquest, the arrival, mission accomplished And too, I miss, that trajectory, that good vibe. And too, I miss, that trajectory, that good vibe. So what's the next? So what's the next? [chorus] [chorus] This one is over, what will come next?“All things must pass,” GH tells me This one is over, what will come next?“All things must pass,” GH tells me So much coherence... So much coherence... [verse] [verse] A fresh start not in a hurry, A fresh start not in a hurry, Prologue!After a farewell without bitterness, a see you laterClean inventory, zero hours, no XP...Which class should I choose? Prologue!After a farewell without bitterness, a see you laterClean inventory, zero hours, no XP...Which class should I choose? [intermission][humming la-la-la] [intermission][humming la-la-la] [bridge]In the six-one rhythmThe meter suppresses the pawn... the queen, the bishopNot cool, guys, living by the card? Not cool...What's next? [bridge]In the six-one rhythmThe meter suppresses the pawn... the queen, the bishopNot cool, guys, living by the card? Not cool...What's next? [verse]Today, headphones have given way to the speakerThe sound fills my office...now it's a studioWithout a gold chain, but with historyWho’s going to turn off the light?It's not so dark anymore [verse]Today, headphones have given way to the speakerThe sound fills my office...now it's a studioWithout a gold chain, but with historyWho’s going to turn off the light?It's not so dark anymore [chorus]A sprint without a backlogThe coffee is in another kitchenThe guitar came off the wallThe cursor blinks on the first line [chorus]A sprint without a backlogThe coffee is in another kitchenThe guitar came off the wallThe cursor blinks on the first line Credits: Prologue, by Concept ACK Prologue, by Concept ACK

Every Job Is a Book, Isn't It? 

Welcome to MTP Business Boost — a series of expert publications filled with real-world strategies, transforming complex ideas into simple, actionable advice you can apply immediately (MTP stands for Marketing, Technology, and Psychology). In just 9 minutes, you’ll uncover how AI isn’t just adapting marketing communication for different generations—it’s giving businesses the power to dominate. By leveraging AI-driven personalization and precision, you can craft messages that resonate deeply, drive higher engagement, maximize conversions, and secure long-term customer loyalty. The result? Reduced costs, a stronger competitive edge, and undeniable market leadership. Personalization isn’t just a trend—it’s an expectation. A McKinsey study found that 71% of consumers expect personalized interactions, and 76% feel frustrated when companies fail to deliver them. This frustration often leads to lost sales and weakened brand loyalty. On the flip side, companies that embrace personalization can see revenue increases of 5-15% and a boost in marketing ROI by 10-30%. Without it, businesses risk inefficiencies in customer acquisition and retention, ultimately falling behind their competitors (source). source source Before you dive in, make sure you’re subscribed so you don’t miss the next expert insights packed with practical recommendations. Let’s get started! Weekend on a Yacht and Unexpected Consequences Weekend on a Yacht and Unexpected Consequences The golden hues of the Sydney sunrise painted the glass towers in warm amber as Alex leaned back in his sleek office chair, staring at the analytics report on his screen. His IT startup, a promising SaaS company specializing in cybersecurity solutions, had been steadily growing. But now, the data revealed an unexpected challenge—his customer base spanned multiple generations, each responding differently to marketing messages. What worked for Gen Z seemed irrelevant to Boomers, and Millennials had their own distinct preferences. Frustration crept in. How could he fine-tune his communication without hiring a team of specialists or overhauling his entire strategy? The budget was tight, the stakes were high, and he couldn’t afford to misstep. Just then, his phone buzzed. It was Daniel, an old friend and fellow entrepreneur, but leagues ahead in the game—seasoned, successful, and always three steps ahead. "Mate, your voice sounds tense. You need to unwind. Come spend the weekend on my yacht. A little time away will do you good." Alex hesitated. Leaving work for an entire weekend? Now? But something about Daniel’s tone made him reconsider. And so, with a mix of reluctance and curiosity, Alex accepted. The Sydney Harbour shimmered under the midday sun, a dazzling contrast to the deep blue waters. As Alex stepped onto Daniel’s sleek, state-of-the-art yacht—a floating masterpiece of luxury—he felt an unexpected sense of release. Polished teak, crisp ocean air, and the gentle lapping of waves made the city’s worries feel miles away. Over gourmet seafood and a chilled bottle of vintage Chardonnay, Alex shared his predicament. Daniel listened, nodding knowingly. "You’re making it harder than it needs to be," he finally said. "AI can handle this in minutes. It can analyze generational preferences, tailor messaging to their values and interests, and ensure each group receives communication that truly resonates." Alex raised an eyebrow. AI? Sure, his company used machine learning for cybersecurity, but for marketing? Daniel smirked, pulled out his tablet, and with a few taps, demonstrated how AI could segment audiences, adapt messaging for different generations, and align content with their unique expectations and behaviors. The next morning, back in his office, Alex hesitated for only a second before trying it himself. Within minutes, AI had analyzed his customer segments, optimized messaging for each generation, and provided actionable insights. It was effortless. It was powerful. And it worked. As he leaned back, a satisfied grin spread across his face. This wasn’t just a solution—it was a revelation. For the first time in weeks, he felt in control, ahead of the curve. And to think, it all started with a simple phone call and a weekend on a yacht. Winning Every Generation: AI-Powered Messaging Guide Let’s take an example and see how to adapt a marketing message for different generations. We’ll use a sample ad from a hypothetical SaaS company offering a sales automation product. Here’s the original marketing message: Boost your sales like never before with the ultimate SaaS solution for automating your pipeline! Say goodbye to manual follow-ups and hello to smart workflows that save you time and close deals faster. With AI-powered insights, you’ll know exactly when to reach out to prospects for maximum impact. Try it today and watch your revenue soar in just weeks. Sign up for a free 14-day trial – no credit card required! I recommend taking your own marketing message, following the steps below, and applying them right away. This way, you’ll put the knowledge into practice and see results quickly. Go to chatgpt.com Go to chatgpt.com chatgpt.com 2. Paste the following instruction for the AI and press Enter: Hello. You are a world-class expert in effective marketing communications. I need help adapting the following advertising message for optimal reception by my audience, which consists of the Baby Boomer generation. Hello. You are a world-class expert in effective marketing communications. I need help adapting the following advertising message for optimal reception by my audience, which consists of the Baby Boomer generation. Boost your sales like never before with the ultimate SaaS solution for automating your pipeline! Say goodbye to manual follow-ups and hello to smart workflows that save you time and close deals faster. With AI-powered insights, you’ll know exactly when to reach out to prospects for maximum impact. Try it today and watch your revenue soar in just weeks. Sign up for a free 14-day trial – no credit card required! Boost your sales like never before with the ultimate SaaS solution for automating your pipeline! Say goodbye to manual follow-ups and hello to smart workflows that save you time and close deals faster. With AI-powered insights, you’ll know exactly when to reach out to prospects for maximum impact. Try it today and watch your revenue soar in just weeks. Sign up for a free 14-day trial – no credit card required! Instead of “Baby Boomer,” you can swap in the generation your customers belong to: The Silent Generation (born 1928–1945)


Gen X (born 1965–1980)


Millennials, Gen Y (born 1981–1996)


Zoomers, Gen Z (born 1997–2012)


Gen Alpha (born 2013–2025) The Silent Generation (born 1928–1945) The Silent Generation (born 1928–1945) Gen X (born 1965–1980) Gen X (born 1965–1980) Millennials, Gen Y (born 1981–1996) Millennials, Gen Y (born 1981–1996) Zoomers, Gen Z (born 1997–2012) Zoomers, Gen Z (born 1997–2012) Gen Alpha (born 2013–2025) Gen Alpha (born 2013–2025) Here’s how the AI adapted the message for the Baby Boomer generation: 3. You can also ask the AI to explain why the adapted message works for that generation. Use this instruction: Write a detailed argument explaining why this advertising text is suitable for the generation of my clients. Write a detailed argument explaining why this advertising text is suitable for the generation of my clients. Here’s how the AI explained it in our example: 4. Now, let’s ask the AI to adapt the message for another generation, like Gen Y (born 1981–1996): Now, adapt this advertising message for Generation Y and explain why it is effective specifically for this generation. Now, adapt this advertising message for Generation Y and explain why it is effective specifically for this generation. The AI will also explain why the message fits Gen Y. 5. You can also have the AI adapt the message for all generations at once to compare them: Adapt this advertising message for all generations and present the results in a table format Adapt this advertising message for all generations and present the results in a table format 6. Plus, you can get the table as an Excel file: Generate this table in Excel format Generate this table in Excel format Besides Excel, the AI can provide the results in CSV or PDF formats. 7. You can also ask the AI for specific tips on communicating with your customers’ generation. In our example, try this instruction: Write the most effective recommendations for communication with the Baby Boomer generation. My product is a sales automation service Write the most effective recommendations for communication with the Baby Boomer generation. My product is a sales automation service 8. To make your communication with clients as effective as possible and avoid missteps, ask the AI: What mistakes should be avoided in communication with the Baby Boomer generation and why? What mistakes should be avoided in communication with the Baby Boomer generation and why? 9. After getting a lot of information from the AI, you can ask it to summarize everything into a handy PDF: Summarize all the information in this dialogue and present it in PDF format Summarize all the information in this dialogue and present it in PDF format Here’s what the AI-generated PDF might include: Extra Tips With AI, you can adapt almost any type of marketing communication: emails, Google Ads, social media posts, sales proposals, landing page content, and more. If you have data on your customers’ ages, you can group them by generation and make your communication even more personal and targeted. For example, if your email list has 100,000 subscribers—30,000 from Gen X and 70,000 from Gen Y—a single generic email might not work as well as two versions tailored to each generation. Now you know how to do this with AI, and it only takes a few minutes! Test the results to see the impact of adapting your marketing for specific generations. For instance, when sending an email, create two versions and check which one gets better conversions. Summary In this article, you’ve learned how to easily and quickly adapt your communication with clients based on the psychological perception of the generation they belong to. If the knowledge you gained from this article has been valuable and helpful to you, you can show your appreciation to the author by making a donation via this link or giving a like and sharing it. this link this link Would you also like to learn more about how AI can be used to grow your business and increase your market share? Feel free to leave your questions in the comments! About the Author Gene Misiev is a marketing expert with over seven years of experience in digital marketing. He thrives in highly competitive "red ocean" B2B markets. His focus is on growth marketing, market research, and strategic development for a complex SaaS product—a tender platform for government and private procurement. He has completed advanced training in Strategic Marketing and Generative AI applications in business at the Institute of Applied Technology (Australia). He has also undertaken specialized courses in leveraging ChatGPT for business and marketing automation. See You in the Next Issue Thanks for reading! Make sure you’re subscribed so you don’t miss the next publication, which will bring even more insights to help you expand your business empire with the power of marketing, technology and psychology.

Want to Boost Your Sales? AI Knows Exactly How to Speak to Every Generation

The tech industry is at the forefront of cutting-edge innovation. Everywhere you turn, someone's talking about disruption, transformation, or unlocking new possibilities – but the truth is, not every new tech trend aligns with actual user needs. And as product managers, we would do well to remember that the innovation should always serve the customer, not the trend. Last week, I was invited to share my experiences of leading product at companies working with emerging technologies like artificial intelligence (AI) and the new iteration of the internet focussed on data ownership (web3) on a Product People webinar. Using a few examples from my career, I argued for ignoring the hype and focussing on solving real user needs – aligned, of course, to business objectives – when introducing AI or web3 into the product. Product People webinar Understanding the temptation Understanding the temptation Of course, it's tempting to jump on the bandwagon. After all, if everyone is hyped up about something, shouting about how it's going to change the world, that energy can be contagious. Even more so in the tech sector, where we're all afraid of missing out on the next big thing. So whether it's accepting crypto or integrating AI tools, there's often pressure – from consumers, from leaders, from investors, hell, even from ourselves – to "do something with the trend". But here's the catch – just because we have access to a new technology doesn't mean it makes sense for our users. A cautionary example is the way businesses have been introducing AI chatbots. Sure, you can now say that you're AI-powered, but how is the experience for your typical user? Far too often, poorly executed chatbots frustrate users rather than helping. Instead of enhancing their interaction with your product, it can lead to friction as they struggle to get access to human support agents. In other words, adding AI just for the sake of it can end up alienating the very users it's meant to serve. It's not all about the tech It's not all about the tech This tends to happen because we get so caught up in the possibilities of the technology that we forget the most important thing, what problem are we solving? This is especially relevant when we talk about driving adoption of new technologies. technology what problem are we solving I was once on a panel with a woman who'd been an early adopter of Bitcoin and blockchain-based currencies more generally, and she drew a comparison with the success of Skype and no one caring about Voice over Internet Protocol (VoIP). The underlying technology is secondary. Its main purpose is helping you achieve your goals quickly and easily. Skype helped connect you to relatives across the world without paying exorbitant fees, that's the value. helping you achieve your goals quickly and easily that's The other interesting thing to highlight from my fellow panellist's observation is that, of course, it benefits from hindsight. We know (as we knew then) what problems Skype was solving, but we didn't know at the time whether the Skype protocol would win over the other variations of protocols being developed. I must admit that I don't know the history in detail, but I would hazard a guess that user experience had something to do with Skype's ultimate success. hindsight didn't In the same way, blockchain is just the facilitator[1]. Of course, there are significant advantages in terms of security and permanence, but ultimately, it's about the problem it's solving for users. And right now, it's lacking on the user experience side, though we have made great strides in improving this. I'm personally a firm believer that blockchain, crypto, NFTs, and especially AI do add value, but my overarching point is that we as product managers need to look past the technology and solve for users. have do Uncovering the "why" Uncovering the "why" As such, when it comes to our users, we need to get to know them so well that we can anticipate their needs and build solutions without worrying about the underlying technology. There's the often-quoted Henry Ford statement that if he had asked user what they wanted, they would've said a faster horse. While it's unlikely that he actually said this, not the least because he didn't actually invent the car, the quote conveys an important point about the user need state to (a) get somewhere faster and (b) to be able to afford it. Ford's invention, therefore, becomes the solution to a very specific problem – getting from point A to point B more efficiently. without worrying about the underlying technology Therefore, it's always a good idea to take a step back and ask a simple question: why? Why are we adding [insert feature here]? If you can't answer in a way that addresses a key business objective, whether that's increased revenue, improved retention, better engagement, or whatever else, through a better customer experience, it's time to reconsider. It's easy to get caught up in the hype and think that blockchain or AI or some other new technology is the magical silver bullet solution, but you can't lose sight of what you're trying to achieve – both as a business and as the product with the customer top-of-mind. why The benefits of web3 and AI The benefits of web3 and AI So what benefits are there in web3 and AI? Of course, we haven't yet reached the mass adoption of, say, Skype circa 2013, and it remains to be seen whether we will from a consumer side. From the consumer side, there's a disconnect between the promise (store of value) and the reality (speculation) of crypto, as well as the promise (owning IP) as well as the reality (again, speculation) of NFTs – so while the technology is innovative, the why hasn’t been fully addressed, at least not for consumers. But blockchain is already being used in government and business applications. Estonian and American government bodies, for example, are using the KSI blockchain for protecting privacy and security. Governments and big companies store value in bitcoin. are consumer side why is And then when we think about AI, it's more of the same. Maybe we haven't quite identified the overarching why of consumer AI, though in my personal opinion, it's just a matter of time before mass adoption for the simplification of mundane tasks (my mother regularly uses DeepL to check her English, neurodiverse acquaintances swear by ChatGPT for tackling simple emails that would otherwise take hours, etc). From a business perspective, however, AI is already embedded into our meeting software, into collaboration tools, and even into the core of software development through tools like GitHub Copilot, with more use cases added daily. why Knowing when to pivot Knowing when to pivot A few years ago, I was working with a company that encountered this very problem – it failed to find product market fit among consumers, but found it for businesses. This was a mission-driven crypto startup focussed on bringing Bitcoin to emerging markets as a hedge against inflation. We gamified the experience, rewarding users with small amounts of bitcoin for engaging with the platform. On paper, this seemed like a great way to build user engagement, but the reality was that this didn't support our business goals long term. consumers businesses Given the market and the industry, we had to do everything by the book – complying with regulation, receiving the necessary licenses, partnering with banks and authorities. This was not without its challenges, often financial. It quickly became apparent that our target audience wasn't able to sustain our growth ambitions, and while target users were using us to earn bitcoin, we weren't seeing enough traction in terms of transactions to make any money off the exchange. Now, I was young, a bit naïve, and so committed to the mission as central to the product – in other words, the technology and the mission became inextricably entwined for me – that I left when the CEO decided to pivot, leveraging all our banking relationships and licenses to actually improve the experience of transferring money to more complicated regions using blockchain rails and our user-friendly UI. But with the wisdom of hindsight, I can admit that this use case actually solves a problem and adds value for users, and, from a business perspective, it's a clever repackaging of our existing tech and partner stack to solve a different problem for a different set of users. These new users don't care that the money transfers are cheap and convenient because of blockchain, they just care that they're cheap, secure, and get the funds to a heavily regulated market compliantly. because When technology becomes the solution to a problem that doesn't exist When technology becomes the solution to a problem that doesn't exist But it doesn't always work that way. Sometimes, we want to work the technology into the solution so much that the problem we're solving for users is forgotten. In another company I worked for, the founding mission was the ability to register Certificates of Authenticity for physical artworks on the blockchain as a permanent record, which matters to artists who want to track provenance. Blockchain was seen as a solution to the question of permanence, as well as security. The issue was adoption – this is an issue for the art world generally, why there isn't a single database of Certificates of Authenticity is that each artist, gallery, museum or whatever it may be issues their own, which makes it difficult to track and authenticate. So while there was a use case, the same issue pursued the startup, because in order for these Certificates to continue to exist as intended to, they needed to be transferred alongside the artwork. This was then complicated by the emergence of NFTs and our company's entry into the space, because NFTs were intended, first and foremost, to serve as proof of ownership in and of themselves – you own the NFT, therefore you own the underlying art, and any transactions are visible on the blockchain, therefore establishing provenance. However, instead of doubling down on the use case and pursuing the vision of establishing an immutable repository of Certificates, we focussed on the technology, and tried to certify NFTs alongside physical works. The logic being that NFTs can be faked, because it's easy to make an NFT with an underlying image that isn't your artwork – though, of course, NFTs track which address created the artwork, so the artists for whom this matters can prove or disprove authorship anyway. So how does this all reflect on the problem we were trying to solve? Well, the issue is that the decisions we were making (pursuing NFTs in parallel to certification) were contradicting the why of what we were doing (establishing authenticity of certification). And, of course, the big one – we were solving a very niche problem in a very complicated way, which prevented us from driving adoption by focussing on simplifying user needs. The main takeaway being, of course, that before getting too carried away with how to build the solution, determine whether the problem being solved matches your business objectives. simplifying Build or buy? Build or buy? To top it all off, there's the additional consideration of whether to build the solution yourself or to delegate the work to a third party. This becomes especially relevant when it concerns AI, because ownership of the underlying data model is a competitive advantage. In my current organisation, we have a number of products that are introducing AI-powered solutions that address specific user need states, such as manual and labour-intensive purchase invoicing. This kind of repetitive process with clear parameters is ripe for AI automation. Why AI? Because it needs to account for nuance in business operations, which is why attempting to address it with rule-based processing is not sufficient. But this kind of solution comes with additional considerations of tradeoffs (time-to-market versus long-term value, as well as who builds it and who handles the legal questions like data processing), all within the context of the breakneck pace of AI. nuance In Silverbucket, the product I am currently working on, there are many areas in which we can improve usability through AI, both internally and customer-facing. The important thing is to recognise what is actually relevant for us – for example, there's no need for us to screen "easy" customer service queries trained on our knowledge base, because we don't typically get any queries that don't require engineering. This then paves the way for a more comprehensive question of how to build AI assistants for our customers, because a simple AI chatbot for the sake of it is unnecessary. The main question that we need to answer when we think about how our solution addresses user needs is, how do we facilitate the user's intended result in the easiest way possible? As you can see, that last question doesn't say anything about AI – but in our day and age, this can very well end up being the answer, which is something that we're therefore obligated to explore as a potential (but not only) solution. how do we facilitate the user's intended result in the easiest way possible? Conclusion Conclusion The main takeaway is that companies need to solve real pain points, and the technology is just there as a facilitator. If we use it correctly, our users benefit; if we don't, we risk alienating them. The only thing we can really rely on is continuous discovery – watching users, speaking to them, looking at product analytics, exploring their need states, and understanding how to solve their problems, and this can be with or without web3, blockchain, AI or whatever new technology appears on the horizon. [1] I do want to sound a note of caution here, because AI is a bit of a different beast, the inputs do matter, because they can replicate existing inequalities or spread misinformation, but that's somewhat of a different conversation. do

Stories, News & Mentions about EVERY

Every’s Stories on HackerNoon

Every's News & Mentions