<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by BOOM on Medium]]></title>
        <description><![CDATA[Stories by BOOM on Medium]]></description>
        <link>https://medium.com/@boomimagestudio-techblog?source=rss-2f6b5752c28e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WtA0l-mDe7nev8EV6UVT2g.png</url>
            <title>Stories by BOOM on Medium</title>
            <link>https://medium.com/@boomimagestudio-techblog?source=rss-2f6b5752c28e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:36:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@boomimagestudio-techblog/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How to plan and execute a marketing campaign with BOOM Worksite]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/how-to-plan-and-execute-a-marketing-campaign-with-boom-worksite-9cb7d95bccad?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/9cb7d95bccad</guid>
            <category><![CDATA[advertising-campaign]]></category>
            <category><![CDATA[digital-workplace]]></category>
            <category><![CDATA[marketing-campaign]]></category>
            <category><![CDATA[digital-asset-management]]></category>
            <category><![CDATA[agencylife]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Wed, 17 Aug 2022 14:44:06 GMT</pubDate>
            <atom:updated>2022-08-17T14:51:33.100Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ov-DSryrJ18gTuVH.jpg" /></figure><p>There is no stronger way to persuade and communicate a product, brand, or event than with an advertising or <strong>marketing campaign</strong>. A great way to get a message across through a series of <strong>strategic activities</strong> and <strong>communication tactics</strong>, a campaign is a powerful way to make an impression in the collective consciousness, either through distribution on traditional media, digital touchpoints, and social media, or with more out-of-the-box guerilla marketing tactics. For a marketing team or a creative, digital, or advertising agency, creating a campaign offers team members a chance to expose their best work and let it reach the greatest number of people. A campaign mobilizes the best of every person’s talent and creativity. Whether a campaign supports the launch of a new product or service, a brand revamp, or an event, it should always inspire and persuade. For the people behind the campaign, it is always an opportunity to make the most of everyone’s talent and creativity.</p><h3>What are the three phases of a campaign?</h3><p>A creative campaign is usually divided into three main phases: <strong>strategy, creative concept,</strong> and <strong>execution</strong>.</p><h4>Strategy</h4><p>The strategy part of the campaign is about defining the brand’s <strong>objectives</strong> and needs. It is about understanding the brief and figuring out strategies to tackle the goals requested by the brand’s stakeholders. The strategy part of campaign creation usually involves a competitor analysis, identifying the brand’s positioning, the budget, the brief, and the outcomes expected from the campaign.</p><h4>Creative concept</h4><p>Once the strategy is set up and clear for everyone involved, comes the time for creativity. Which <strong>creative directions</strong> will meet the brief? This phase is a sweet spot to allow creative teams to explore and <a href="https://boom.co/resources/how-to-run-brainstorming-sessions/">brainstorm ideas</a>, seek inspiration, and experiment. Presenting three different creative routes to stakeholders is a good way to test different directions and options.</p><h4>Execution</h4><p>After defining the concept and creative route comes the time to take the plunge and start developing the campaign’s different moving parts. Define a list of deliverables required, along with the different moving parts, and get your creative team to start <a href="https://boom.co/resources/3-steps-visual-content/">creating and developing visual content </a>and material.</p><h3>How can BOOM Worksite support campaign execution?</h3><p>The execution of a campaign involves many moving parts, many team members, and often many different visual assets and files. In other words, <strong>centralization</strong> is essential to the <strong>success and productivity of a well-executed campaign</strong>. If you’re running on a tight deadline and schedule, and have a long <strong>list of deliverables</strong> to develop — depending on the approval of many different stakeholders — the last thing you want is to lose or misplace files, misunderstand which images should be used, or which video footage should be edited within the hero campaign. A DAM solution like <a href="https://boom.co/features">Worksite</a> <strong>centralizes file management</strong> and the <strong>workrooms</strong> can help <a href="https://boom.co/resources/4-ways-efficient-workflow/">streamline the workflow </a>and <a href="https://boom.co/resources/6-steps-team-collaboration-creative-studio/">optimize teamwork</a>.</p><h3>Worksite optimizes the execution of your campaign through:</h3><h4>Version control</h4><p>Like any project with many rounds of feedback and revisions, it’s very likely that the videos and images you’re working on will be updated, edited, and adapted for different channels and touchpoints. As such you need to make sure that you can keep track of the different versions uploaded and presented to the team. Worksite can help creative teams ensure they always work on the correct file version. At the same time, if multiple team members find themselves collaborating on the same asset, version control ensures that they all work on the same page (literally), with amendments visible in real-time. And when clients or account managers get involved, version track can allow them to see who did what, with the ability to compare multiple versions side by side.</p><h4>Streamlined workflow</h4><p>When you create a workroom on Worksite, you can use that dedicated space to workshop the visual assets for that particular project. Once you create a workroom for your campaign’s many <strong>key deliverables</strong>, you can insert the visual assets that’ll be useful for the project — either as references or as content to be adapted and worked on — and assign tasks to different team members so that they can do their job and later upload and refresh visual assets on the Worksite.</p><h4>Improved communication</h4><p>The workrooms include a number of <strong>communication and collaboration features</strong> that optimize communication across the project. Members can <strong>comment</strong>, mention each other, <strong>ask for revisions</strong>, and <strong>approve/replace visual assets</strong>. These communication features can also improve <a href="https://boom.co/resources/5-tips-agency-client-relationships/">client-agency relationships </a>(assuming that the campaign is handled by an agency). How? In a workroom, an account manager can give <strong>customized access</strong> to clients, either to <strong>edit </strong>or just <strong>visualize</strong> final content, and <strong>give approval or ask for revisions</strong>.</p><h4>Social media adaptation</h4><p>If your creative team and all the graphic designers are busy post-producing visuals, creating banners, and fantastic material pieces for the campaign, chances are they don’t have time to <strong>crop images</strong> and <strong>adapt them for social media</strong>. When you’re in an “all hands on deck” mindset in the middle of campaign execution, there will come a time when a non-creative will have to do <strong>last-minute edits</strong> on visual assets. Worksite is equipped with <strong>editing tools</strong> that’ll let you <strong>crop</strong>, <strong>resize</strong> and <strong>customize</strong> your visuals to fit different <strong>social media formats</strong> (presets included in Worksite!)</p><h4>Sharing and publishing</h4><p>When your campaign is ready, the deliverables will evidently need to be distributed beyond the storage capacity of Worksite. <strong>Sharing and publishing</strong> on digital touchpoints is a no-brainer, with dedicated CDN links that allow anyone to copy and paste links to publish <strong>images</strong> and <strong>videos</strong> anywhere on the web.</p><h4>Interested in using Worksite for your upcoming campaign?</h4><p><a href="https://login.boom.co/auth/realms/platform-production/protocol/openid-connect/registrations?client_id=customer-frontend&amp;response_type=code&amp;scope=openid&amp;redirect_uri=https%3A%2F%2Fcustomer.boom.co%2F">Sign up for FREE</a></p><p><em>Originally published at </em><a href="https://boom.co/resources/how-to-execute-marketing-campaign-worksite/"><em>https://boom.co</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9cb7d95bccad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Big Picture Eventstorming: A Guide on How to Explore with a Fast Learning Curve]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/big-picture-eventstorming-a-guide-on-how-to-explore-with-a-fast-learning-curve-b43b91902197?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b43b91902197</guid>
            <category><![CDATA[learning-curve]]></category>
            <category><![CDATA[eventstorming]]></category>
            <category><![CDATA[ddd]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Wed, 30 Mar 2022 10:31:39 GMT</pubDate>
            <atom:updated>2022-05-13T12:37:06.712Z</atom:updated>
            <content:encoded><![CDATA[<p>Ever read lots of documents to figure out how a process works?</p><p>Ever spoken to other departments to better understand the overall process?</p><p>Ever drawn a diagram with all the interactions with your software?</p><p>If you’ve ever tried the methods above to cover the subset of the system to explore, chances are you might have been partially or totally unsuccessful.</p><p>With <strong>Big Picture Eventstorming</strong> you will see the “big picture” in a single comprehensive diagram and you will reach this goal by sharing knowledge and problems, as well as clarifying doubts, so that anyone involved in this experiment will learn something.</p><h3>What is Big Picture Eventstorming?</h3><p><a href="https://www.eventstorming.com/">Big Picture Eventstorming</a> is a DDD technique invented by Alberto Brandolini to explore the state of the art of your software with the collaboration of business, tech and UX professionals.</p><p>He starts with the assumption that when it comes to organizations where people are working together towards a common goal we are in some form of Complex Adaptive System, which is a network of interdependent agents influencing each other.</p><p>Its main characteristic is a complex adaptive system that won’t behave as expected!</p><p>This technique has the ability of explaining complex situations with a simple narrative. It reinforces the collaboration between the “experts” and the others, throwing down the silo effect.</p><h3>How does it work?</h3><p>Gather all the key people, build together a model of the current understanding of the system.</p><p>Add details to your model incrementally with a facilitator in a time box diagram with certain phases.</p><h3>Does it work remotely?</h3><p>The first version of the Brandolini’s unfinished <a href="https://leanpub.com/introducing_eventstorming">book</a> said that it didn’t work remotely.</p><p>Then the Covid19 pandemic came, and of course Alberto himself had to change his idea and let it work remotely but with some limitations.</p><h3>How can I start?</h3><p>You can start with a simple example, for example with a story that everyone knows (like Little Red Riding Hood or the three Little Pigs) to introduce some key concepts:</p><ul><li>Events (orange sticky note): This is a domain event, relevant for experts exposed with past tense verbs such as “Challenge Accepted”. An event is a fact, a thing that happened, something precise and relevant. It should be the result of an action or a user interaction, it should be triggered by external systems, it should be triggered by time or it should be the result of a cascading reaction or simply a consequence of another event.</li><li>Timeline: your board is chronological time space with time moving forward from left to right (put an arrow on the board to make this concept visible).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WWjgyOUxtUXQtxY9" /></figure><p>Everyone should feel free to add a sticky note to complete the story.</p><p>Only relevant facts must be added, and anything that isn’t relevant to the narrative should be left out (e.g. the “what big eyes you have” dialogue).</p><p>The point is not to tell a story but to better identify the main events that make up the process.</p><p>Once the main principle is understood, we can move on to the different phases.</p><h3>The phases</h3><p>The final result will come out once we get through the following the main phases.</p><p>Phases:</p><ol><li>Chaotic Exploration: place sticky notes with events that make up your business process in the timeline. Everyone should feel free to add sticky notes.</li><li>Enforce the timeline: put events in the right chronological order, set pivotal events or swimlanes when processes take different paths. Extract key chapters.</li><li>People and Systems: add persons which play a role in our model and add external systems as something outside our control (“whatever we can put the blame on”).</li><li>Explicit Walk-Through: storytelling of all the events starting from the first. After the first round, do a second in the reverse order, starting from the last and coming back.</li><li>Problems and Opportunities: everyone is now free to put a red sticky note on hotspots or a green sticky note to raise opportunities.</li></ol><h4>Phase 1: Chaotic Exploration</h4><p>In this phase we should add all the relevant events that come to our mind. Everyone should feel free to add sticky notes to enrich our process and no one should remove them (except the facilitators).</p><p>If you find yourself with duplicated events with different terminology, do not block this useful momentum as different terminology raises important ubiquitous language problems that we should solve in the next phases.</p><p>This phase could last 15 minutes to hours. It depends on the complexity of the process you are trying to explore. Like with any other phase, the important thing is that it should be time boxed.</p><h4>Phase 2: Enforce the timeline</h4><p>The facilitator takes the reins of the meeting and the group starts to put some order in the timeline. The facilitator unveils the process, removing duplicates but keeping the events exposed with very different terminology. The facilitator is there to facilitate the process, all the decisions must be made by the group.</p><p>When problems or questions arise throughout this phase, it is important to write them down on the red “hotspot” sticky note and leave the “hotspot” near the problematic events.</p><p>Then, the groups should work to organize the flows using one or more of the following elements:</p><ul><li>Pivotal Events: the most relevant events “pivot” with a vertical line to better separate the different “phases” of our process.</li><li>Swimlanes: some part of the process will be split into two parallel sub-processes, using a horizontal line to reinforce this concept.</li><li>Temporal milestone: it is possible to have events triggered by time, so put this temporal milestone (+1 month, +1 year) on the flow with a blue sticky note.</li><li>Chapter sorting: if the process is too long you can decide to extract the key chapters, order them separately and then rebuild the timeline.</li></ul><h4>Phase 3: People and Systems</h4><p>In this phase, two new elements should be added:</p><ul><li>People: yellow sticky notes for each person with a specific role in the model.</li><li>External system: pink sticky notes for every external factor (remember, Alberto wrote “whatever we can put the blame on”).</li></ul><p>The group will enrich the diagram with “people and external systems” to have a better understanding of the actors playing a role in our processes.</p><h4>Phase 4: Explicit Walk-Through</h4><p>In this phase the facilitator will take a domain expert to do an extended narrative of the process starting from the first event until the last.</p><p>With the explicit walk-through phase, you might realize that you had missed some important events before, and this will allow you to reorganize accordingly.</p><p>If there’s enough time the facilitator will take another domain expert to do a “reverse narrative” starting from the last event to the first.</p><p>This will help clarify possible doubts and make sure that everyone is on the same page.</p><h4>Phase 5: Problems and Opportunities</h4><p>In this phase the facilitator will invite all participants to raise:</p><ul><li>problems: a red sticky note with the description of the problem.</li><li>opportunities: a green sticky note with possible improvements or new opportunities in terms of technology or business.</li></ul><p>After the first part, people can vote for the most crucial problem or greatest opportunity by signaling it with an arrow on a sticky note. This will lead to a list of priorities and possible future developments.</p><h4>The result</h4><p>After the first 4 phases the results look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/914/0*hH6exV1tzvPuz3bt" /></figure><p>What are the main problems for the online version?</p><p>1. Number of people involved</p><p>The “live” version is better for engagement and can include as many participants as we want, while the online version thrives on smaller groups (no more than 8 people), with no possibilities to carry on multiple conversations at the same time. The limited number of people in an online version makes it even more important to select and invite essential participants only.</p><p>2. Chaotic exploration could become unmanageable</p><p>The chaotic exploration due to the missing natural subgroups and conversations that take place in person, could make the remote experience more difficult. In a real room, the facilitator can check on the subgroups, correct them or recall the rules if necessary. When the experience is conducted digitally, the facilitator could make up for the lack of personal interaction by presenting a board with the main pivotal elements, which would help everyone have some reference point for the chaotic exploration.</p><p>3. Attention threshold</p><p>While splitting up into subgroups tends to happen naturally in live sessions, a remote experience forces people to face a monitor, which doesn’t help retain attention. If a live session lasts an entire day, an online version should be split into several sessions, each one lasting no more than two hours (90 mins is what we would recommend).</p><h3>What are the benefits of this experiment?</h3><p>1. Determining your internal process and breaking down the silo effect</p><p>Gathering people who usually work in different departments could help the company have a better view of the overall process and break down the silo effect. This will help departments feel less isolated and more involved in the overall strategy to achieve organizational goals.</p><p>2. Determining the strengths and weaknesses of your process</p><p>Seeing the entire process should make it easier to identify strengths and weaknesses. The system can help everyone identify the problems of their department and help determine issues in the overall flow. The same consideration is also valid for the strengths that could help shed light on the things that work and don’t need improvement.</p><p>3. Speeding up the learning curve for newcomers</p><p>A newcomer will get a descriptive diagram for the overall process. This will save months of training and give a clear starting point.</p><p>4. A checkpoint for your startup</p><p>In a startup, this kind of experiment must be repeated every six months, to get a good snapshot of your company’s organizational status and process evolution. It can serve as a checkpoint to find out how old problems have been solved and whether old strengths are still valid or not.</p><p>5. A starting point for more deeper analysis</p><p>You can select a subset of the overall process worth troubleshooting and explore it in greater depth. You can use this as a starting point for a ContextMap session to better understand the interactions between our software domains. You can use this as a starting point to design a new part of your software.</p><h3>Is it worth it?</h3><p>At BOOM, the engineering team used this system to explore obscure processes of the BOOM Factory’s production department and the result was astonishing.</p><p>In two sessions (less than three hours total), we discovered the part of the reverse engineering process that a single person would take months to go through.</p><p>We also used Big Picture Eventstorming to explain our main platform processes to newcomers.</p><p>In less than two hours, they managed to grasp the entire process, which would have been impossible without this system.</p><h3>Learn More</h3><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Andrea Bersani, Tech Lead.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b43b91902197" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What you Need to Know about Complex React Architecture]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/what-you-need-to-know-about-complex-react-architecture-66ae41e32abc?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/66ae41e32abc</guid>
            <category><![CDATA[repositories]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Mon, 21 Mar 2022 08:39:11 GMT</pubDate>
            <atom:updated>2022-03-21T08:39:11.173Z</atom:updated>
            <content:encoded><![CDATA[<p>As we all know, React allows developers to build applications quickly and easily, simplify the creation of custom interactive user interfaces, and focus on UI execution perfection.</p><p>When the application is created from scratch, everything seems easy and well connected, but as soon as the app grows, the components become confusing and mixed up with one another.</p><p>This article will unveil ways to avoid common mistakes during the growing phase of app development.</p><h3>The plain react architecture</h3><p>Most commonly, React suggests the simple division of all folders in the following way:</p><pre>└── /src<br>    ├── /assets<br>    ├── /components<br>    ├── /context<br>    ├── /hooks<br>    ├── /pages<br>    ├── /services<br>    ├── /utils<br>    ├── App.ts<br>    ├── Routes.ts<br>    └── index.ts</pre><p>This plain way of structuring the application works if we keep everything inside the same context, which is very useful for a mono-scope application (e.g. a to-do list): everything is separated by its own class type and you can write the application very fast by just following the web results.</p><h3>The modularized React architecture</h3><p>This is an evolution from the previous style, where you could handle multiple contexts:</p><pre>└── /src<br>    ├── /assets<br>    ├── /firstModule<br>    |   ├── /components<br>    |   ├── /context<br>    |   ├── /hooks<br>    |   ├── /services<br>    |   ├── /redux (module only)<br>    |   └── /utils<br>    ├── /secondModule<br>    |   ├── /components<br>    |   ├── /context<br>    |   ├── /hooks<br>    |   ├── /services<br>    |   ├── /redux (module only)<br>    |   └── /utils<br>    ├── /shared<br>    |   ├── /components<br>    |   ├── /context<br>    |   ├── /hooks<br>    |   ├── /services<br>    |   └── /utils<br>    ├── /redux (global)<br>    ├── /pages<br>    ├── App.ts<br>    ├── Routes.ts<br>    └── index.ts</pre><p>This structure is more complex but allows a clearer separation between the various scopes: each module has its own components and should not talk to each other. The only exception is for the “Shared” folder, which is made exclusively to handle shared tools to be used everywhere.</p><h3>The clean architecture (applied to React)</h3><p>As many of you know, modern applications are divided into backend and frontend, often spread among different people with different projects, so modifications are done within separate pipelines.</p><p><strong>Separate pipelines mean separate release timing.</strong></p><p>So that also means that an API interface could change fast and/or break your frontend application in a very easy way. To prevent this, we need to introduce the concept of layers.</p><p><em>Note that this kind of architecture is widely used in backend apps, to separate the database, business logic, and API sections but, unlike the backend one, we are not going to introduce the Dependency Injection or Inversion of Control patterns.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/821/0*RlqtEcKArcKddvjs" /></figure><p>All three layers (presentation, application, and infrastructure) are made to communicate with their “siblings”, but the first and last cannot communicate with each other.</p><p>This separation is intentional since it allows relevant logic to be contained exclusively within the Application layer, which serves as a link between the other two.</p><p>This clear separation provides us with a few advantages in comparison to the previous architectures:</p><ul><li>Changes from backend will be confined inside the Infrastructure layer</li><li>To handle multiple backend releases with breaking changes, we can still develop the new changes coming out and “switch” to the new one only when needed inside the application layer (maybe under a toggle or a fallback logic)</li><li>Changes in styles will never impact application logic or backend calls</li></ul><p>This is the common breakdown for the Clean Architecture applied to React (don’t worry if it’s complex, we will explain it in more detail):</p><pre>└── /src<br>    ├── /assets<br>    ├── /presentation<br>    |   ├── /pages<br>    |   ├── /module1<br>    |   |   ├── /pages<br>    |   |   ├── /components<br>    |   |   ├── /context<br>    |   |   └── /hooks<br>    |   ├── /module2<br>    |   |   ├── /pages<br>    |   |   ├── /components<br>    |   |   ├── /context<br>    |   |   └── /hooks<br>    |   └── /shared<br>    |       ├── /components<br>    |       ├── /context<br>    |       ├── /hooks<br>    |       └── /utils<br>    ├── /application<br>    |   ├── /types<br>    |   ├── /services<br>    |   └── /redux<br>    ├── /infrastructure<br>    |   ├── /api<br>    |   |   ├── /mappers<br>    |   |   └── /dtos<br>    |   ├── /websocket<br>    |   |   ├── /mappers<br>    |   |   └── /dtos<br>    |   └── /otherservice<br>    |       ├── /mappers<br>    |       └── /dtos<br>    ├── App.ts<br>    ├── Routes.ts<br>    └── index.ts</pre><p><em>Note: due to the highly nested levels, it is highly recommended to use the barrel files (aka index.ts) to shrink the imports.</em></p><h3>The Presentation Layer</h3><p>The presentation layer, which is responsible for displaying the user interface and interacting with the user, is usually one of the largest layers inside the structure, and reads from the application layer and displays the views to the user. It is split into the following parts:</p><pre>├── /presentation<br>    ├── /pages<br>    ├── /module1<br>    |   ├── /pages<br>    |   ├── /components<br>    |   ├── /context<br>    |   └── /hooks<br>    ├── /module2<br>    |   ├── /pages<br>    |   ├── /components<br>    |   ├── /context<br>    |   └── /hooks<br>    └── /shared<br>        ├── /components<br>        ├── /context<br>        ├── /hooks<br>        └── /utils</pre><p><strong>The pages folder</strong> contains all the common pages to be displayed <strong>independently</strong> from the context (e.g. error pages, status pages, etc.)</p><p><strong>The shared folder</strong> contains what could be useful to be reused multiple times inside the other modules, like the inputs, own style library, or common hooks and/or utilities.</p><p><strong>The module folders</strong> contain all the other content useful to make the application visible and reactive. All of the items placed inside must be part of the same contextual idea; if something is shared with some other module, it should be moved into the “shared” folder.</p><p>The pages folder inside a single module is for page components made to match that specific route. Those components should only handle the routing parameters and/or access permissions, and then return some other components passing the right values as a prop.</p><p>To ensure the stability of this design, one rule must be followed strictly: <strong>modules should not import each other’s elements</strong>. If communication is needed, they should use the application layer or the shared folder items.</p><h3>The infrastructure layer</h3><p>The infrastructure layer is responsible for handling the communication with external services, like APIs, WebSockets, or third-party services.</p><pre>├── /infrastructure<br>    ├── /api<br>    |   ├── /mappers<br>    |   ├── /dtos<br>    |   ├── myApiMethod1.ts<br>    |   └── myApiMethod2.ts<br>    ├── /websocket<br>    |   ├── /mappers<br>    |   └── /dtos<br>    └── /otherservice<br>        ├── /mappers<br>        └── /dtos</pre><p>The folders are structured by Service and contain the same sub-structure inside each one. It is composed of:</p><p><strong>Dtos folder</strong>, containing all the files to declare the service interfaces. It is strictly related to the service (e.g. API) and should not be adapted to the internal domain or logic.</p><p><strong>Mappers folder</strong> contains classes (with their own tests) able to convert data from Dtos to application layers’ types. This conversion ensures the flexibility of the infrastructure layers during the changes.</p><p><strong>The files</strong> inside the folders are all the declarations needed to make the communication work, including calling the service and returning a converted response using the mappers.</p><h3>The application Layer</h3><p>The application layer is responsible for applying business logic inside the app, it can interact with all the modules present in the presentation layer and call the services declared inside the infrastructure layer.</p><p>Types and classes are defined here in order to better satisfy the responsibilities at the mass center of the whole app.</p><pre>├── /application<br>    ├── /types<br>    ├── /services<br>    └── /redux</pre><p><strong>Types folder</strong> contains interfaces, enumerators, and types needed to define all the data that flows inside the whole structure.</p><p><strong>Services folders</strong> contain functions or classes made to bring calculations on the table or execute specific flows from/to the Infrastructure layer.</p><p><strong>Redux</strong> contains the classic Redux structure to support his pattern: Actions, Reducers, Selectors, and Middlewares. The structure could change depending on external tools or add-ons.</p><h3>A real project example</h3><p>Picture this scenario: one of our customers asked to create an application to keep track of the bookings in his hotel. The application is composed of:</p><ul><li>An order section, made with the routes to view, create, edit and delete</li><li>A dashboard page to display the sales of the month</li></ul><p>So as soon as our backend people received the specifics, they made up this standard Rest API:</p><ul><li>/orders (get, post, put and delete methods to make all the CRUD operations)</li><li>/dashboard (get only to retrieve the data)</li></ul><p>So, after reading all of these, we made up this structure (explanation below):</p><pre>└── /src<br>    ├── /assets<br>    ├── /presentation<br>    |   ├── /pages<br>    |   |   ├── NotFoundPage.ts<br>    |   |   └── NotAllowedPage.ts<br>    |   ├── /Orders<br>    |   |   ├── /pages<br>    |   |   |   ├── OrdersListPage.ts<br>    |   |   |   ├── OrdersCreatePage.ts<br>    |   |   |   └── OrdersEditPage.ts<br>    |   |   ├── /components<br>    |   |   |   ├── OrdersList.ts<br>    |   |   |   ├── OrdersForm.ts<br>    |   |   |   └── OrdersDeleteModal.ts<br>    |   |   ├── /context<br>    |   |   └── /hooks<br>    |   ├── /Dashboard<br>    |   |   ├── /pages<br>    |   |   |   └── DashboardPage.ts<br>    |   |   ├── /components<br>    |   |   |   ├── DashboardTable.ts<br>    |   |   |   └── DashboardGraph.ts<br>    |   |   ├── /context<br>    |   |   |   └── DashboardGraphsContext.ts<br>    |   |   └── /hooks<br>    |   |       └── useDashboardGraphs.ts<br>    |   └── /shared<br>    |       ├── /components<br>    |       |   ├── Input.ts<br>    |       |   └── Button.ts<br>    |       ├── /context<br>    |       ├── /hooks<br>    |       |   └── useWindowResize.ts<br>    |       └── /utils<br>    |           └── dates-functions.ts<br>    ├── /application<br>    |   ├── /types<br>    |   |   ├── orders.type.ts<br>    |   |   ├── order-status.enum.ts<br>    |   |   └── dashboard-data.type.ts<br>    |   ├── /services<br>    |   |   ├── read-orders-list.ts<br>    |   |   ├── edit-orders.ts<br>    |   |   └── create-order.ts<br>    |   └── /redux<br>    |       ├── /orders<br>    |       |   └── (redux folders for orders)<br>    |       └── /dashboard<br>    |           └── (redux folders for dashboard)<br>    ├── /infrastructure<br>    |   └── /api<br>    |       ├── /mappers<br>    |       |   ├── ordersDtoToOrders.ts<br>    |       |   └── dashboardDtoToDashboardData.ts<br>    |       ├── /dtos<br>    |       |   ├── get-order.dto.ts<br>    |       |   ├── post-order.dto.ts<br>    |       |   ├── put-order.dto.ts<br>    |       |   ├── delete-order.dto.ts<br>    |       |   └── get-dashboard.dto.ts<br>    |       ├── orders-api.ts<br>    |       └── dashboard-api.ts<br>    ├── App.ts<br>    ├── Routes.ts<br>    └── index.ts</pre><p>The whole structure is made of multiple flows:</p><p>Let’s try to follow just the reading of the order flow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/0*7hWRmCu1wfJZ_kOl" /></figure><p>The data read by the API with a type defined in “get-order.dto.ts” passes through a mapper called “ordersDtoToOrders.ts”. This mapper transforms the DTO into the application layer type so that the DTO is only confined inside the infrastructure layer.</p><p>After that, the data moves to the presentation layer, and finally, displayed to the user.</p><p>With a create/modify operation, everything would follow the exact same flow.</p><p>Let’s make it a bit more complex, to showcase the flexibility of the process: <strong>what if the backend changes the DTO of the “GET /orders” but we cannot know the release time?</strong> (a valid statement if you consider this in a CICD environment).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/0*47xtBnzQystrH3Ph" /></figure><p>So now, we ask our “read-orders-list.ts” to <strong>choose</strong> which API must be called depending on a flag.</p><p>If the flag is set to follow the new flow, the new API will be called and will use his new mapper to change the output.</p><p><strong>The good news is that everything below the application layer remains untouched!</strong> (whew!).</p><h3>Take-home messages</h3><p>When a project starts, it is easy to underestimate the growing complexity that comes along the way, in part because we start off not knowing how and in which direction the app will expand, or even because we might not expect any growth at all.</p><p>Just think about mono-task applications evolving in the course of a few months to meet customers’ needs and feedback. Flexibility and a change speed while keeping control of the code is a must in these situations, and a good solid design can make all the difference to build and foster a successful product.</p><p>This architecture tries to meet all these needs and requirements by separating the various layers and preventing the whole app from changing with every tiny implementation.</p><h3>Learn More</h3><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Andrea Giannoni, Senior Frontend Engineer.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66ae41e32abc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS Serverless Image Handler: The Key to Effortless, Cost-Effective Image Manipulation]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/aws-serverless-image-handler-the-key-to-effortless-cost-effective-image-manipulation-82f9594aeb53?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/82f9594aeb53</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-secrets-manager]]></category>
            <category><![CDATA[image-manipulation]]></category>
            <category><![CDATA[image-processing]]></category>
            <category><![CDATA[image]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Wed, 02 Mar 2022 13:49:33 GMT</pubDate>
            <atom:updated>2022-03-02T13:49:33.584Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c8o_Z9KiVtw6_cYmZfpthA.jpeg" /></figure><p>At BOOM we produce and manage hundreds of thousands of images that need to be browsed and visualized by our web app’s users.</p><p>When we faced the problem of creating an image gallery, our first approach was to generate a set of optimized thumbnails for each image and store them on S3 so that they could be displayed inside the web app.<br>This naive approach had some evident drawbacks:</p><ul><li>We had to know the optimal resolutions needed for every device ahead of time</li><li>Storage consumption would constantly increase over time, regardless of the actual usage of images. For example, an image produced two years ago is less likely to be viewed than a new image, but its thumbnails would be stored forever anyway</li><li>What if requirements changed and we need new types of thumbnails? In that case, we would have to regenerate the missing images from scratch.</li></ul><h4>As such, we came to the conclusion that the best thing to do would be to generate images on the fly and cache them in a CDN for as long as needed. This way, no permanent storage was required, but we still needed to figure out how to perform lots of concurrent manipulations on demand.</h4><p>The natural answer was “it has to be serverless”. That’s when we discovered that such a solution was already provided by <a href="https://aws.amazon.com/solutions/implementations/serverless-image-handler/">AWS Serverless Image Handler</a>.</p><h3>AWS Serverless image handler</h3><p>Serverless image handler is an AWS solution implementation that allows to store a single version of every image on an S3 bucket and at the same time deliver as many dynamic versions as desired. This approach drastically cuts storage costs and eliminates all the management complexity required by maintaining multiple image copies.</p><p>The solution comes with an AWS Cloudformation template that deploys the following resources:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/0*TEl0P9ur8G9L2qHb.png" /></figure><ol><li>An Amazon CloudFront distribution that acts as a caching layer, reducing the latency of image delivery and the cost of image processing</li><li>An Amazon API Gateway to forward requests that were not already cached in the CDN to a Lambda function</li><li>A Lambda function to retrieve the image from the S3 bucket and returns the modified image after applying the necessary manipulations using.</li></ol><p>In addition to that, the solution can also use AWS Secrets Manager if you wish to secure the requests through the signature feature, or Amazon Rekognition when using the smart crop or content moderation features.</p><h3>Request examples</h3><p>The serverless image handler features include the ability to resize, crop, flip images, change their background colors, convert to grayscale, perform smart cropping through face detection and content moderation, add watermarks, and more.</p><p>Most of these features can be explored through the demo app available in the solution; just import an image from your bucket and select the transformations you want to apply, and you’ll see the corresponding request json on the right-side panel.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/0*7ZNr2GGcpxD8PRzO.png" /></figure><p>For example if you need to resize an image — keeping its aspect ratio — and convert it to jpg, the request json will look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/248/0*uIEqpDaguQYyWiRG.png" /></figure><p>The json needs to be first encoded to Base64 and then appended as path parameter to the Cloudfront url like this:<br><strong>https://<em>&lt;distributionName&gt;</em>.cloudfront.net/<em>&lt;base64encodedRequest&gt;</em></strong></p><p>The demo app generates requests only for some of the available Sharp.js image manipulations. <br>In the official documentation, you won’t find an exhaustive list of all the supported parameters because you can refer to the library documentation. In fact, the parameters contained in the edit section of the json are passed directly to Sharp, as you can see in the default case of the lambda’s applyEdits function here below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/659/0*ec-Arit9ijan4h3G.png" /></figure><p>In addition to Sharp transformations, you can also use Thumbor filters that respond to different kinds of requests.<br>For example, if you want to add a watermark to your image you can call</p><p><strong>https://<em>&lt;distributionName&gt;</em>.cloudfront.net/filters:watermark(bucket,key,x,y,alpha,w_ratio,h_ratio])</strong></p><p>For the complete listing of supported filters, just refer to the <a href="https://docs.aws.amazon.com/solutions/latest/serverless-image-handler/thumbor-filters.html">supported Thumbor filters page</a>.</p><h3>Securing images</h3><p>If you wish to keep your images secure you can enable the signature feature that will make the lambda check for a valid signature query string in every image request.</p><p>An error message will come up if the signature is either invalid or not present.</p><p>To activate the feature, you need to set the following lambda ENV variables:</p><p>With the signature feature enabled, the image request becomes:</p><ul><li>ENABLE_SIGNATURE: Yes</li><li>SECRETS_MANAGER<strong>: </strong>a valid secret created in AWS Secrets manager</li><li>SECRET_KEY: a valid key created in in AWS Secrets manager</li></ul><p><strong>Here below is an example of a Java method to create a valid signature, provided the request path and the signature key as input parameters:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/0*ypvZhjCdkCGoqhfq.png" /></figure><p>With the signature feature enabled, the image request becomes:</p><p><strong>https://<em>&lt;distributionName&gt;</em>.cloudfront.net/<em>&lt;path&gt;</em>?signature=<em>&lt;signature&gt;</em></strong></p><h3>Limitations</h3><p>Of course, there is a limitation to this AWS solution, involving the Lambda’s invocation payload quota, as both request and response cannot exceed 6MB.</p><p>In case the resulting image is larger than 6MB you will receive the following error in the response:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/0*791eskXATqng6sQP.png" /></figure><h4>Learn More</h4><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Valentina Bruno, Senior Backend Engineer.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82f9594aeb53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to scale data fetching with SWR]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/how-to-scale-data-fetching-with-swr-699911506284?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/699911506284</guid>
            <category><![CDATA[data-fetching]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[frontend-engineering]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[swr]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Thu, 24 Feb 2022 15:39:11 GMT</pubDate>
            <atom:updated>2022-03-10T17:33:39.959Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2b2N4_w19mrCGkmiZcB6tg.jpeg" /></figure><p>I first discovered SWR when I joined BOOM as a junior developer.</p><p>Whenever I had built applications before, I limited myself to creating an effect that inserted data into the state of the single component. Later, after trying SWR, I realized that without this library, some problems were difficult to manage. For example, reusing the code to call an API endpoint resulted in many identical calls, with only two solutions within my reach:</p><ul><li>to create a global state in redux, which involved adding complexity to the code and studying the library</li><li>to insert the data in a global state of the “App” component (the parent component of all the others) and do prop drilling to get the data to all the child components that needed it.</li></ul><p>SWR was the only way to keep the code from getting dirty and maintain a high degree of speed when loading data.</p><p>Additionally, I had been positively impressed when I noticed the features that revolve around the SWR library because implementing them would have been very difficult and long for a beginner (like I was).</p><p>For example, it’s very convenient to just have to call the “mutate” method from one component to update data in another component that is difficult to reach.</p><p>And so SWR was, for me, the solution that sped up my work and kept the code clean, without any do-it-yourself solutions.</p><p>At BOOM, after a period of experimentation to find the best technology for data fetching, we decided that SWR was best-suited for our needs.</p><p>The acronym SWR stands for Stale-While-Revalidate: a pattern used in applications to speed up the loading and updating of the UI that requires data from an external REST resource.</p><p>SWR implies a caching strategy, whereby data received from the server stored in a local cache (stale), can be revalidated if necessary (revalidate), and updated in the same cache to be served in the future.</p><p>The browser needs to know when a resource has to be updated and to do this it uses the data contained in ‘Cache-Control’, a header of the HTTP response from the server.</p><p>​Inside this header there are several attributes, of which we will consider two:</p><p>​Let’s illustrate this with the example of a server returning this header in the HTTP response to a resource:</p><pre>Cache-Control: max-age=10, stale-while-revalidate=119</pre><p>Depending on how much time elapses before the browser asks whether the data needs updating or not, three different situations can come across:</p><ul><li>If the elapsed time is less than the “max-age” (so before the 10th second) the data stored in the local cache is still valid, and it is not necessary to make a new call to receive the updated data.<br>​</li><li>If the elapsed time is greater than the “max-age” and less than the “stale-while-revalidate” (between seconds 10 and 119) the data stored in the local cache are still valid and can be used temporarily. The browser must ask the server for updated data in order to update the cache and display the new data as soon as possible</li><li>If the elapsed time is greater than the “stale-while-revalidate” (beyond the second 119), the data in the local cache must be discarded because it is no longer valid. The browser must make a new call in order to take the updated data, insert it in the cache and finally display it.</li><li>If you need updated data and you accept a certain degree of obsolescence, this pattern fully meets your needs!</li></ul><h3>​React SWR library and advantages</h3><p>Stale-While-Revalidate is implemented in the SWR library (<a href="https://swr.vercel.app/">https://swr.vercel.app/ </a>) and allows us to apply the pattern to React applications.</p><p>​The greatest advantage is the automated process that takes care of receiving and updating the data, without requesting any interaction with the cache.</p><p>​Other features offered by SWR include:</p><ul><li>useSWR hook returns two values: data and error-based on the status of the request</li><li>useSWR hook, which also provides mutation function, to force data reload.</li><li>the data is updated “on focus”: SWR understands when you switch from one browser tab to another or when the computer stops and automatically updates data to make it easier to find it when you go back to the tab.</li><li>data revalidation is performed automatically when the connection is lost, so there is no need to manage it on the code side; the library will do it for us.</li><li>deduplication: components accessing the same resource in the local cache make SWR perform only one call. Let’s take an example:</li></ul><pre>import useSWR from &#39;swr&#39;;<br><br>const Header = () =&gt; {<br>  const { data } = useSWR(&quot;/api/shop&quot;)<br><br>  return ...<br>};<br><br>const HeroSection = () =&gt; {<br>  const { data } = useSWR(&quot;/api/shop&quot;)<br><br>  return ...<br>};<br><br>const Footer = () =&gt; {<br>  const { data } = useSWR(&quot;/api/shop&quot;)<br><br>  return ...<br>};<br><br>const App = () =&gt; {<br>  return (<br>    &lt;&gt;<br>      &lt;Header /&gt;<br>      &lt;HeroSection /&gt;<br>      &lt;Footer /&gt;<br>    &lt;/&gt;<br>  );<br>};</pre><p>An application has to use the data of the resource “shop” in 3 different components, and each component will handle the call to this resource internally via SWR.</p><p>​At the network level, there’s the execution of a single call to the server. The hook will return the same data to all 3 components without executing the call multiple times.</p><p>​This way, it is also possible to avoid the creation of a “global state” (using e.g. React.Context or Redux) to share information across multiple components: SWR will act as the global state and return the value to all components that need it.</p><p>​This functionality can be used to scale any frontend application and generate interesting results using just a few lines of code.</p><p>​Let’s take another example to illustrate how this amazing technology works. An API method returns the user’s data through a GET on the /api/user endpoint, and we need to:</p><p>A simple and frequently used solution is to create a state, and through an event (like a React effect or a user click) ask for the resource and save it in the state.</p><p>​A possible implementation that does not involve the use of SWR could be this one:</p><pre>import useSWR from &#39;swr&#39;;<br>import {fetcher} from &#39;somewhere&#39;<br><br>const Profile = () =&gt; {<br>  const [data, setData] = useState(null);<br>  const [error, setError] = useState(null);<br><br>  const fetchData = useCallback(async () =&gt; {<br>    try {<br>      const response = await fetcher(&quot;/api/user&quot;);<br>      setData(response.data);<br>      setError(null);<br>    } catch (e) {<br>      setError(e);<br>    }<br>  }, [])<br><br>  useEffect(()=&gt;{<br>    fetchData();<br>  }, [fetchData])<br><br>  if (error) return &lt;div&gt;failed to load&lt;/div&gt;;<br>  if (!data) return &lt;div&gt;loading...&lt;/div&gt;;<br><br>  return (<br>    &lt;&gt;<br>      &lt;div&gt;hello {data.name}!&lt;/div&gt;<br>      &lt;button onClick={fetchData}&gt;refresh&lt;/button&gt;<br>    &lt;/&gt;<br>  );<br>};</pre><p>As you can see, we need an initial effect to make the first call to get the data, and we also need two states to save the data and a possible error.</p><p>​Let us now try a solution using SWR:</p><pre>import useSWR from &#39;swr&#39;;<br><br>const Profile = () =&gt; {<br>  const { data, error, mutate } = useSWR(&#39;/api/user&#39;, fetcher);<br><br>  if (error) return &lt;div&gt;failed to load&lt;/div&gt;;<br>  if (!data) return &lt;div&gt;loading...&lt;/div&gt;;<br>  return (<br>    &lt;&gt;<br>      &lt;div&gt;hello {data.name}!&lt;/div&gt;<br>      &lt;button onClick={() =&gt; mutate()}&gt;refresh&lt;/button&gt;<br>    &lt;/&gt;<br>  );<br>};</pre><p>This solution is cleaner and more compact at first glance. We don’t need effects and states to save progress because SWR takes care of the cache, possible errors, and the initial call for us.</p><p>Furthermore, with this last solution, we have the features mentioned above to improve the user experience.</p><p>​In summing up, with SWR it is easier to manage situations that request a lot of resources, where the cache plays a fundamental role in speeding up the application.</p><p>​At the same time, however, SWR is a library on which our project will depend, and as such, it needs to be updated and maintained over time.</p><p>​Migrating to a solution using SWR is quite simple and removes complexity from the application by adding useful functionality for the end-user.</p><p>​Alternatively, there are interesting alternatives to SWR, including <a href="https://react-query.tanstack.com/">react-query</a> and SWR supports GraphQL requests.</p><p>The SWR project <a href="https://swr.vercel.app/">page.</a></p><h4>Learn More</h4><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Francesco Filippini, Backend Engineer.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=699911506284" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Compress Files without a Filesystem Support]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/how-to-compress-files-without-a-filesystem-support-294cfaac5353?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/294cfaac5353</guid>
            <category><![CDATA[file-compression]]></category>
            <category><![CDATA[s3-bucket]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[filesystem]]></category>
            <category><![CDATA[zip]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Mon, 14 Feb 2022 09:02:42 GMT</pubDate>
            <atom:updated>2022-02-14T09:02:42.611Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pdzF_hr3_s8SLbUY38st3g.jpeg" /></figure><p>Zipping files is essential to save space and memory when working on a<a href="https://boom.co/how-it-works"> platform as big and complex as BOOM</a>, which handles thousands of files on a daily basis and therefore must optimize space and resources in order to provide an efficient experience. However, compressing files is a tough task, especially when you don’t know how much space you will need in advance. Working in a cloud environment also brings out new challenges when handling data, as a file system is something that is not included by default in every cloud environment, and it impacts the pricing of the services we’re using.</p><p>As a developer, it’s our responsibility to get things done efficiently while being mindful of costs, and luckily there are ways to get around the file system!</p><p>I recently found myself having to translate an old procedure from python to java (kotlin, actually), whose purpose was to <strong>download pictures from a third-party supplier </strong>and then save them on our <strong>S3 bucket</strong>, zipping them together once the process was done.</p><p>The old procedure simply wasn’t effective. First of all, it required a temporary filesystem to store the images and the zip file. Secondly, since we deal with a good deal of resources at once (each photoshoot requires around 10s of Gigabytes of data) we had to make sure that the container that took care of doing the job had enough <strong>space</strong> <em>and</em> <strong>memory</strong> to work successfully at any given moment.</p><p>Since we could move this procedure into a <strong>single microservice</strong> that took care of the whole <strong>picture editing process</strong>, there surely had to be a better way to handle this use case without having to rely on a filesystem and using as little memory as possible. I then ventured into a journey made of trial and error which proved to be a valuable learning experience.</p><p>The first instinctive approach that came to mind was using Java’s streams, of course. This would surely have reduced the impact on the JVM and gotten rid of our data persistence needs.</p><p>In a way, it made sense. The first part — downloading pictures as a data stream and uploading them to S3 — worked perfectly thanks to the S3 SDK and a bit of abstraction.</p><p>The code to upload something with the SDK looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/551/0*RszclnH6daDsazxg.png" /></figure><p>Now, the S3 SDK claims the following:</p><p><em>“Content length must be specified before data can be uploaded to Amazon S3. If the caller doesn’t provide it, the library will make the best effort to compute the content length by buffering the contents of the input stream into the memory because Amazon S3 explicitly requires that the content length be sent in the request headers before any of the data is sent.”</em></p><p>As such, it’s quite apparent that the “metadata” object needs to have the content length specified, which in this first stage was not an issue at all, using some HttpOpener class that provided the data stream and its length, which could then be passed on to the S3 API:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/0*9rJ12_bEYi1TL3o_.png" /></figure><p>This proved to work well: during the download/upload phase, the memory usage was constant.</p><p>The real issue came when trying to zip everything back to S3. In theory, the working principle went as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/406/0*b8LDcs0FO7zTKqK8.png" /></figure><ol><li>Get the image from S3 (because I don’t trust the image to be still available at the old location)</li><li>Feed that data stream into a zip input stream</li><li>Feed that zip stream back into S3</li></ol><p>In practice, there were two major drawbacks/learning moments:</p><ol><li>First of all, as noticed before, if we don’t send the final size of the object sent by the S3 API through the putObject method, <strong>the method just reads the Input Stream twice</strong>, once to calculate the actual size, once to send the data.<br>This proved devastating on the JVM, because to calculate the size, the stream needs to be materialized into a byte array in memory. In other words, the allocated memory had to be as big as the zip we were going to handle. And so this solution couldn’t have worked.<br>The real problem, in this case, is that <strong>we don’t know the size of the final zip’s size beforehand</strong>.</li></ol><p>2. Secondly, but still quite important, the “getObject” method of the S3 SDK — used to retrieve our images on S3 — keeps an HTTP connection open for each file we want to process, so getting all files beforehand wouldn’t quite work, as the HTTP pool would quickly deplete and throw exceptions all over the place.</p><p>The second point was quickly solved by using the getObject function lazily (so only when we had to process that particular file), and manually closing the resource afterwards.</p><p>The first problem was solved by exploiting the multipart upload and Java’s utilities PipedInputStream and PipedOutputStream in the following way:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*3sGPUQySbssKcDxi.png" /></figure><p>Here we have here our main zip stream (zip), which will feed its contents to the main output stream (outputStream), which in turn will pipe its contents to the final input stream (inputStream) that will be used by the upload thread.</p><p>The zipping thread is spawned by means of a CompletableFutureto simplify things, and manages the data that goes inside the zip stream:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/0*LKLIEEw6jB8Cmap5.png" /></figure><p>As mentioned before, for each key in our list, we lazily get the object and put the data from the entry to the zip stream.</p><p>And finally, the upload thread is spawned with a CompletableFuture as well and takes care of using the data from the input stream, after initiating a multipart upload request towards S3.</p><p>This is a bit more complex yet pretty straightforward:</p><ul><li>At the beginning of the process, we initiate the multipart upload session</li><li>We use our “inStream” as a resource (the piped input stream with data flowing from the zip)</li><li>We calculate a rough estimate of the size of the final zip. In this particular case, we don’t need absolute precision, as we just need to know how many parts we are sending, based on the size of each part we send, in our case 20 Mb</li><li>Once we have the total size, we calculate the number of parts that we’re going to send</li><li>For each part, we read through many bytes from the input stream, and send it as an S3 part, collecting the resulting eTags</li><li>Once we finish, we use the list of eTags to tell S3 to build up the zip and terminate the multipart upload.</li><li>Any error in the process will abort the multipart upload</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/0*ZAHYGEDZyMMQimgs.png" /></figure><p>The main question you might ask at this point is: why use two different threads? The answer is simple: to use the piped streams efficiently we need data to be constantly “pumped” in and out of the stream, so that memory consumption remains low.</p><p>Tests were made by spawning many threads running the upload function with a total image size of roughly 40Gb for each run, and it was run both on a development machine and in a Docker container with just 1Gb of memory available, with no occurrence of out-of-memory issues.</p><p>The following is the memory consumption of the service in our production environment, while it was running the zip of a ~40Gb file, in parallel with other smaller compression jobs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/0*fI8faZyKWR1SiRSQ.png" /></figure><p>As you can see, the memory usage during the whole process (that started at 8:30 and ended at 9:30) was constant and had no peaks. The application runs with the Spring Boot framework, on a docker container, and the baseline of the memory occupied by the server is in the 600Mb range when not doing anything.</p><h3>Learn More</h3><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Luca Di Stefano, Backend Engineer.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=294cfaac5353" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How To Build Strategies For Engaging Product Communication]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/how-to-build-strategies-for-engaging-product-communication-2e462ab20c56?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e462ab20c56</guid>
            <category><![CDATA[communications-strategy]]></category>
            <category><![CDATA[product-strategy]]></category>
            <category><![CDATA[product]]></category>
            <category><![CDATA[customer-engagement]]></category>
            <category><![CDATA[product-marketing]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Thu, 10 Feb 2022 10:56:34 GMT</pubDate>
            <atom:updated>2022-02-10T10:56:34.628Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kwlslk1FR7zw-NTq.jpg" /></figure><p>Effective product communication is a competitive advantage for a company and helps target customers with marketing messages.</p><p>Regardless of the type of product in question (digital, physical, etc.) a product communication strategy is an <strong>integral part of a good marketing plan</strong>.</p><p>The best product communication strategies increase your message’s chance of reaching the right customers and ultimately lead to more sales and revenues.</p><p><strong>What is a product communication strategy?</strong></p><p>The product communication strategy is the approach used to fulfill product marketing objectives. It’s the part of a marketing plan that sheds light on how a product <strong>solves specific customer issues</strong>, demonstrating the product’s <strong>values</strong> and <strong>benefits</strong> in the process. As such, a strategy for product communication regulates the planning and implementation phase of future tasks concerning the product <strong>launch</strong>, <strong>promotion,</strong> and <strong>adoption</strong>.</p><p><strong>Why build a product communication strategy?</strong></p><p>By creating an efficient strategy, you also factually <strong>define the KPIs of your success</strong>. From the product launch to the promotion phase of the journey, these can determine whether or not a strategy works, and help keep track of the completion of previous tasks. It will also encourage you to achieve your <strong>goals</strong> by following your own path instead of blindly following marketing trends or one-size-fits-all strategies.</p><p><strong>How to create a strategy for product communication</strong></p><ul><li><strong>Identify the goal</strong></li></ul><p>As with any strategy, the first step of creating your product communication strategy matrix is to define the primary objectives of your company (and your product in particular).</p><ul><li><strong>Understand the situation</strong></li></ul><p>When launching a new product on the market, there are a few crucial steps that will help communicate product and feature updates, including identifying a target audience and how to interact with them.</p><p>The strategy should answer key questions such as:</p><ul><li>What’s the value proposition?</li><li>Will the new solution resolve customers’ issues?</li><li>How profitable is it?</li><li>Who are our competitors (if any)?</li></ul><p>You can answer these questions, as well as others, by working on the product communication strategy. Your audience usually has to go through several stages of behavior change, such as <strong>awareness</strong>,<strong> consideration</strong>,<strong> trial</strong>, and <strong>purchasing</strong>. Additional behaviors after product purchase include <strong>using</strong> the product and purchasing an <strong>upgrade</strong> (with upselling) or <strong>add-ons</strong>. Your strategies will change for each phase.</p><p>After asking yourself these questions, you’ll be able to build the right message for your customers and communicate the product in a way that conveys its full value and the benefits they can get from it, telling them how it can <strong>simplify</strong> their work or <strong>increase business performance.</strong></p><p><strong>Determine your target audience</strong></p><p>Once you are comfortable with your business goals and you have assessed the surrounding landscape, determine who you want to reach.</p><p>Defining your target audience for your product communication is a crucial phase, and the best way to get it right is to conduct the following analysis:</p><p>Divide customers into segments such as <strong>potential customers</strong>, <strong>new customers, mature customers,</strong> and <strong>star customers</strong>.</p><p>Then, target each segment with different communication messages and promotional offers. For <strong>new customers</strong>, use your communication to confirm that they are pleased with their first purchase, and encourage repeat purchases through discount coupons and offers. For your <strong>star customers</strong>, provide customized product communication based on their buying patterns, and consider personal emails or phone calls to confirm their satisfaction.</p><p><strong>Media and channels</strong></p><p>Align your target audience with what you hope to accomplish by asking yourself the following questions:</p><ul><li>Which social channels can you find them on?</li><li>Do they more often use a mobile device or desktop?</li><li>What types of content do they find valuable and engaging?</li><li>Are they already aware of your company and its offering?</li><li>What content are they searching for and where?</li><li>What do they expect to see on your site once they get there?</li></ul><p>Use multiple methods of communicating with your customers. Use email <strong>newsletters</strong>,<strong> magazine advertisements</strong>,<strong> postcards</strong>,<strong> billboards</strong>,<strong> in-store displays</strong>,<strong> product packaging</strong>,<strong> direct-mail letters,</strong> and any other advertising method that effectively reaches your target audience. Create an <strong>information-rich website</strong> that offers specific product information and insights, <strong>chat-based assistance,</strong> and <strong>customer testimonials</strong>. Your goal with your product communication mix is to use enough tactics to reach each customer in their preferred way.</p><p><strong>Messaging: tell a beautiful story</strong></p><p>Finding the right angle is another important part of creating a communication strategy, which will allow you to tell an honest, emotional, and <strong>engaging</strong> <strong>story</strong>. When communicating a new product or launch, you must first figure out the best way to frame the story before you can move to any of the next steps.</p><p>By developing your product messaging around a <strong>well-designed story</strong>, you can increase your product branding, reinforce your theme and enhance product awareness. Your product messaging goal should be to create an <strong>emotional</strong> <strong>response</strong> to your product that propels customers to purchase it.</p><p>Creating a product communication strategy is a precondition for <strong>product success</strong>. If a company underestimates or neglects this part, they can risk launching a no-win solution (unprofitable), with a low adoption rate, or otherwise not achieving the intended goals.</p><p>There can be many reasons for this: a wrong target audience selected, an unclear value proposition (messaging), a wrong fit for a customer need, media that are ineffective for the target audience, or <strong>storytelling</strong> that is not engaging enough. For these reasons, it is necessary to take time to develop a strategy that takes all aspects into account and extracts and communicates the right <strong>product</strong> <strong>values</strong>, to the right customers, in the most efficient way possible.</p><h3>Learn More</h3><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. Explore our job offers <a href="https://boom.co/careers/">https://boom.co/careers/</a> to browse our opportunities. <em>Posted by Daniele Tognetti, Product Marketing Manager</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e462ab20c56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Challenges to Tackle as a Start-Up Product Manager]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/3-challenges-to-tackle-as-a-start-up-product-manager-c59880bcac51?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c59880bcac51</guid>
            <category><![CDATA[soft-skills]]></category>
            <category><![CDATA[product-manager]]></category>
            <category><![CDATA[time-management-tips]]></category>
            <category><![CDATA[project-management-tips]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Thu, 13 Jan 2022 11:23:04 GMT</pubDate>
            <atom:updated>2022-01-13T11:23:04.722Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GN3XGX0JnGhqWYAY.jpg" /></figure><p>The role of a <strong>product manager</strong> is a challenge in itself.</p><p>First of all, the job definition means different things to different companies. I am not only speaking about the role definition, but mainly the <strong>responsibilities and activities</strong> we have to deal with every day. For example, being a product manager in an <strong>enterprise</strong> is totally different from being a product manager in a <strong>startup company</strong>. Therefore, what makes up a successful product manager depends on many factors.</p><p>What does it take to be a successful product manager in a start-up? Hard skills are of course necessary, but <strong>soft skills</strong> make a real difference.</p><p>Here are <strong>three challenges</strong> of working as a product manager in a start-up:</p><p><strong>CHALLENGE 1. Everything moves fast — Be flexible</strong></p><p>In every company, <strong>reducing time to market</strong> is paramount. In a start-up, it’s a <strong>basic survival skill.</strong></p><p>Changes happen every day and it is crucial to address them quickly. What is true today might not be true tomorrow and you must be ok with it.</p><p>Start-ups, more than any other type of company, need to adapt and continuously review their products. This doesn’t imply that your company shouldn’t stick to a vision, a strategy, or goals, which are absolutely necessary to build a successful product.</p><p>However, it is important to <strong>recognize experiment results</strong> and customers’ (or users’) <strong>feedback</strong> and adjust your path on the run.</p><p>If you are flexible and willing to review your work until a <strong>market fit</strong> is achieved, then you will be able to face this challenge.</p><p><strong>CHALLENGE 2. Too many things to do — Learn to prioritize</strong></p><p>As a product manager, you must be able to go from working on <strong>tactics currently in development</strong> to <strong>thinking about initiatives and goals for the next months</strong>. And in order to focus on what is truly essential, it is important to <strong>prioritize</strong> and learn how to say “no” (or “yes, but not now”).</p><p>So the question is, how can you say “no” efficiently (and still sound polite and professional). It’s hard to refuse tasks in a resolved manner, and so it is important to <strong>justify your reasoning clearly</strong>, in order to <strong>keep your stakeholders’ trust</strong>. Moreover, remember to raise your hand and let your team know when you face time obstacles.</p><p>Learn how to <a href="https://boom.co/resources/prioritizing-by-value-how-to-plan-your-product-roadmap/"><strong>prioritize by value</strong></a>, and <strong>challenge the process in place</strong> if you feel it slows you down and asks a lot of extra time.</p><p><strong>CHALLENGE 3. Communicating is hard — Find the right style and balance</strong></p><p>Communication must be your <strong>superpower</strong>.</p><p>As a product manager, your role is central and you have to <strong>speak efficiently with different audiences</strong>.</p><p>People have a heterogeneous background and a personal understanding of the product itself.</p><p>Make sure you speak clearly, <strong>give the right level of detail,</strong> and <strong>change your vocabulary </strong>depending on your audience.</p><p>It is essential for team members to be on the same page, but in a fast-changing start-up environment, this can be challenging.</p><p>There is no silver bullet for this; every team needs to find its ingredients to communicate efficiently.</p><p>In some cases, <strong>asynchronous communication</strong> is enough (chat, shared documents, or videos).</p><p>In other cases, scheduling a quick meeting might be a better option to really get your team members’ attention. However, remember that while it is important to have clear communication channels, it is also important to avoid over-communicating, which is just as harmful as not communicating enough.</p><p>Efficient communication is key in a <a href="https://boom.co/resources/how-to-build-a-successful-startup-culture/">successful start-up culture</a>, especially for product managers!</p><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. <em>Posted by Antonella Cipresso, Product Manager</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c59880bcac51" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Product Thinkers: How to Design and Lay the Groundwork for your Tech Team]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/product-thinkers-how-to-design-and-lay-the-groundwork-for-your-tech-team-6ae76ed7a356?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ae76ed7a356</guid>
            <category><![CDATA[product-thinking]]></category>
            <category><![CDATA[mvp]]></category>
            <category><![CDATA[tech-product]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Wed, 29 Dec 2021 10:06:38 GMT</pubDate>
            <atom:updated>2021-12-29T10:06:38.084Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Nvgo3sRfccoqmXK0.jpg" /></figure><p>The greatest necessity of a cutting-edge technology startup is to <strong>release impact in the shortest possible time</strong>. There is no way to know what could have value for the end-user until you release a product that verifies our initial analysis and forecasts.</p><p>At BOOM, the definition of our “product” varies — it can be a <strong>feature, a new user flow, or an app with well-defined boundaries</strong>. In each of these cases, the process leading to its conception and its consequent implementation requires time, energy, and total participation from all the stakeholders involved in each phase.</p><p>Research, ideation, and creation require a great deal of energy from a Product Manager. And because these steps enable the creation of a great product, is the role of a PM about writing stories or about <strong>committing to imagining, verifying, and refining the future</strong> ahead of time?</p><p>Time is the most important resource and we never have enough of it. This is precisely why PMs do not deal with “bureaucracy” here. They don’t write stories with a grueling list of requirements to be revised and rewritten depending on unexpected events or missed requirements. Instead, a PM’s job is about <strong>defining the big picture</strong> and the <strong>MVPs</strong> of the next projects ahead of time, as well as iterating them to give the tech team a clear vision of what’s expected.</p><p><strong>How do we apply these principles at BOOM? </strong>For us, it all stems from one question: considering the company vision, what problem do we want to solve for our users? What are the main <strong>pain points</strong> will they have to face in the coming years?</p><p>From this question comes the first research level that involves the entire product team and is divided into <strong>focus groups, product discovery, interviews, and competitive analysis</strong>, to identify high-level projects to invest in. All of these projects are then fed into a roadmap that we call the <strong>Product Strategy Roadmap (PSR)</strong>. The PSR — which by definition is not immutable (on the contrary!) — adopts names that are clear to everyone in the company. Remember, everyone must be able to understand what we want to invest in without digging too deep into the details!</p><p><strong>So how do we consolidate different projects?</strong> This is where our product thinkers become fundamental.</p><p>Considering the various projects in the PSR — which we call <strong>strategies</strong> — the PMs begin to rigorously explore the terrain by reiterating the steps mentioned above (focus-groups, product discovery, interviews, competitive analysis, surveys, or inventing new techniques but with a much higher level of detail). Decisions depend on the quality but also the quantity of data and insights available.</p><p><strong>What happens after that? </strong>Each PM is responsible for <strong>defining a memo</strong> by providing a BIG-Picture of the project and slicing it into<strong> many MVPs</strong>, which will confirm or validate the solution in the shortest possible time.</p><p>For each of these projects, we define a <strong>metric</strong> known as a <strong>proxy metric</strong>, which will confirm the progress of the project. Remember, with us an MVP is like an experiment: we believe in something, we bet on it and then we check if our hypotheses are correct. We are scientists who operate in an unknown environment, where the presumption of knowledge is our greatest enemy.</p><p>For each of these projects, we define a roadmap, known as a <strong>POD-Roadmap</strong>, which connects each of them to those defined in the PSR. We call this process <strong>bucket creation</strong>.</p><p><strong>And what happens if a strategy in the PSR runs out of linked sub-projects?</strong> In those cases, we evaluate why and determine if the project defined in the RDP makes sense or not. This is a fluid process where nothing is written forever and everything can change!</p><p><strong>So once we’ve established what needs to be done, how can the tech team make it a reality? </strong>At that point, an <strong>epic</strong> is written for each MVP, which defines the final result expected. Each epic is completed with <strong>wireframes and mockups</strong> in which UI and interactions are defined with absolute precision. The product design team’s role is fundamental, as is their role in improving the solution itself.</p><p>At that point, the tech team (also involved in the previous discovery part) starts<strong> drafting the stories that connect to the epics</strong>, which provides T-shirt sizes and more precise estimates, as part of their responsibility for the entire solution.</p><p>This process has allowed us to keep the product team focused on value for the end-user without dwelling on the not-so-agile bureaucracy, and to distribute ownership of the result across all teams. In fact, we do not follow the idea that “ <em>product gives requirements</em>” and “ <em>tech performs</em>” but rather “ <em>product thinks about what to do and why</em>” and “ <em>tech proposes the best technological strategy to do it</em>”. It might seem redundant to reiterate it, but trust us, it isn’t!</p><p>We have little time and a lot to do, so it’s important to improve and do better with each project, isn’t it?</p><p>Find out more about BOOM’s <a href="https://boom.co/how-it-works">product</a>!</p><p>Explore our website <a href="https://boom.co/it/">https://boom.co/</a> to learn more about the platform. <em>Posted by Marco Gadaleta, Head of Product</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ae76ed7a356" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Use Metabase to Optimize Decision-Making]]></title>
            <link>https://medium.com/@boomimagestudio-techblog/how-to-use-metabase-to-optimize-decision-making-32d7c7be5f96?source=rss-2f6b5752c28e------2</link>
            <guid isPermaLink="false">https://medium.com/p/32d7c7be5f96</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[metabase]]></category>
            <category><![CDATA[data-analytics-tools]]></category>
            <category><![CDATA[data-analytics]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[BOOM]]></dc:creator>
            <pubDate>Wed, 15 Dec 2021 12:05:57 GMT</pubDate>
            <atom:updated>2021-12-15T12:05:57.645Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gpQIn3mD0z5VeiJt3Fhhgg.jpeg" /></figure><p>At BOOM, the <strong>data team’s mission</strong> is to <strong>support</strong> the company’s <a href="https://boom.co/resources/5-keys-to-create-a-data-driven-customer-centric-mindset/">data-driven approach</a>, and selecting the right tools to carry out projects is a key part of it. When it came to choosing a power visualization data tool, the team tested a couple and ultimately picked, an <strong>open-source business intelligence tool</strong>.</p><h3>What does Metabase provide exactly?</h3><p>To put it simply, Metabase <strong>answers questions about data,</strong> displaying them in graphs or detailed tables. The program saves the questions or groups them inside dashboards.</p><p>Early on, Metabase proved to be useful to onboard new employees quickly, thanks to <strong>Google Authentication,</strong> and made it a perfect tool for <strong>GDPR compliance</strong>, thanks to a very intuitive group-based approach to setting permissions of data and collections.</p><p>Metabase offers two options to choose from: the <strong>free</strong> and the <strong>enterprise</strong> version. BOOM installed a <strong>free Metabase cluster</strong> (2 instances) in a <strong>Kubernetes cluster</strong> on Amazon Cloud, which relies on the MySql database (For installation details read <a href="https://www.metabase.com/blog/how-to-run-metabase-in-production/">here</a>).</p><p>One of the main advantages of Metabase is that all charts can be <strong>dragged and dropped</strong> and the use of SQL is optional during dashboard development.</p><h3>Using Metabase in our Data Pipeline</h3><p>At BOOM, we integrate heterogeneous data sources in a data warehouse adding a historicization of transaction systems. Then we clean and arrange all data and present them to our stakeholders using Metabase<strong>.</strong></p><p><strong><em>Example of BOOM’s Data Pipeline:</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/840/0*nc4DQC-ZpAtT_diD.png" /></figure><p><strong>BOOM’s data analysts </strong>found it useful to <strong>divide widgets and dashboards</strong> into separate folders. Every team has two principal folders: one with only their own dashboards and one with widgets organized with sub-folders — one for every dashboard — which collect all the widgets that make it up.<br>This way, not only is it simple to find a specific dashboard but moving, dating, or sharing data from one group to another is a breeze. <br>Additionally, data analysts recommend <strong>personalized documentation</strong>, which features a series of short video tutorials about folder organization, chart creation, and howMetabase is structured for BOOM’s various requirements.</p><p>From a <strong>DevOps</strong>’ perspective, BOOM’s Metabase runs on Kubernetes, including two particular instances in high availability, to always have at least one active, in case of maintenance or reboots. A DevOps knows that when it comes to database instances, <strong>connection limits</strong> must always be taken into consideration. How did BOOM handle that? Well, by <strong>optimizing our deployment </strong>and <strong>managing the application restart in Kubernetes</strong>, to have a maximum of two simultaneously active machines, and a maximum of one down. <br>Finally, it is important to adapt the Metabase service to generate<strong> logs in json</strong> format, in order to be able to read from Datadog and monitor it with other logs. <br>Interested in finding our <strong>customized Docker image</strong> with those modifications? Just click <a href="https://hub.docker.com/repository/docker/boomimage/metabase">here</a>!</p><p><a href="https://www.metabase.com/community/">Real stories about teams working and learning with data.</a></p><p>Find out more about Metabase:</p><p><em>Originally published at </em><a href="https://boom.co/resources/how-to-use-metabase-to-optimize-decision-making/"><em>https://boom.co</em></a><em>.</em></p><p><em>Posted by Data Analysts Katia Bonella and Valentin Popov, and DevOps Andrea Cesti.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32d7c7be5f96" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>