{
    "version": "https://jsonfeed.org/version/1.1",
    "title": "Yetric Blog",
    "home_page_url": "https://yetric.com/blog/",
    "feed_url": "https://yetric.com/feed.json",
    "description": "Articles and thoughts on software development, technology and building digital products.",
    "language": "en",
    "authors": [{ "name": "Yetric" }],
    "items": [
        
        {
            "id": "https://yetric.com/blog/posts/doon-learn-swedish-maths-geography/",
            "url": "https://yetric.com/blog/posts/doon-learn-swedish-maths-geography/",
            "title": "Doon: One Place to Learn Swedish, Maths and Geography",
            "summary": "Doon started as a Swedish word guide and is growing into a place to practise Swedish, maths and geography. What it does for learners and what’s new.",
            "content_html": "<p><a href=\"https://doon.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Doon</a> started as a place to look up Swedish words. It's now a small learning site with three subjects: Swedish, maths and geography. The site is in Swedish, and it's aimed at people who want to learn at their own pace without having to sign up for a course.</p>\n<p>A lot has been added over the last couple of weeks, so this is a good time to say what Doon is and what's in it.</p>\n<h2 id=\"what-a-learner-gets\" data-toc-text=\"What a learner gets\">What a learner gets</h2>\n<p>You pick a subject and start. Each one has the same shape: something to read and explore, and something to practise.</p>\n<p><strong>Swedish.</strong> Doon has almost 19,000 Swedish words. You can browse them from A to Ö, look at the most common ones first, or filter by how long a word is, which is handy for word games. Every word has its own page, and many are translated. There are practice exercises on meanings, definitions and using words in sentences, plus grammar exercises and spelling practice. Words can be played aloud, so you hear how they're pronounced and not only how they're spelled.</p>\n<p><strong>Maths.</strong> Lessons and exercises for the four basic operations, fractions, percentages and geometry. You can practise one skill at a time when something is giving you trouble, and print worksheets if you'd rather work on paper. The exercises are generated fresh and checked, so you don't see the same set every time.</p>\n<p><strong>Geography.</strong> Countries, capitals, continents, flags, languages and currencies. You can practise with maps, and there are printable maps and flags for use in a classroom or at the kitchen table.</p>\n<p>Your progress is shared across the subjects, so what you've practised shows up in one place.</p>\n<h2 id=\"why-this-is-useful-for-learners\" data-toc-text=\"Why this is useful for learners\">Why this is useful for learners</h2>\n<p>A few things we care about:</p>\n<ul>\n<li><strong>Short, focused sessions.</strong> An exercise should be quick to start and easy to leave. There's a focus mode that removes everything except the question.</li>\n<li><strong>Feedback after each answer.</strong> You find out straight away whether you were right, so a round doesn't turn into guesswork.</li>\n<li><strong>Content that's been reviewed.</strong> A question with two defensible answers is frustrating. We keep an editorial checklist for vocabulary, and the exercises are validated, so a question should have one clear answer.</li>\n<li><strong>Works however you use it.</strong> On a phone or a computer, in light or dark theme. The geography map practice is built to be accessible.</li>\n</ul>\n<h2 id=\"one-engine-behind-every-subject\" data-toc-text=\"One engine behind every subject\">One engine behind every subject</h2>\n<p>For us as builders, the most important change was invisible. Maths practice came first, and we turned it into a shared exercise engine that Swedish and geography now use too. A new subject is a new set of questions, not a new application.</p>\n<p>That's also why the three subjects feel alike. A learner who knows how maths practice works already knows how to use the Swedish and geography ones. And when we improve something, like how feedback is shown or how a round ends, every subject gets the improvement at once.</p>\n<h2 id=\"what-we-aren-t-saying\" data-toc-text=\"What we aren't saying\">What we aren't saying</h2>\n<p>Doon is young and some of it is still being built. Swedish has the most depth. Geography and maths have good coverage but are newer. We're not trying to replace a teacher or a school course, and we don't claim that using Doon will get anyone to a certain level. It's a practice and reference tool.</p>\n<h2 id=\"what-s-next\" data-toc-text=\"What's next\">What's next</h2>\n<p>We want more depth in each subject, and more of the practice to be tied to the words and topics you've already met. We've also started thinking about other languages, though that's early and nothing is promised.</p>\n<p>If you try Doon and something is confusing or wrong, tell us. A wrong answer in a learning tool matters more than most bugs, and we'd like to fix it quickly.</p>\n",
            "date_published": "2026-11-16T00:00:00Z",
            "tags": ["doon","learning","product","swedish","user-experience"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/hembiosystem-home-cinema-guide/",
            "url": "https://yetric.com/blog/posts/hembiosystem-home-cinema-guide/",
            "title": "Hembiosystem: Choosing Home Cinema Gear Without the Guesswork",
            "summary": "Hembiosystem is a Swedish guide to home cinema products. Here's how it helps you choose, and what we're building next, including price alerts.",
            "content_html": "<p>Buying a TV, a soundbar or a projector is harder than it should be. There are a lot of models, the specifications are full of numbers that don't tell you much, and the price of the same product varies from store to store and from week to week.</p>\n<p><a href=\"https://hembiosystem.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Hembiosystem</a> is a Swedish guide that tries to make that easier. It covers TVs, projectors and screens, soundbars, speakers, headphones, streaming and media players, and consoles. You can browse the products, compare prices across Swedish stores, and read buyer's guides that explain what to look for.</p>\n<h2 id=\"what-it-helps-with\" data-toc-text=\"What it helps with\">What it helps with</h2>\n<p><strong>Knowing what to look for.</strong> Not everyone knows what separates one soundbar or projector from another. The buyer's guides (köpguider) explain what matters in each category, so you can choose between products with some confidence.</p>\n<p><strong>Seeing pros and cons at a glance.</strong> A recent change made the pros and cons in each guide easier to scan. Most people don't read a long review before buying, and we'd rather the important points be visible in a few seconds.</p>\n<p><strong>Comparing prices.</strong> The same product is often sold by several stores. Hembiosystem matches products across stores, so you can see where it's cheapest. We also recently fixed how sale prices are compared across matched stores.</p>\n<p><strong>Planning around events.</strong> Around big sports events people suddenly care about their TV. We've added a TV guide for sports and pages for coming events, such as Vasaloppet and the ice hockey World Championship in 2027, so you can find a good screen before the event and not during it.</p>\n<h2 id=\"prices-you-can-trust\" data-toc-text=\"Prices you can trust\">Prices you can trust</h2>\n<p>Price sites have a reputation problem. A &quot;sale&quot; can be a price that was raised just before it was cut. Swedish rules say that the previous price in a discount claim should be the lowest price of the last 30 days, and that's the standard we want to hold ourselves to.</p>\n<p>To do that, a site has to remember what each product has cost. This is work we've planned and are building towards. Until it's in place everywhere, we'd rather show less than show a discount we can't back up. That's an intention and not a finished feature, so please judge us on what you see on the site.</p>\n<h2 id=\"price-alerts-coming\" data-toc-text=\"Price alerts, coming\">Price alerts, coming</h2>\n<p>The thing we're building now is price alerts. You'll be able to choose &quot;notify me when the price drops&quot; on a product page, enter an email address, and choose how big a drop you care about, in percent or in kronor.</p>\n<p>How we want it to work:</p>\n<ul>\n<li><strong>No account.</strong> You confirm your email address and get a link for managing the alert. That's all.</li>\n<li><strong>One email per alert.</strong> When the price reaches your target at any store that sells exactly that product, you get one email. If you want another, you turn the alert back on.</li>\n<li><strong>Exact products.</strong> An alert is tied to one specific product, not a vague category, so a cheaper but different model doesn't trigger it.</li>\n<li><strong>No hidden extras.</strong> Signing up for an alert doesn't also sign you up for a newsletter or marketing.</li>\n</ul>\n<p>The groundwork is built and tested, but it's not switched on for visitors yet. We'll say so here when it is.</p>\n<h2 id=\"what-s-next\" data-toc-text=\"What's next\">What's next</h2>\n<p>After alerts, we'll keep adding the practical guides people ask for. If there's a product category or a question you'd like Hembiosystem to answer, tell us.</p>\n",
            "date_published": "2026-11-16T00:00:00Z",
            "tags": ["hembiosystem","home-cinema","product","user-experience"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/audioplayer-1-2-hittapodd/",
            "url": "https://yetric.com/blog/posts/audioplayer-1-2-hittapodd/",
            "title": "A Better Podcast Player: What's New in Our Audio Player and What's Next",
            "summary": "How the audio player behind HittaPodd.se is getting steadier and smarter, and how chapters and timed images can make listening better.",
            "content_html": "<p>Press play on <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a> and a small piece of software called <a href=\"https://github.com/yetric/audioplayer\" target=\"_blank\" rel=\"noopener noreferrer\"><code>@yetric/audioplayer</code></a> takes over. It's open source, we maintain it, and it handles the things a listener notices without thinking about them: play and pause, skipping, speed, the queue, and picking up where you left off.</p>\n<p>Two releases are in the works. 1.2 makes the player steadier. 1.3 lets it do something new for listeners. A note on status: 1.2 is in beta, 1.3 is an open pull request, and HittaPodd still runs the older 1.1. Nothing here is live on the site yet.</p>\n<h2 id=\"what-a-listener-expects\" data-toc-text=\"What a listener expects\">What a listener expects</h2>\n<p>Nobody opens a podcast app to admire the player. They want it to do these things and not get in the way:</p>\n<ul>\n<li>Start quickly and keep playing.</li>\n<li>Remember where they were, even days later.</li>\n<li>Skip back 15 seconds when they missed a sentence.</li>\n<li>Work from the lock screen and with headphone buttons.</li>\n<li>Not drain the battery or make the page feel sluggish.</li>\n</ul>\n<p>Most of what we've done to the player is aimed at these basics. They're easy to get almost right and annoying when they're not.</p>\n<h2 id=\"1-2-the-basics-get-steadier\" data-toc-text=\"1.2: the basics get steadier\">1.2: the basics get steadier</h2>\n<p><strong>Skipping works the same everywhere.</strong> Skip forward and back now behaves the same whether you tap a button on the page or on the lock screen. It never jumps to a strange position, and if an episode hasn't finished loading it moves from where you are rather than back to the start.</p>\n<p><strong>A smoother page.</strong> A player updates several times a second while it plays. Until now, every part of the page that showed anything from the player had to redraw each time, whether it needed to or not. In 1.2 a part of the page can ask to hear only about what it shows. The play button cares about play and pause. The progress bar cares about time. That means less wasted work, which matters most on older phones.</p>\n<p><strong>Remembering your place, more reliably.</strong> Resuming where you left off is the feature listeners miss most when it breaks. 1.2 fixes a bug that could interfere with restoring your position during development. It also makes sure that when the browser can't save something, because storage is full or blocked, playback carries on instead of stopping.</p>\n<p><strong>Tested in real browsers.</strong> Playback is now tested in actual browsers, not just simulated ones. A change that quietly breaks sound in Firefox or Safari is the kind of bug nobody finds until a listener reports it. We'd rather find it first.</p>\n<p><strong>Less work for us.</strong> For HittaPodd, a lot of what we built by hand around the player becomes a setting. Saving progress every few seconds is one example. Lock-screen controls are another. Less hand-built code means fewer places for things to go wrong, and more time spent on features that listeners can see.</p>\n<h2 id=\"1-3-the-player-learns-about-chapters\" data-toc-text=\"1.3: the player learns about chapters\">1.3: the player learns about chapters</h2>\n<p>Here's the part I'm most excited about. Many podcasts include chapters: a list of titles and start times, like &quot;Intro&quot;, &quot;Interview&quot;, &quot;Listener mail&quot;. Some also add an image, a link or a short note to a chapter. This is part of an open standard called <a href=\"https://podcasting2.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Podcasting 2.0</a>, and the information is already published by many shows. The chapters themselves follow the <a href=\"https://podcasting2.org/docs/podcast-namespace/examples/chapters/jsonChapters\" target=\"_blank\" rel=\"noopener noreferrer\">JSON Chapters specification</a>, which is part of the <a href=\"https://github.com/Podcastindex-org/podcast-namespace\" target=\"_blank\" rel=\"noopener noreferrer\">podcast namespace</a>.</p>\n<p>Today, most players ignore all of it. In 1.3, our player can read it and keep the screen in step with the audio.</p>\n<p>What that could mean for someone listening on HittaPodd:</p>\n<ul>\n<li><strong>Jump to what you care about.</strong> Instead of dragging a slider and guessing, you tap &quot;Interview&quot; and you're there.</li>\n<li><strong>See where you are.</strong> The current chapter title is shown while you listen, and the progress bar can show where the chapters begin.</li>\n<li><strong>Pictures and links at the right moment.</strong> When the host mentions a book, the cover appears. When they mention a website, the link is there to tap. No hunting through show notes afterwards.</li>\n<li><strong>Seeking doesn't spam you.</strong> If you drag ahead by half an hour, you see what belongs to where you landed. You don't get every picture and link you skipped past flashing by.</li>\n<li><strong>It keeps working when things change.</strong> Repeat, moving to the next episode in your queue and swapping episodes all reset the screen correctly.</li>\n</ul>\n<p>All of this is opt-in. A show without chapters plays exactly as before.</p>\n<h2 id=\"what-we-aren-t-claiming\" data-toc-text=\"What we aren't claiming\">What we aren't claiming</h2>\n<p>The player does the keeping-in-sync. It doesn't find the chapter data for us. Fetching it from a show's feed, designing how it looks, and making it accessible to everyone are still up to HittaPodd. That's real work and it comes next. Also, chapters only help when the podcast publishes them. We'll see how many do. Transcripts and automatic silence skipping are on the list for later.</p>\n<p>So the honest summary is that 1.3 makes a better listening experience possible. It doesn't give us one by itself.</p>\n<h2 id=\"why-we-build-it-in-the-open\" data-toc-text=\"Why we build it in the open\">Why we build it in the open</h2>\n<p>The player is MIT-licensed. If you're building a podcast or audiobook experience in a browser, you can use it, and the <a href=\"https://yetric.github.io/audioplayer/\" target=\"_blank\" rel=\"noopener noreferrer\">documentation</a> and <a href=\"https://github.com/yetric/audioplayer\" target=\"_blank\" rel=\"noopener noreferrer\">code</a> are public. Using it in a real product, with real listeners, is how we find out what's missing. I'd rather the library be shaped by an app people use than by guesses.</p>\n<p>If you listen on HittaPodd and something about the player annoys you, that's useful to us. Tell us.</p>\n",
            "date_published": "2026-11-15T00:00:00Z",
            "tags": ["audio","open-source","podcasts","ux"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/meilisearch-hittapodd-search/",
            "url": "https://yetric.com/blog/posts/meilisearch-hittapodd-search/",
            "title": "Finding the Right Podcast Episode: How Search Works on HittaPodd.se",
            "summary": "How we use Meilisearch on HittaPodd.se so listeners find podcasts and episodes quickly, even with typos, and how we want to use it for recommendations next.",
            "content_html": "<p>Search is the front door of a podcast app. Someone has a show or a topic in mind, they type a few letters, and they expect the right thing to show up. If it doesn't, they don't think &quot;the search index is stale&quot;. They think &quot;this app doesn't have it&quot;.</p>\n<p>On <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a> we use <a href=\"https://www.meilisearch.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Meilisearch</a> for this. It sits behind our API and is used by the web app. This post is about why we added it, and what it does for listeners.</p>\n<h2 id=\"what-was-wrong-before\" data-toc-text=\"What was wrong before\">What was wrong before</h2>\n<p>Search used to be a database query that looked for your text inside titles. It worked, but badly in three ways:</p>\n<ul>\n<li><strong>It was slow where it mattered.</strong> Episodes are the biggest part of the catalogue. On our measurements with about 345,000 episodes, the database search took around 1.7 seconds. The search engine answers in about 10 milliseconds. A search box that waits almost two seconds after every keystroke feels broken.</li>\n<li><strong>It didn't forgive typos.</strong> Type <code>fotbolsviken</code> with one <code>l</code> and you got nothing, even though the show exists.</li>\n<li><strong>The order was arbitrary.</strong> A database <code>LIKE</code> query finds matches but doesn't say which is the best one.</li>\n</ul>\n<h2 id=\"what-listeners-get-now\" data-toc-text=\"What listeners get now\">What listeners get now</h2>\n<p><strong>Fast enough to search as you type.</strong> We lowered the delay before a search starts from 400 to 150 milliseconds. That only makes sense because answers come back quickly. Results appear while you're still typing, in a popup you can open from anywhere with Cmd/Ctrl+K.</p>\n<p><strong>Typos are forgiven.</strong> A title that's one letter off is still found. We tuned this on purpose, though. By default the engine forgives a typo from 5 letters, and at that length <code>krimm</code> started matching <code>krim</code>. We changed it to forgive one typo from 6 letters and two from 12, so short words stay precise.</p>\n<p><strong>Better order.</strong> Of equally good matches, a podcast with more episodes comes first, and a newer episode comes before an older one. We also drop weak matches. Without that, searching for <code>kolbäck</code> would list every episode that happens to mention the village of Kolback somewhere deep in its description.</p>\n<p><strong>One search across everything.</strong> The same box finds podcasts, episodes, collections and focus areas. There's also a results page at <code>/hitta</code> where podcasts show as cards and episodes as rows with cover, show name, snippet and date. The address contains your search, so you can share it.</p>\n<p><strong>Newly published episodes show up quickly.</strong> A new episode of a show you follow shouldn't be missing from search for a day. A small job adds new episodes to the index every ten minutes. A full rebuild runs nightly to catch everything else.</p>\n<h2 id=\"where-it-still-falls-short\" data-toc-text=\"Where it still falls short\">Where it still falls short</h2>\n<p>We try to be honest about trade-offs in the docs, and the same applies here.</p>\n<p><strong>It matches the start of words, not the middle.</strong> <code>fotboll</code> finds <code>Fotbollspodden</code>. <code>podden</code> does not. The old database query would have found it. That's the price of the typo tolerance, and it hurts with Swedish compound words. I think the trade is right, since typos are more common than searching for the end of a word. But some listeners will notice.</p>\n<p><strong>New things take a little while.</strong> Not everything is picked up by the ten-minute job. If a feed changes an episode's title, that waits for the nightly rebuild.</p>\n<p><strong>It uses real resources.</strong> The index for about 260,000 episodes takes around 2 GB of disk, and a rebuild needs room for the old and new index side by side. That's fine for us, but it's not free.</p>\n<h2 id=\"why-meilisearch\" data-toc-text=\"Why Meilisearch\">Why Meilisearch</h2>\n<p>We looked at two open source engines: <a href=\"https://typesense.org/\" target=\"_blank\" rel=\"noopener noreferrer\">Typesense</a> and Meilisearch. Both are fast, both forgive typos, and both can run on your own server. Either would probably have worked for us. We went with Meilisearch.</p>\n<p>What we ended up relying on, and what makes it a good fit for HittaPodd:</p>\n<ul>\n<li><strong>Typo tolerance we can tune.</strong> We set how long a word must be before a typo is forgiven, which fixed short words matching too loosely.</li>\n<li><strong>A ranking score for every hit.</strong> That let us drop weak matches, like a near miss buried in a long description.</li>\n<li><strong>Language settings.</strong> We can tell the engine which language a field is written in, which matters for Swedish.</li>\n<li><strong>A plain HTTP interface.</strong> Our client is small and has no extra dependency. That keeps the search code easy to read and replace.</li>\n</ul>\n<p>I'd say the same to anyone choosing between the two: try both on your own data. Search quality depends on your content, and a day of testing tells you more than a comparison table.</p>\n<h3 id=\"and-compared-with-algolia\" data-toc-text=\"And compared with Algolia\">And compared with Algolia</h3>\n<p>The hosted name most people know is <a href=\"https://www.algolia.com/\" target=\"_blank\" rel=\"noopener noreferrer\">Algolia</a>. It's good and easy to start with, and for many teams it's the right call. If you're willing to self-host, though, Meilisearch or Typesense is a good alternative:</p>\n<ul>\n<li><strong>It's ours.</strong> The data stays on our own server. There's no third party in the path of every search a listener makes.</li>\n<li><strong>The cost is predictable.</strong> We pay for a server we already run, not per search or per record. With a catalogue of hundreds of thousands of episodes, that matters.</li>\n<li><strong>It's small to run.</strong> For us it's one container with a memory cap and no public port. Only our own services can reach it.</li>\n</ul>\n<p>The honest other side is that you take on the work. You size the server, keep the index up to date, and handle upgrades yourself. A hosted service does all of that for you, and for a small team that may be worth the price. Meilisearch also offers a hosted version if you want the engine without running it.</p>\n<p>Our setup makes self-hosting lower-risk than it sounds, because the index is only a fast copy. If it's lost, we rebuild it from the database.</p>\n<h2 id=\"the-safety-net\" data-toc-text=\"The safety net\">The safety net</h2>\n<p>The part I like most is what happens when the search engine is down. The answer is: nothing visible. The API quietly falls back to the old database search, and the listener gets slower, less forgiving results instead of an error. We only see it in the logs.</p>\n<p>Two design choices make that safe.</p>\n<p><strong>The engine only decides what matches and in what order.</strong> The actual podcast and episode data is always read from our database. So if an admin hides an episode, or a podcast is removed, or a collection is made private, it disappears from search results right away. The index doesn't have to be rebuilt first. The result looks the same whether it came from the engine or from the fallback.</p>\n<p><strong>The index can always be rebuilt.</strong> Meilisearch is a fast copy of what's in the database, never the source of truth. The nightly rebuild builds a fresh index on the side and swaps it in, so a search never hits one that's half finished. Upgrading Meilisearch means wiping the index and rebuilding it. That sounds drastic and is actually boring, which is what we want.</p>\n<h2 id=\"what-s-next-finding-what-you-didn-t-know-to-search-for\" data-toc-text=\"What's next: finding what you didn't know to search for\">What's next: finding what you didn't know to search for</h2>\n<p>Search only helps people who already know what they're looking for. Some of the best listening comes from the show you'd never have typed in. That's the next job for the same engine: recommendations and personalization.</p>\n<p>None of this is built yet, so this is the direction and not a feature list. But Meilisearch is a good fit for it, and here is what we want it to make possible for listeners:</p>\n<ul>\n<li><strong>&quot;If you liked this, try that.&quot;</strong> An episode or podcast page that suggests things close to it in topic, not just things with a similar name. We already find similar podcasts today. A search engine that understands words and ranking lets us do it for episodes too, and do it fast enough to show on every page.</li>\n<li><strong>A start page that knows you.</strong> What you've listened to, saved and followed can shape what you see first, so you spend less time scrolling through things that don't interest you.</li>\n<li><strong>Search that leans your way.</strong> Of two equally good matches, the one closer to what you usually listen to can come first. Someone who follows football podcasts probably means the sports show when they type a short, ambiguous word.</li>\n<li><strong>Discovery beyond the obvious.</strong> Recommendations that only repeat the most popular shows aren't much help. We'd like to surface good, smaller podcasts that match your taste and that you'd otherwise miss.</li>\n</ul>\n<p>Personalization comes with a responsibility. We want it to be something you can see and control, not a black box. That means being clear about what's used, keeping it to what a listener has chosen to do on HittaPodd, and always leaving a plain, non-personalized way to browse and search. A recommendation that feels creepy is worse than none.</p>\n<p>We'll write about it as it takes shape, including what doesn't work. In the meantime, I'd also like to look at which searches return nothing, since those show what listeners want and we don't have. Compound words are the other thing on my mind, since they're where the engine is weakest for Swedish.</p>\n<p>If a search on HittaPodd doesn't find what you expected, tell us. It's the quickest way for us to find the next thing to fix.</p>\n",
            "date_published": "2026-11-15T00:00:00Z",
            "tags": ["go","meilisearch","podcasts","search","ux"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/hittapodd-php-to-go/",
            "url": "https://yetric.com/blog/posts/hittapodd-php-to-go/",
            "title": "From PHP to Go: Rebuilding the Backend for HittaPodd.se",
            "summary": "How HittaPodd.se moved from PHP to Go and from a shared database to one of its own. What went well, what went wrong, and what we learned.",
            "content_html": "<p><a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a> now runs on Go. The old PHP API has been retired, and the app has a database of its own instead of sharing one with other things.</p>\n<p>This isn't a how-to. I'm leaving the code out and writing about why we did it, what helped, and the things that didn't go as planned. We got a fair amount wrong along the way.</p>\n<h2 id=\"why-we-did-it\" data-toc-text=\"Why we did it\">Why we did it</h2>\n<p>Nothing was broken. The PHP version worked. The reason is bigger than one app: we want to retire PHP as a runtime across our product portfolio and move toward Go. HittaPodd was the next one in line.</p>\n<p>Fewer runtimes means less to patch, less to keep in your head, and less to explain to anyone joining a project. That was the bet, at least.</p>\n<p>There was also a reason specific to HittaPodd. The app shared a database with other things. Nobody decided that, it just happened over the years. It was convenient at first and then turned into a dependency nobody had chosen. Changing runtimes seemed like a reasonable time to deal with it.</p>\n<h2 id=\"how-it-went\" data-toc-text=\"How it went\">How it went</h2>\n<p>It wasn't done in one go. A first pass in March got the basics and the background jobs running in Go: importing podcasts, reading feeds, making thumbnails, finding similar podcasts. Then it sat for a while because other work came first. We picked it up again in the autumn, and the actual cutover happened over a few weeks in late October.</p>\n<p>Looking back, the pause helped. When we returned to it, it was clearer what was still missing.</p>\n<h2 id=\"moving-one-piece-at-a-time\" data-toc-text=\"Moving one piece at a time\">Moving one piece at a time</h2>\n<p>We used nginx, which already sat in front of the API, to decide where each request went. PHP kept answering everything, and we moved groups of routes to Go one step at a time. First the catalogue (categories, collections, authors), then podcasts, episodes and search, then similar podcasts and series. The background jobs moved in between.</p>\n<p>This worked better than I expected:</p>\n<ul>\n<li><strong>Each step was small.</strong> A few routes at a time meant that when something looked wrong, there wasn't much to search through.</li>\n<li><strong>Going back was easy.</strong> Sending a route back to PHP was a change in nginx, not a new release. That made it less scary to try the next step.</li>\n<li><strong>We could see what was left.</strong> Whatever nginx still sent to PHP was the work that remained.</li>\n<li><strong>PHP and Go ran side by side.</strong> We could compare them on real traffic, instead of guessing how they'd differ.</li>\n</ul>\n<h2 id=\"what-went-better\" data-toc-text=\"What went better\">What went better</h2>\n<p><strong>Speed.</strong> Search was the slowest part. Once we measured it on production data, we got an uncached episode search from about 1.4 seconds down to about 0.6, and later made most searches faster again. Day to day, the API answers with a median around 18 ms, though that's from a single hour, so take it as a rough picture.</p>\n<p><strong>The database is ours.</strong> HittaPodd now has a database that only holds HittaPodd data, and Go owns the schema. Migrations live next to the code and run in CI. I can change a table without first wondering who else reads it.</p>\n<p><strong>A reason to revisit the background work.</strong> The feed updater now checks feeds less often when they rarely change and backs off when one misbehaves. Thumbnails are made from a queue. Similar podcasts are found through shared vocabulary rather than name matching. None of that required Go, but the rewrite gave us a reason to look at it.</p>\n<p><strong>Room for new things.</strong> With the foundation in place, we've been able to add accounts, playlists, OPML import, an admin, and an MCP server. We probably wouldn't have gotten to those on the old setup.</p>\n<h2 id=\"what-was-hard\" data-toc-text=\"What was hard\">What was hard</h2>\n<p><strong>Untangling the shared database.</strong> Working out what actually belonged to HittaPodd took longer than the code did. After years with other tenants, the boundaries were blurry. We started from an exact copy of production's schema and sorted it out from there. I'm not certain we made every call right the first time.</p>\n<p><strong>Matching the old behavior.</strong> The frontend relied on details that only the PHP code defined, and nobody had written them down. In one case a renamed field would have made every private collection look public. We added tests that compare the API spec to the real code, and they found 87 mismatches the first time they ran. That was humbling.</p>\n<p><strong>The first route move broke the site.</strong> We had a new frontend ready, but its deploy failed, so the live site was still running an older build. Installed apps and open tabs do the same. They kept expecting PHP's response format, and Go answered in a different one. We should have caught that before moving anything. The fix was to let Go answer in the old format when asked. nginx asks on behalf of old clients, and new clients get the new format. We used that for every step after.</p>\n<p><strong>Moving the data.</strong> Data migrations make me nervous. We rehearsed it several times, ran it, checked the result, threw it away, and repeated, until the real run was uneventful.</p>\n<p><strong>Real traffic is different from tests.</strong> Some of our heaviest traffic comes from our own apps and partner sites, and it doesn't behave like anything we'd have made up. Search was the clearest case, and we only found it by looking at real numbers.</p>\n<h2 id=\"what-we-d-do-the-same-and-what-we-d-change\" data-toc-text=\"What we'd do the same, and what we'd change\">What we'd do the same, and what we'd change</h2>\n<p>Things we'd repeat:</p>\n<ul>\n<li>Move one route at a time behind a switchboard, even though it feels slow.</li>\n<li>Get the old behavior right first and improve things afterwards.</li>\n<li>Measure before tuning anything.</li>\n<li>Give an app its own database.</li>\n</ul>\n<p>Things we'd do differently:</p>\n<ul>\n<li>Check what old clients expect before moving the first route.</li>\n<li>Write down the quirks of the old system earlier, before they turn into surprises.</li>\n</ul>\n<h2 id=\"where-that-leaves-us\" data-toc-text=\"Where that leaves us\">Where that leaves us</h2>\n<p>HittaPodd.se is simpler to run now, and it doesn't depend on anything it didn't choose. It's also one less PHP app in the portfolio, which was the goal. There are surely rough edges we haven't found yet.</p>\n<p>If you spot something that feels off on <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a>, I'd like to hear about it.</p>\n<p>And if you have an old system you're nervous about touching, <a href=\"https://yetric.com/contact/\">get in touch</a>. This is the kind of work I like helping with.</p>\n",
            "date_published": "2026-11-07T00:00:00Z",
            "tags": ["engineering","go","migration","php","podcasts"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/pcmr-better-pc-builder/",
            "url": "https://yetric.com/blog/posts/pcmr-better-pc-builder/",
            "title": "Building a Better PC Builder for PCMR",
            "summary": "How we're improving PCMR's PC builder with compatibility checks, guided choices, live prices, and shareable builds.",
            "content_html": "<h2 id=\"building-a-pc-should-feel-exciting\" data-toc-text=\"Building a PC should feel exciting\">Building a PC should feel exciting</h2>\n<p>Building your own gaming PC is one of those projects that is both more accessible and more intimidating than it first appears.</p>\n<p>The individual decisions are understandable. Pick a processor. Pick a graphics card. Add memory, storage, a power supply, and a case. But once those decisions interact, the number of ways to get something subtly wrong grows quickly. A part can look like a good deal and still be the wrong choice for the rest of the build. A specification can be technically compatible while making the finished computer unnecessarily difficult to assemble or upgrade.</p>\n<p>That is the problem we have been working on at <a href=\"https://pcmr.se/\" target=\"_blank\" rel=\"noopener\">PCMR</a>: making a better PC builder for people who want to choose their own components without needing to become hardware experts first.</p>\n<p>PCMR started as a Swedish price comparison site for PC hardware. The first version of the builder could help you select parts, but it still assumed that you already understood how a computer goes together. The new direction is more ambitious: the <a href=\"https://pcmr.se/bygge/ny\" target=\"_blank\" rel=\"noopener noreferrer\">new-build flow</a> should help someone go from an empty page to a sensible, purchasable build, while still giving experienced builders complete control.</p>\n<h2 id=\"the-real-product-is-confidence\" data-toc-text=\"The real product is confidence\">The real product is confidence</h2>\n<p>A list of components is not enough. A useful PC builder needs to answer the questions that appear between the product pages:</p>\n<ul>\n<li>Will these parts work together?</li>\n<li>Am I paying a reasonable price?</li>\n<li>Is this build balanced for what I want to do with it?</li>\n<li>What am I forgetting?</li>\n<li>If I change one part, what else needs to change?</li>\n</ul>\n<p>Those questions are connected. Choosing a different processor can affect the motherboard. The motherboard can affect memory support and the case. The graphics card affects the power supply, available space, and, often, the total budget. The interface needs to make those relationships visible without turning the experience into a spreadsheet.</p>\n<p>The goal is not to hide the complexity. It is to put the complexity in the right place: in the product's rules and data, rather than in the user's head.</p>\n<h2 id=\"compatibility-is-the-foundation\" data-toc-text=\"Compatibility is the foundation\">Compatibility is the foundation</h2>\n<p>Compatibility checking is easy to describe and difficult to get right. The builder now treats it as a first-class part of the experience rather than a final form validation step.</p>\n<p>It is tempting to think of it as a collection of warnings: this socket does not match that socket, this component needs more space, or this power supply is too small. But a useful builder has to do more than reject obviously invalid combinations. It has to help people understand why a choice matters and what alternatives they have.</p>\n<p>That changes the design of the whole experience. A warning should not be a dead end. It should point towards a decision:</p>\n<blockquote>\n<p>This part does not fit this build because of X. Here are the changes that would make it work.</p>\n</blockquote>\n<p>That is a much better interaction than allowing someone to complete a build and discover the problem only when the boxes arrive. It also means the API has to understand more than product categories. It needs to reason about sockets, memory, form factors, clearances, power, and the relationships between the selected parts.</p>\n<p>The result is a set of verdicts attached to the build and its slots. A part can be compatible, incompatible, or still need more information. That last state matters: pretending that incomplete data is a clean &quot;yes&quot; is worse than explaining what is unknown and giving the user a way to resolve it.</p>\n<h2 id=\"price-is-part-of-the-decision\" data-toc-text=\"Price is part of the decision\">Price is part of the decision</h2>\n<p>Component selection is not just a technical exercise. Most builds have a budget, and prices move.</p>\n<p>Showing a component without showing its cost makes the choice incomplete. Comparing prices without considering compatibility is just as misleading. PCMR's builder brings those concerns together so that the build can be evaluated as a whole: the parts, the total cost, and whether the result makes sense.</p>\n<p>This also makes trade-offs easier to see. A slightly more expensive component may remove the need for another upgrade. A cheaper part may leave room in the budget for a better graphics card. There is rarely one universally correct build; there are only better and worse choices for a particular goal.</p>\n<h2 id=\"guiding-without-taking-over\" data-toc-text=\"Guiding without taking over\">Guiding without taking over</h2>\n<p>There is a balance to strike in any configuration tool.</p>\n<p>If the builder gives users no guidance, beginners are left alone with a catalogue of unfamiliar specifications. If it makes every decision for them, experienced users lose control and beginners never learn why the recommendations are sensible.</p>\n<p>We want PCMR to sit in the useful middle. The user should be able to make the decisions, while the builder supplies the context. That has led to several entry points instead of one monolithic workflow:</p>\n<ul>\n<li>compatibility checks when a choice affects the rest of the build</li>\n<li>a guided builder for people who want to start with a budget or a goal</li>\n<li>a traditional slot-by-slot builder for people who already have a plan</li>\n<li>&quot;Passar med&quot; suggestions from product pages</li>\n<li>candidate lists that can be filtered by brand, store, name, and price</li>\n<li>prices that make budget trade-offs visible</li>\n<li>a clear view of what has already been selected</li>\n<li>feedback that helps explain the consequences of changing a part</li>\n</ul>\n<p>That makes the tool useful for someone building their first PC, without making it frustrating for someone who already knows exactly which components they want. You can start from a product in the <a href=\"https://pcmr.se/cpu\" target=\"_blank\" rel=\"noopener noreferrer\">component catalogue</a>, add it to a build, and let the builder narrow the next choices; or start from an empty build and choose every slot yourself.</p>\n<h2 id=\"a-better-builder-is-an-information-problem\" data-toc-text=\"A better builder is an information problem\">A better builder is an information problem</h2>\n<p>The visible interface is only one part of the work. Behind it is a large, changing set of product data and relationships.</p>\n<p>Parts have specifications, prices, dimensions, power requirements, and compatibility constraints. Those facts need to be represented consistently enough that the builder can reason about them, while still being understandable when they reach the user. The quality of the experience depends on both sides: good data and good decisions about how to present it.</p>\n<p>This is where the work spans both PCMR and <a href=\"https://hembiosystem.se/\" target=\"_blank\" rel=\"noopener\">Hembiosystem</a>. The PCMR product catalogue and compatibility work provide the product side of the system: the API can return compatible candidates, verdicts, prices, power information, and related products. Hembiosystem uses those PCMR products in its <a href=\"https://hembiosystem.se/htpc\" target=\"_blank\" rel=\"noopener noreferrer\">HTPC section</a>, another example of presenting technical products through a more useful buying context. PCMR turns the same information into a builder that people can actually use. Keeping that boundary explicit lets the frontend stay focused on decisions while the backend owns the rules and product data.</p>\n<p>It also gives us a place to improve the underlying data. Product specifications are not always perfect, so one of the planned parts of the workflow is letting visitors report an incorrect specification. A compatibility system is only trustworthy if there is a path for correcting the facts it relies on.</p>\n<h2 id=\"builds-are-meant-to-be-used\" data-toc-text=\"Builds are meant to be used\">Builds are meant to be used</h2>\n<p>A build is not finished when the last slot is filled. People want to come back to it, ask someone else for advice, and buy the parts when the timing is right.</p>\n<p>The new builder supports saving and editing builds, copying an existing build to make a variation, and sharing a build with a link. The <a href=\"https://pcmr.se/bygge/mina\" target=\"_blank\" rel=\"noopener noreferrer\">saved-builds view</a> keeps those builds available in the browser, while shared builds show the selected parts together with their compatibility verdicts, total, and power information. Prices are deliberately not treated as permanent: build pages need to reflect current prices rather than presenting an outdated snapshot as fact.</p>\n<p>We are also working through the practical shopping question. The cheapest individual price can be spread across several stores, while buying everything from one store can be worth paying a little more for. The useful comparison is not just &quot;what is the cheapest part?&quot; but &quot;what will this complete basket cost, and where can I buy it?&quot;</p>\n<p>This is a familiar software engineering pattern. The difficult part is not rendering a list of products. The difficult part is building a model that can support trustworthy decisions and an interface that communicates those decisions clearly.</p>\n<h2 id=\"what-we-are-learning\" data-toc-text=\"What we are learning\">What we are learning</h2>\n<p>Working on PCMR has reinforced a few lessons that apply well beyond hardware:</p>\n<p><strong>The happy path is not the product.</strong> The interesting work starts when someone changes a part, has a tight budget, or makes a choice that affects three other components.</p>\n<p><strong>Rules are part of the user experience.</strong> A compatibility rule is not merely backend logic. It becomes a message, a suggestion, and sometimes the difference between confidence and hesitation.</p>\n<p><strong>Progressive disclosure beats a wall of information.</strong> People need enough detail to make the next decision, not every specification at once.</p>\n<p><strong>Good tools make expertise transferable.</strong> The best outcome is not only that someone finishes a build. It is that they understand the important trade-offs well enough to make the next choice themselves.</p>\n<p><strong>Measurement has to follow the journey.</strong> We are tracking the builder as a funnel: starting a build, filling slots, opening a picker, checking a verdict, saving, sharing, and clicking through to a store. That tells us which parts of the experience help people move forward instead of leaving us to judge the interface by intuition.</p>\n<h2 id=\"making-the-first-step-easier\" data-toc-text=\"Making the first step easier\">Making the first step easier</h2>\n<p>PCMR is built around a simple idea: choosing your own PC should be rewarding, not a test of how many hardware compatibility tables you have memorised.</p>\n<p>We are continuing to improve the builder around that idea—making it easier to choose parts, compare prices, save a build, and catch problems before they become expensive surprises. There is still plenty to do, especially around starter builds and better explanations, but the direction is clear: the builder should reduce uncertainty without taking the building experience away from the person using it.</p>\n<p>If you are planning a gaming PC, <a href=\"https://pcmr.se/bygge\" target=\"_blank\" rel=\"noopener\">try the PCMR builder</a> and see what you can build.</p>\n",
            "date_published": "2026-10-09T00:00:00Z",
            "tags": ["pc-building","pcmr","product","user-experience"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/vm-2026-fantasy-tipset/",
            "url": "https://yetric.com/blog/posts/vm-2026-fantasy-tipset/",
            "title": "VM 2026 Tipset: Predict the World Cup with Friends",
            "summary": "A fantasy football game for the 2026 World Cup on Fotbollsfeber.se: predict results, create a private pool and compete with friends on a leaderboard.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>We've launched <a href=\"https://fotbollsfeber.se/vm-2026\" target=\"_blank\" rel=\"noopener noreferrer\">VM 2026 Tipset</a> on Fotbollsfeber.se — a free fantasy football game for the 2026 World Cup. Predict all 104 matches, create a private pool, and compete against friends on a shared leaderboard.</p>\n<hr />\n<h2 id=\"what-it-is\" data-toc-text=\"What It Is\">What It Is</h2>\n<p>The 2026 World Cup runs June 11 through July 19, across 48 teams and 16 host cities in the US, Canada, and Mexico. It's the biggest tournament in the history of the competition, and we wanted to give football fans a reason to be invested in every match — not just the ones their own country is playing.</p>\n<p><a href=\"https://fotbollsfeber.se/vm-2026\" target=\"_blank\" rel=\"noopener noreferrer\">VM 2026 Tipset</a> is built around a simple idea: before the tournament starts, you predict the score of every group stage match. Once the knockout stage is drawn, you fill in the bracket. Points accumulate across all 104 matches, and you compete against everyone in your pool.</p>\n<hr />\n<h2 id=\"how-it-works\" data-toc-text=\"How It Works\">How It Works</h2>\n<p><strong>Group stage:</strong> Predict the score of all 72 group stage matches before the opening match on June 11. You earn points for each correct component — right outcome (3p), right home goals (2p), right away goals (2p). Max 7 points for an exact result.</p>\n<p><strong>Knockout bracket:</strong> Once the groups are decided (around June 27), you fill in the full bracket. The further a team goes, the more your pick is worth — from 2 points in the round of 32 up to 32 points for calling the champion.</p>\n<p><strong>Special predictions:</strong> Eight tournament-level picks — top scorer, most clean sheets, which host nation goes furthest, whether the final goes to penalties, and more. Worth 10–15 points each.</p>\n<p><strong>Private pools:</strong> Create a pool, share the link or 6-digit code, and your friends join. You can be in multiple pools — one with workmates, one with your football club — each with their own leaderboard and their own set of predictions.</p>\n<hr />\n<h2 id=\"try-it\" data-toc-text=\"Try It\">Try It</h2>\n<p>The group stage locks when the opening match kicks off on June 11. That gives you just under three weeks to get your predictions in.</p>\n<p><a href=\"https://fotbollsfeber.se/vm-2026\" target=\"_blank\" rel=\"noopener noreferrer\">Start your pool at fotbollsfeber.se/vm-2026</a> — it's free, and you don't need to already be a Fotbollsfeber user.</p>\n",
            "date_published": "2026-05-20T00:00:00Z",
            "tags": ["football","fotbollsfeber","product","vm-2026"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/focused-ux-pushes/",
            "url": "https://yetric.com/blog/posts/focused-ux-pushes/",
            "title": "Sometimes You Need a Focused UX Push",
            "summary": "A short reflection on why product teams sometimes need bounded pushes that focus on one class of problem, using recent Fotbollsfeber UX work as the example.",
            "content_html": "<p>Over the last few days we made a focused UX push on <a href=\"https://fotbollsfeber.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Fotbollsfeber</a>.</p>\n<p>Not a redesign. Not a rebrand. Not a &quot;let's rethink everything&quot; exercise.</p>\n<p>Just a short, deliberate pass over the parts of the product where the experience had started to lag behind the capability of the system.</p>\n<p>That distinction matters.</p>\n<h2 id=\"products-accumulate-friction\" data-toc-text=\"Products Accumulate Friction\">Products Accumulate Friction</h2>\n<p>Most useful products get rough before they get polished.</p>\n<p>You add a prediction model. Then a match center. Then filters. Then favorite teams. Then a watchlist. Then league pages, match pages, simulation views, standings, form indicators, and small bits of editorial context.</p>\n<p>Each individual change can be reasonable. The problem is the sum.</p>\n<p>After a while, the product has more power than clarity. The data is there, but the hierarchy is uneven. Important controls are technically present, but not always where people expect them. Mobile layouts work, but only if you are forgiving. Dense analytical screens contain the right information, but they require too much effort to scan.</p>\n<p>None of this is catastrophic. That is why it is easy to ignore.</p>\n<p>It is also exactly why it needs attention.</p>\n<h2 id=\"why-a-focused-push-works\" data-toc-text=\"Why a Focused Push Works\">Why a Focused Push Works</h2>\n<p>UX debt is hard to fix opportunistically.</p>\n<p>If you only improve usability while working on unrelated features, you tend to fix the visible irritation in front of you and leave the system-level pattern untouched. One page gets better. Another page keeps the old spacing. One component gets clearer labels. Another still uses a different visual language.</p>\n<p>A focused push lets you stay inside one problem space long enough to see the repetition.</p>\n<p>For Fotbollsfeber, that meant spending a few days on the same family of issues:</p>\n<ul>\n<li>personalization should feel native, not bolted on</li>\n<li>dense football data should remain scannable</li>\n<li>analytical surfaces should share a consistent visual rhythm</li>\n<li>mobile layouts should be designed for the actual viewport, not merely squeezed into it</li>\n</ul>\n<p>The point was not any single pull request. The point was momentum around one concern: make the product easier to understand and use without making it less capable.</p>\n<h2 id=\"focus-creates-better-taste\" data-toc-text=\"Focus Creates Better Taste\">Focus Creates Better Taste</h2>\n<p>There is a practical benefit to doing this work in a cluster: your judgment improves as you go.</p>\n<p>The first fix reveals the second. The second makes an inconsistency obvious somewhere else. A component that felt fine in isolation suddenly looks awkward next to the newer pattern. A mobile layout that technically passed becomes clearly too compressed once nearby screens improve.</p>\n<p>This is not scope creep if the frame is clear.</p>\n<p>It is the work becoming legible.</p>\n<p>Focused pushes are useful because they give a team permission to follow those connections for a bounded period of time. You are not opening the door to infinite polish. You are saying: for the next few days, this specific quality dimension matters more than the backlog's usual ordering.</p>\n<p>That can be necessary.</p>\n<h2 id=\"the-risk-of-always-shipping-features\" data-toc-text=\"The Risk of Always Shipping Features\">The Risk of Always Shipping Features</h2>\n<p>Feature work is easier to justify than product quality work because it is easier to name.</p>\n<p>&quot;Add a watchlist&quot; sounds concrete.</p>\n<p>&quot;Make the match center feel calmer, denser, and more predictable&quot; sounds softer, even when it has more impact on daily use.</p>\n<p>But products are not judged only by the features they contain. They are judged by how confidently people can move through them. A feature that exists but hides behind unclear hierarchy, cramped layouts, or inconsistent interaction patterns is not really finished.</p>\n<p>This is especially true for data-heavy products.</p>\n<p>The value is often in comparison: teams, matches, form, probabilities, standings, trends. If the interface makes comparison tiring, the product is wasting its own data.</p>\n<h2 id=\"a-push-is-not-a-permanent-mode\" data-toc-text=\"A Push Is Not a Permanent Mode\">A Push Is Not a Permanent Mode</h2>\n<p>The key is that this kind of work needs boundaries.</p>\n<p>A focused UX push should have a theme, a short time window, and a clear exit. It should improve the product's foundations, then hand attention back to the broader roadmap.</p>\n<p>Without boundaries, polish becomes avoidance.</p>\n<p>With boundaries, it becomes maintenance of product trust.</p>\n<p>For Fotbollsfeber, this push was about tightening the experience around the work already done: making personalization more visible, making dense views more usable, improving hierarchy, and reducing small bits of friction that get in the way of understanding the football.</p>\n<p>The product did not become something else.</p>\n<p>It became more itself.</p>\n<h2 id=\"the-broader-lesson\" data-toc-text=\"The Broader Lesson\">The Broader Lesson</h2>\n<p>Most teams should occasionally ask: what class of problem have we been stepping around?</p>\n<p>Not which ticket is next. Not which feature is most exciting. Which kind of problem keeps showing up in different forms?</p>\n<p>Maybe it is onboarding. Maybe it is performance. Maybe it is copy. Maybe it is accessibility. Maybe it is the fact that every settings screen behaves slightly differently.</p>\n<p>When the same issue appears across the product, fixing one instance at a time is usually too slow. You need a short push that treats the pattern as the work.</p>\n<p>That is what we did here.</p>\n<p>Sometimes progress is not adding a new capability. Sometimes progress is taking the capabilities you already built and making them easier to trust.</p>\n",
            "date_published": "2026-05-06T00:00:00Z",
            "tags": ["fotbollsfeber","product","strategy","ux"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/cartridge-engine-three-demos/",
            "url": "https://yetric.com/blog/posts/cartridge-engine-three-demos/",
            "title": "Cartridge Engine: Three Demos Later",
            "summary": "Four weeks after introducing a constraint-first game engine, I had to ship three playable demos inside its limits. Here’s what happened.",
            "content_html": "<p>A few weeks ago I wrote about <a href=\"https://yetric.com/blog/posts/cartridge-engine-building-a-console/\">Cartridge Engine</a> — a 2D game engine designed like a retro console, with fixed hardware specs and no escape hatches. The pitch was: constraints are features, determinism matters more than flexibility, the game declares its hardware and the engine enforces it.</p>\n<p>That post was written at a fairly early stage. The engine ran. A demo cartridge existed. The architecture was sound. But the three games I listed as the real test — a Zelda-like, a platformer, a match-3 — weren't playable yet.</p>\n<p>They are now. Here's what I learned building them.</p>\n<hr />\n<h2 id=\"what-shipped\" data-toc-text=\"What shipped\">What shipped</h2>\n<p>Three cartridges are running in-engine, each a different genre:</p>\n<p><strong>Adventure</strong> — a top-down game with rooms, a combat loop, enemies with distinct AI behaviors, dialogue, interactive objects, an inventory, and a win condition. It uses the most engine features of the three.</p>\n<p><strong>Platformer</strong> — a side-scroller with gravity, tile-based collision, a level-end goal, parallax backgrounds, per-level music, and a death/respawn flow. The engine's tile collision system was designed for top-down; making it work for a platformer revealed some interesting edge cases.</p>\n<p><strong>Puzzle</strong> — a match-3 with a board rendered from the dungeon tileset, gem swap animations, match flash feedback, a score target win condition, a timer, and a no-moves-left shuffle. This one was the most useful for stress-testing the animation and tween systems.</p>\n<p>All three have a title screen, a game-over screen, and return to the in-engine cartridge selector when they end. Consistent HUD style across all three.</p>\n<hr />\n<h2 id=\"what-the-engine-needed-to-make-this-work\" data-toc-text=\"What the engine needed to make this work\">What the engine needed to make this work</h2>\n<p>Phase 1 laid the foundations — animation state machine, deterministic RNG, timers and tweens, save/load, cartridge self-registration. But building actual games exposed what was missing beyond that.</p>\n<p>The biggest additions, in rough order of difficulty:</p>\n<p><strong>Dialogue and interaction zones.</strong> A first-person trigger zone system with <code>action</code> and <code>enter</code> semantics. A typewriter text box renderer that pauses the cartridge tick while open. Branching choice prompts with d-pad navigation. A <code>.dlg</code> script format compiled to typed constants via codegen, so cartridge code references IDs rather than raw strings.</p>\n<p>Getting the &quot;pause tick while dialogue is open&quot; behavior right was trickier than expected. The engine owns the loop — it decides whether to call <code>tick()</code> this frame. The cartridge has no say. That's correct design, but it means the engine needs to know when dialogue is active, which creates a small coupling. The solution was a simple <code>isBlocking()</code> flag on the dialogue system that the runtime loop checks before calling <code>tick()</code>.</p>\n<p><strong>Combat primitives.</strong> Separate hitbox and hurtbox per entity. Invincibility frames (i-frames) counted in ticks, not milliseconds — this matters for determinism. A <code>onHit(attacker, victim, damage)</code> hook the cartridge wires up. Floating damage numbers via a pooled HUD layer.</p>\n<p><strong>Enemy AI.</strong> A small finite state machine library: <code>patrol</code>, <code>chase</code>, <code>flee</code>, <code>attack</code>. Declarative wiring — the cartridge specifies what the AI should do, not how. Pathfinding on the collision grid via A*, with a bounded step count per tick so the CPU budget stays fixed.</p>\n<p><strong>Inventory.</strong> Fixed-size slots declared in the manifest. <code>add</code>, <code>remove</code>, <code>has</code>, <code>count</code>, <code>equip</code>. Stackable vs unique items declared on the item definition. No runtime surprises — overflow policy is explicit (reject, not silent drop).</p>\n<p><strong>Cutscenes and camera.</strong> A tick-based sequencer that chains entity moves, dialogue, SFX, and waits. It pauses player input automatically and restores on finish. Camera now supports lerp-to-target, directional lookahead, and bounds clamping to map edges.</p>\n<p><strong>Screen effects and particles.</strong> Flash, fade-to-color, screen shake with fixed amplitude presets. A particle emitter with pooled instances and built-in presets (<code>dust</code>, <code>spark</code>, <code>smoke</code>). These live in the engine's rendering pipeline, not in cartridge code.</p>\n<hr />\n<h2 id=\"things-the-constraints-got-right\" data-toc-text=\"Things the constraints got right\">Things the constraints got right</h2>\n<p>I said in the original post that constraints force decisions earlier. That turned out to be more important than I expected.</p>\n<p>The <code>inventory: { slots: 16 }</code> line in the manifest is a good example. It forces you to decide, before writing any inventory code, how many item slots the game has. And it forces the engine to enforce it — full is full. That sounds minor but it means the question &quot;what happens when the inventory is full?&quot; always has a crisp answer. The cartridge either handles it or the engine rejects the add. There's no third option where you quietly have 17 items.</p>\n<p>Item definitions follow the same pattern. Items are typed constants generated from the manifest. The cartridge cannot reference an item that isn't declared. This caught several mistakes during development where I would reference an item ID that I hadn't wired up yet. Compile-time error, not a runtime null.</p>\n<p>Enemy AI being declarative also worked out. The <code>chase</code> and <code>patrol</code> states are implemented once in the engine. The cartridge says which state the enemy starts in and what triggers transitions. The adventure cartridge has two distinct enemy behaviors — they're distinct not because I wrote different code but because the transition tables are different. One chases on sight and attacks on contact. One patrols until attacked, then chases. That differentiation is just data.</p>\n<hr />\n<h2 id=\"things-the-constraints-got-wrong\" data-toc-text=\"Things the constraints got wrong\">Things the constraints got wrong</h2>\n<p>The tile-based collision worked perfectly for the top-down game. It worked less perfectly for the platformer.</p>\n<p>The issue isn't the model — a flat tile array is still the right call. The issue is that platformer physics have some expectations about collision resolution that don't come for free. Specifically: when you're moving horizontally and hit a wall, you should stop moving horizontally without being pushed down. When you're falling and land on a tile, you should land cleanly on top of it, not clip into it slightly.</p>\n<p>The separated X/Y movement system handles this, but it required a few non-obvious corner case fixes when the player is in the corner of two tiles simultaneously. The adventure cartridge never exposed these because top-down movement doesn't have gravity and the player is rarely moving in two axes at full speed simultaneously.</p>\n<p>The lesson isn't that the collision model was wrong. It's that the constraint — tile-based collision only — is right for both genres, but the engine code needed to be a bit smarter about resolution order to be actually correct in both.</p>\n<p>The other tension is in audio. Eight channels, four music and four SFX. That's fine for one game. It's fine for three games. But writing a match-3 that has distinct sounds for each gem type under a four-SFX budget forced some creative decisions — you can have distinct sounds per gem type or distinct sounds per combo size, but not both. That's probably the right tradeoff for a constraint-first engine, but it's worth calling out: the constraint is real and it shapes what games are possible.</p>\n<hr />\n<h2 id=\"the-tooling-turned-out-to-matter\" data-toc-text=\"The tooling turned out to matter\">The tooling turned out to matter</h2>\n<p>I underestimated how much time I'd spend in the tools, not the engine.</p>\n<p>A sprite sheet editor. A palette editor (256 entries, palette-indexed). A tilemap editor with multi-layer editing, per-layer parallax scroll factors, and a collision-layer painter. An animation editor for wiring up the state machine visually. A dialogue editor with a graph view for branching. A chiptune/SFX tool over the synth parameters. A font browser for the four shipped fonts.</p>\n<p>None of these are sophisticated tools. They're all just good enough to make actual content. But &quot;just good enough&quot; is a real bar. The alternative is hand-editing JSON and pixel arrays, which is slow and error-prone.</p>\n<p>The CLI also shipped: <code>cart init</code>, <code>cart validate</code>, <code>cart codegen</code>, <code>cart inspect</code>, <code>cart build</code>, <code>cart watch</code>, <code>cart package</code>. The inspect output in particular is useful:</p>\n<pre class=\"shiki shiki-themes github-light-high-contrast github-dark-high-contrast\" style=\"--shiki-light:#0e1116;--shiki-dark:#f0f3f6;--shiki-light-bg:#ffffff;--shiki-dark-bg:#0a0c10\" tabindex=\"0\"><code class=\"language-text\"><span class=\"line\"><span>ROM:   18 MB / 64 MB</span></span>\n<span class=\"line\"><span>VRAM:   3 MB / 8 MB</span></span>\n<span class=\"line\"><span>RAM:   10 MB / 32 MB</span></span>\n<span class=\"line\"><span>Sprites: 96 / 128</span></span></code></pre>\n<p>Seeing the hardware budget at a glance keeps the constraints visible. It's easy to forget you're on &quot;fixed hardware&quot; when you're just writing TypeScript. The inspect output makes it concrete.</p>\n<hr />\n<h2 id=\"what-s-next\" data-toc-text=\"What's next\">What's next</h2>\n<p>A few things remain unbuilt that I want to finish:</p>\n<p><strong>Composite sprites.</strong> Multi-part characters where each part is an independent sprite slot but they move together as a unit. This is needed for larger characters and character customization. The engine currently has no concept of a sprite group — each sprite is independently positioned.</p>\n<p><strong>Capability validation.</strong> Static analysis of cartridge code against the manifest-declared capabilities. If you call <code>inventory.add(...)</code> but your manifest doesn't declare an inventory, the build should fail. Right now this is an honor system — the API just returns undefined for undeclared capabilities. I want the build to catch it.</p>\n<p><strong>Playtest recorder.</strong> Record <code>{ tick, inputs }</code> during play, replay deterministically. This is the real test of the determinism contract. Same seed plus same input sequence should always produce the same game state. If it doesn't, something is wrong.</p>\n<p>The three demos proved the architecture holds. The constraint-first model produced three very different games that all run in the same engine without any of them needing engine modifications or workarounds. The expansion system isn't built yet — that's how the engine is supposed to handle capabilities beyond the base console — but I haven't needed it for any of the three demos.</p>\n<p>That's probably the most honest validation: I built three games that required dialogue, combat, pathfinding, inventory, cutscenes, and particle effects, and none of them needed a plugin, a config option, or an escape hatch. They just used the API.</p>\n",
            "date_published": "2026-04-28T00:00:00Z",
            "tags": ["cartridge","gamedev","learning","typescript"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/cartridge-engine-building-a-console/",
            "url": "https://yetric.com/blog/posts/cartridge-engine-building-a-console/",
            "title": "Cartridge Engine: What I'm Learning by Building a Game Engine Like a Console",
            "summary": "I’m building a constraint-first 2D game engine from scratch to learn what happens when a system is designed around hard limits, not flexibility.",
            "content_html": "<h2 id=\"why-build-a-game-engine\" data-toc-text=\"Why build a game engine?\">Why build a game engine?</h2>\n<p>Not to use it. Not to compete with Unity or Godot. The honest answer is that I wanted to understand what happens when you design a system around constraints rather than flexibility — and building a game engine seemed like the most direct way to explore that.</p>\n<p>I've used modern engines and frameworks enough to know that they're optimized for capability. You can do almost anything. That's useful, but it also means you spend a lot of time just making decisions. And the more configurable a system is, the harder it is to reason about what it's actually doing at any moment.</p>\n<p>The question I kept coming back to: what if that wasn't the goal?</p>\n<hr />\n<h2 id=\"the-console-metaphor\" data-toc-text=\"The console metaphor\">The console metaphor</h2>\n<p>SNES and Mega Drive developers didn't have a flexible engine. They had hardware. Fixed resolution. Fixed tile size. A specific number of sprites. Defined audio channels. Those weren't limitations they worked around — they were the shape of the problem. And games from that era are often easier to understand at a systems level than modern ones precisely because the constraints were visible and shared.</p>\n<p>So I started building something I'm calling Cartridge Engine. The framing is:</p>\n<ul>\n<li>The <strong>engine is the console</strong> — it defines what's possible</li>\n<li>The <strong>game is a cartridge</strong> — it runs inside the console and can't escape it</li>\n<li>New capabilities come from <strong>hardware expansions</strong> — not plugins, not configuration</li>\n</ul>\n<p>The hardware spec is fixed: 320×180, 16×16 tiles, 128 sprites, 4 tile layers, 8 audio channels, 60Hz. These numbers are arbitrary enough to be honest — I picked them to be plausible, not to be optimal.</p>\n<p>The principles I wrote down at the start, and have mostly stuck to:</p>\n<ol>\n<li>Constraints are features</li>\n<li>Determinism over flexibility</li>\n<li>One way to do things</li>\n<li>No hidden behavior</li>\n<li>Capabilities must be declared</li>\n<li>No runtime magic</li>\n</ol>\n<hr />\n<h2 id=\"what-i-ve-learned-so-far\" data-toc-text=\"What I've learned so far\">What I've learned so far</h2>\n<p>Building this has been more educational than I expected, and in unexpected ways.</p>\n<p><strong>Constraints force decisions earlier.</strong> When you decide up front that collision is tile-based — 0 or 1 per 16px cell, no partial tiles — you stop having a whole category of design debates. You also discover which parts of your map don't actually align to the grid, and you fix them. The system is dumber but the result is cleaner.</p>\n<p>We actually had a pixel-rect collision system first. It worked, but it was floppy — arbitrary rectangles, a visual editor to tune them, lots of per-map exceptions. Replacing it with a flat tile array was a step backward in expressiveness and a step forward in everything else. Simpler to implement, simpler to reason about, simpler to debug. I think that trade is usually worth it and I don't always remember that.</p>\n<p><strong>The cartridge boundary is surprisingly useful.</strong> Writing the game as a function that receives a fixed API — <code>input</code>, <code>video</code>, <code>audio</code>, <code>system</code> — and nothing else forces you to be explicit about what the game actually needs from the engine. It can't reach into engine internals. It can't do anything that isn't in the API contract. That sounds restrictive but it mostly feels like clarity.</p>\n<p><strong>Audio is harder than it looks.</strong> Not the Web Audio API itself — that's fine — but figuring out where audio lives architecturally. It needs to be pre-decoded (no runtime parsing), channel-limited (8 channels, enforced), and ID-based (no file paths at runtime). Getting that right took longer than expected, partly because the temptation to just expose <code>AudioContext</code> directly to the cartridge is strong and wrong.</p>\n<p><strong>The &quot;one small game&quot; constraint is doing real work.</strong> The current demo is a cabin on a hill with an interior you can enter. It's not a game. But building it has already surfaced things I wouldn't have found just designing the engine in the abstract — collision edge cases, sprite z-ordering across layers, scene transition timing, how footstep sounds should relate to the walk cycle. The game is load-bearing.</p>\n<hr />\n<h2 id=\"what-s-running-today\" data-toc-text=\"What's running today\">What's running today</h2>\n<p>To make this concrete: here's what the engine does right now.</p>\n<p>A fixed 60Hz game loop. A 4-layer tilemap renderer with 128 sprites and per-sprite z-ordering. A 12-button input system mapped from keyboard. Tile-based collision. An 8-channel audio system with separate music and SFX channels. Scene transitions with music swapping. A demo cartridge with a hero character who walks around a 16-bit style cabin exterior, enters through the door, and explores the interior.</p>\n<p>The cartridge code for the game entry point looks like this:</p>\n<pre class=\"shiki shiki-themes github-light-high-contrast github-dark-high-contrast\" style=\"--shiki-light:#0e1116;--shiki-dark:#f0f3f6;--shiki-light-bg:#ffffff;--shiki-dark-bg:#0a0c10\" tabindex=\"0\"><code class=\"language-typescript\"><span class=\"line\"><span style=\"--shiki-light:#A0111F;--shiki-dark:#FF9492\">export</span><span style=\"--shiki-light:#A0111F;--shiki-dark:#FF9492\"> default</span><span style=\"--shiki-light:#622CBC;--shiki-dark:#DBB7FF\"> createCartridge</span><span style=\"--shiki-light:#702C00;--shiki-dark:#FFB757\">(({ input, video, audio }) </span><span style=\"--shiki-light:#A0111F;--shiki-dark:#FF9492\">=></span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\"> {</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#A0111F;--shiki-dark:#FF9492\">    return</span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\"> {</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#622CBC;--shiki-dark:#DBB7FF\">        boot</span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">() {</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#66707B;--shiki-dark:#BDC4CC\">            /* set up scene */</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">        },</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#622CBC;--shiki-dark:#DBB7FF\">        tick</span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">() {</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#66707B;--shiki-dark:#BDC4CC\">            /* read input, move player, check triggers */</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">        },</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#622CBC;--shiki-dark:#DBB7FF\">        draw</span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">() {</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#66707B;--shiki-dark:#BDC4CC\">            /* push sprite positions to video */</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">        },</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">    };</span></span>\n<span class=\"line\"><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">}</span><span style=\"--shiki-light:#702C00;--shiki-dark:#FFB757\">)</span><span style=\"--shiki-light:#0E1116;--shiki-dark:#F0F3F6\">;</span></span></code></pre>\n<p>That's it. No engine internals leaking through.</p>\n<hr />\n<h2 id=\"what-s-next\" data-toc-text=\"What's next\">What's next</h2>\n<p>The next things on the list are codegen (generating typed asset bindings from a manifest so the cartridge has compile-time safety on asset IDs), a CLI, and inspect tooling that shows ROM/VRAM/RAM usage against the hardware budget.</p>\n<p>The longer goal is three playable demos — each one using the full feature set of the engine:</p>\n<ul>\n<li>A <strong>top-down Zelda-like</strong>: rooms, combat, NPCs, inventory</li>\n<li>A <strong>side-scrolling Mario 3-like</strong>: gravity, platforms, enemies, power-ups</li>\n<li>An <strong>old-school match-3</strong>: grid logic, cascades, score, progression</li>\n</ul>\n<p>These three were chosen deliberately. They cover very different engine requirements — different collision models, different camera behaviour, different game loops — so together they'll prove whether the engine is actually general or just a cabin demo with ambitions. If all three are playable within the constraints, the constraints were right.</p>\n<p>I don't have a finish line beyond that. I'll write more as it develops.</p>\n",
            "date_published": "2026-04-01T00:00:00Z",
            "tags": ["cartridge","gamedev","learning","typescript"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/tools-yetric-net/",
            "url": "https://yetric.com/blog/posts/tools-yetric-net/",
            "title": "Building tools.yetric.net: 85+ Developer Tools With No Friction",
            "summary": "Why I built a collection of free developer tools, how the architecture works, and what I learned from keeping it simple.",
            "content_html": "<h2 id=\"the-itch\" data-toc-text=\"The Itch\">The Itch</h2>\n<p>Every developer has been there: you need to quickly decode a JWT, format some JSON, or generate a hash — and instead of just doing it, you end up navigating past cookie consent banners, signing up for an account, or waiting for ads to load before the tool even renders.</p>\n<p>It's a solved problem made annoying.</p>\n<p><a href=\"https://tools.yetric.net/\" target=\"_blank\" rel=\"noopener noreferrer\">tools.yetric.net</a> is my answer to that. Free, no accounts, no ads, no friction. Paste input, get output, copy and go.</p>\n<hr />\n<h2 id=\"what-it-is\" data-toc-text=\"What It Is\">What It Is</h2>\n<p>The site is a collection of over 85 web-based utilities organized into categories:</p>\n<ul>\n<li><strong>JSON</strong> — formatting, diffing, converting to TypeScript/Go/Zod schemas, generating SQL inserts, Prisma models, and more</li>\n<li><strong>Auth &amp; Security</strong> — JWT decoder, JWT builder, hash generator, bcrypt, API key generator, HMAC signer</li>\n<li><strong>Security</strong> — CSP builder, CORS policy builder, password strength analyzer, security headers checker</li>\n<li><strong>Dev Utilities</strong> — curl → code, cron parser, regex tester, .env validator, Dockerfile generator, Nginx config builder, OpenAPI → TypeScript, HTTP status reference, and many more</li>\n<li><strong>CSS &amp; Frontend</strong> — px/rem/em converter, CSS specificity calculator, Tailwind → CSS, z-index manager, gradient builder</li>\n<li><strong>SaaS &amp; Metrics</strong> — MRR/ARR calculator, churn impact simulator, CAC/LTV, pricing tier designer</li>\n<li><strong>Docs</strong> — changelog generator, README builder, conventional commit linter, semver bump calculator</li>\n</ul>\n<p>The philosophy is simple: every tool should be immediately usable with no setup, and every tool should do one thing clearly.</p>\n<hr />\n<h2 id=\"the-architecture\" data-toc-text=\"The Architecture\">The Architecture</h2>\n<p>The stack is straightforward and intentionally boring.</p>\n<p><strong>Frontend: Next.js + TypeScript + Mantine</strong></p>\n<p>Next.js 16 with the App Router handles routing and server-side metadata generation. <a href=\"https://mantine.dev/\" target=\"_blank\" rel=\"noopener noreferrer\">Mantine</a> provides the component layer — it handles forms, code highlighting, and dark mode without requiring me to rebuild UI primitives from scratch. The entire frontend is TypeScript with strict mode enabled.</p>\n<p>Each tool follows a consistent pattern:</p>\n<ol>\n<li>A page component that sets SEO metadata</li>\n<li>A tool component that wraps a shared <code>&lt;ToolPage&gt;</code> template with tool-specific config (title, description, input/output labels, syntax highlighting language)</li>\n<li>A typed API wrapper that posts to the backend and handles the <code>{ output, error }</code> response</li>\n</ol>\n<p>This means adding a new tool is low-overhead: write the backend logic, add a handler, add a typed API call, drop a <code>&lt;ToolPage&gt;</code> wrapper around it. The scaffolding is already there.</p>\n<p><strong>Backend: Go</strong></p>\n<p>The API is a Go service using the Chi router. Each tool gets its own handler and internal logic package. Go was the obvious choice here — it's fast, the standard library handles most of what's needed, and the tooling is straightforward.</p>\n<p>The API enforces rate limiting (120 requests/minute per IP), a 1 MB body size cap, and returns a consistent <code>{ output: string, error?: string }</code> shape from every endpoint. No surprises.</p>\n<p><strong>Deployment: Podman + Nginx</strong></p>\n<p>Both services run as containers behind an Nginx reverse proxy. We use <a href=\"https://podman.io/\" target=\"_blank\" rel=\"noopener noreferrer\">Podman</a> rather than Docker — it's fully open source, daemonless, and runs rootless by default, which aligns well with how we prefer to run things. GitHub Actions builds and pushes images to GHCR on every push to main, then pulls and restarts on the server via Podman Compose. Smoke tests run as part of the pipeline to catch obvious regressions.</p>\n<pre class=\"mermaid\">flowchart TD\n    subgraph CI[&quot;CI/CD (GitHub Actions)&quot;]\n        direction LR\n        Push[&quot;git push&quot;] --&gt; Build[&quot;Build images&quot;] --&gt; GHCR[&quot;GHCR&quot;]\n    end\n\n    subgraph Server[&quot;Production Server&quot;]\n        direction LR\n        Nginx[&quot;Nginx\\n(TLS + proxy)&quot;] --&gt; FE[&quot;Next.js\\nFrontend&quot;]\n        FE --&gt;|&quot;POST /api/v1/...&quot;| API[&quot;Go API&quot;]\n        API --&gt; Tools[&quot;Tool Logic\\n(Go packages)&quot;]\n    end\n\n    Browser([Browser]) --&gt; Nginx\n    GHCR --&gt;|&quot;Podman Compose\\npull &amp; restart&quot;| Server\n</pre>\n<hr />\n<h2 id=\"a-few-decisions-worth-noting\" data-toc-text=\"A Few Decisions Worth Noting\">A Few Decisions Worth Noting</h2>\n<p><strong>URL-based input sharing.</strong> Any tool input can be encoded into the URL as a base64 query parameter. The page decodes it and auto-submits on load. This means you can share a link and the recipient lands directly on the result. It's a small feature that turns these tools from local scratch pads into something you can actually hand to a colleague.</p>\n<p><strong>CMD+K search.</strong> With 85+ tools, navigation needs to scale. There's a spotlight-style search overlay (CMD+K or <code>/</code>) that searches across all tool names and descriptions. It's faster than scrolling a sidebar.</p>\n<p><strong>Favorites and recents.</strong> Tools you've used recently appear at the top of the sidebar. Tools you've starred are always accessible. Both are stored in localStorage — no accounts needed.</p>\n<p><strong>Dark mode with Nord.</strong> The color scheme is Nord throughout — the Aurora palette for category accents, Frost for UI chrome. It's opinionated, but it holds together well and looks good at night when you're decoding a JWT at 11pm.</p>\n<hr />\n<h2 id=\"what-i-learned\" data-toc-text=\"What I Learned\">What I Learned</h2>\n<p><strong>The boring architecture wins.</strong> Next.js + Go + Docker is not a novel combination. That's the point. Every piece of it has known tradeoffs, good documentation, and no surprises. When you're building a tool that needs to just work, boring infrastructure is a feature.</p>\n<p><strong>Consistency beats cleverness.</strong> The <code>&lt;ToolPage&gt;</code> pattern means every tool works the same way. Users don't need to re-learn the interface for each tool. It also means I can add new tools quickly without thinking too hard about UI structure.</p>\n<p><strong>The search overlay is more important than the navigation.</strong> Once you have 30+ tools, the sidebar becomes hard to scan. The spotlight search is what most people use after the first visit. Building it earlier would have been worth it.</p>\n<hr />\n<h2 id=\"what-s-next\" data-toc-text=\"What's Next\">What's Next</h2>\n<p>The tool count keeps growing. There are several more DevOps and database utilities in progress. I'm also looking at adding a way to chain tools together — pipe the output of one into the input of another — which would unlock some useful workflows.</p>\n<p>There's also something that keeps coming up: a CLI. The backend is already a clean API — every tool is a single POST with a plain text response. Wrapping that in a terminal client would let you pipe directly from your shell: <code>cat schema.json | yetric json:to-typescript</code>. No browser required. That one is on the list.</p>\n<p>If you use it and find something missing or broken, the site links to GitHub for issues.</p>\n<p><a href=\"https://tools.yetric.net/\" target=\"_blank\" rel=\"noopener noreferrer\">tools.yetric.net</a> — no signup required.</p>\n",
            "date_published": "2026-03-27T00:00:00Z",
            "tags": ["api","developer-tools","go","mantine","nextjs","open-source","podman","productivity","side-project","tools","typescript"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/fotbollsfeber-spring-2026/",
            "url": "https://yetric.com/blog/posts/fotbollsfeber-spring-2026/",
            "title": "Fotbollsfeber: More Than a Football Stats Site",
            "summary": "What we’ve built on Fotbollsfeber.se: a probability engine for Stryktipset and a matchcenter for Swedish and European football.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>Over the past few months, <a href=\"https://fotbollsfeber.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Fotbollsfeber.se</a> has grown from a fairly standard Swedish football stats site into something more interesting: a data platform that tracks leagues, models match outcomes, and helps people think more clearly about football predictions. Here's what we've been building.</p>\n<hr />\n<h2 id=\"it-started-as-a-stats-site\" data-toc-text=\"It Started as a Stats Site\">It Started as a Stats Site</h2>\n<p>Fotbollsfeber has been tracking Swedish football for years — Allsvenskan, Superettan, Damallsvenskan — logging matches, goals, and table standings. Useful, but not particularly exciting.</p>\n<p>The interesting part is what happens when you start treating that historical data as raw material rather than an endpoint.</p>\n<hr />\n<h2 id=\"a-probability-engine-for-stryktipset\" data-toc-text=\"A Probability Engine for Stryktipset\">A Probability Engine for Stryktipset</h2>\n<p>The biggest thing we've shipped this spring is a prediction model for Stryktipset — the Swedish football coupon that's been around since 1934.</p>\n<p>Every week, 13 matches. Three outcomes per match: home win, draw, away win. You pick. If you get all 13 right, you win. Simple on the surface. Genuinely difficult in practice.</p>\n<p>We built a probability engine that models each fixture using a chain of approaches — ELO ratings, goal scoring rates, historical head-to-head form, opening odds from bookmakers, and crowd consensus. No single model works perfectly, so the system prioritizes by reliability and falls back gracefully when data is thin.</p>\n<p>The output isn't just &quot;pick 1, X, or 2.&quot; It's a full probability breakdown per fixture, expected value calculations, and — when we run backtests against historical rounds — a measurable improvement over naive guessing.</p>\n<p>The system runs weekly, aligned to each new Stryktipset round.</p>\n<p>What makes this interesting isn't just the predictions. It's that the whole thing is grounded in real historical data from the site itself, updated continuously as new matches are played.</p>\n<hr />\n<h2 id=\"one-site-every-league\" data-toc-text=\"One Site, Every League\">One Site, Every League</h2>\n<p>The other major project was less glamorous but arguably more important: we rebuilt the routing and data layer so every league — Swedish, European, or otherwise — works the same way.</p>\n<p>Before this, each league had its own page structure, its own quirks, its own workarounds. Adding a new league meant duplicating code and hunting down which assumptions had been baked in from three years ago.</p>\n<p>Now there's a single architecture. You can browse Allsvenskan, Premier League, La Liga, or Damallsvenskan through the same consistent interface. Adding a new league is a configuration change, not a rewrite.</p>\n<p>This matters less for users day-to-day and more for everything that comes next: you can now run the same analysis, the same prediction models, the same comparison tools across leagues without reinventing the wheel each time.</p>\n<p>One example that's already live: season simulation. Pick any league, hit a button, and the site runs 10,000 simulated versions of the rest of the season — based on current standings, team form, and remaining fixtures — and returns a probability distribution of final positions. Who's realistically in the title race? Who's actually in a relegation battle versus just mathematically still in one? The simulation gives you a data-driven answer rather than a gut feeling.</p>\n<p>Because every league now shares the same data model, this works for Allsvenskan and Bundesliga equally. That's exactly what the unified architecture was for.</p>\n<hr />\n<h2 id=\"a-matchcenter-worth-using\" data-toc-text=\"A Matchcenter Worth Using\">A Matchcenter Worth Using</h2>\n<p>We also shipped a proper matchcenter — a live feed of upcoming and recent matches across all tracked leagues, with team logos, live scores, and quick links to match details.</p>\n<p>It sounds basic. Most football sites have something like this. The difference is that ours pulls from a single unified data model that covers Swedish football with real depth (squad data, historical statistics, top scorers) and European leagues with solid coverage (Premier League, La Liga, Bundesliga, Serie A, Ligue 1, and more).</p>\n<p>The home page now gives you a cross-league view of the football week, with league logos and context, rather than forcing you to navigate to each league separately.</p>\n<hr />\n<h2 id=\"why-this-is-interesting\" data-toc-text=\"Why This Is Interesting\">Why This Is Interesting</h2>\n<p>The underlying idea is that football generates enormous amounts of structured data — scores, lineups, goalscorers, betting odds, newspaper predictions — that mostly sits unused or gets locked behind expensive data providers.</p>\n<p>A site with enough historical depth can do something different: treat that data as the input to actual analysis. Not &quot;Allsvenskan table&quot; as a static fact, but &quot;given everything we know about these two teams, what does the data actually suggest about this match?&quot;</p>\n<p>The Stryktipset model is the clearest example of this so far. But the same logic applies to team form analysis, squad depth comparisons, and season projections.</p>\n<hr />\n<h2 id=\"what-s-next\" data-toc-text=\"What's Next\">What's Next</h2>\n<p>We're continuing to build out the prediction side. The probability model will get better as more data accumulates, and we're exploring how to present the analysis in ways that are genuinely useful rather than just numerically impressive.</p>\n<p>On the data coverage side, more leagues, more historical depth, and better real-time sync.</p>\n<p>If you follow Swedish football — or just find the intersection of data and sport interesting — <a href=\"https://fotbollsfeber.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Fotbollsfeber.se</a> is worth a look.</p>\n",
            "date_published": "2026-03-08T00:00:00Z",
            "tags": ["data","football","fotbollsfeber","product"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/maklarinfo-march-2026-product-update/",
            "url": "https://yetric.com/blog/posts/maklarinfo-march-2026-product-update/",
            "title": "What's New in Maklarinfo: March 2026 Update",
            "summary": "Discover the latest improvements to Maklarinfo — better search filters, broker insights, saved search alerts, and account features.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>We've shipped five meaningful updates to Maklarinfo over the past three months. You can now create an account, search with more powerful filters, get instant alerts when new listings match your saved searches, toggle alerts directly from your dashboard, and explore detailed broker performance data with historical trends.</p>\n<hr />\n<h2 id=\"create-your-account\" data-toc-text=\"Create Your Account\">Create Your Account</h2>\n<p>One of the most requested features is finally here: <strong>user accounts</strong>. You can now <a href=\"https://maklarinfo.se/\" target=\"_blank\" rel=\"noopener noreferrer\">sign up for Maklarinfo</a> and keep your searches, alerts, and preferences synchronized across devices and sessions.</p>\n<p>With an account, your saved searches travel with you—whether you're on your phone, laptop, or tablet. No more losing your criteria when you close the browser.</p>\n<hr />\n<h2 id=\"smarter-search-filters\" data-toc-text=\"Smarter Search Filters\">Smarter Search Filters</h2>\n<p>Finding the right property means being able to describe exactly what you want. <a href=\"https://maklarinfo.se/stockholm/hitta\" target=\"_blank\" rel=\"noopener noreferrer\">Maklarinfo's improved search</a> now includes expanded filtering options:</p>\n<ul>\n<li><strong>Free-text search</strong>: Search by street name, neighborhood, or other details without preset categories</li>\n<li><strong>Max rent filter</strong>: For apartment renters, set your maximum rent ceiling directly</li>\n<li><strong>Improved sorting</strong>: Sort results by relevance, price, date, or size—with clearer options to match how you naturally think about properties</li>\n</ul>\n<p>These might seem like small changes, but they let you be more precise about what you're looking for. No more sifting through listings that don't fit your budget or neighborhood preferences.</p>\n<hr />\n<h2 id=\"saved-search-alerts\" data-toc-text=\"Saved Search Alerts\">Saved Search Alerts</h2>\n<p>You can now get automatic alerts when new listings match your saved searches.</p>\n<p><a href=\"https://maklarinfo.se/stockholm/hitta\" target=\"_blank\" rel=\"noopener noreferrer\">Create a saved search</a> for your ideal criteria—maybe a 2-room apartment under 3.5M in Södermalm—and we'll send you an email the moment a new listing matches. No more checking Maklarinfo manually multiple times a day.</p>\n<p>You're in control of when you get alerts. From your dashboard (Mina Sidor), you can toggle alerts on or off for each saved search individually. Want alerts for one search but not another? Just flip the switch.</p>\n<hr />\n<h2 id=\"broker-performance-data\" data-toc-text=\"Broker Performance Data\">Broker Performance Data</h2>\n<p>We've expanded the <strong><a href=\"https://maklarinfo.se/maklare\" target=\"_blank\" rel=\"noopener noreferrer\">National Broker Page</a></strong> with deeper insights into how brokers are performing across Sweden.</p>\n<p>New features include:</p>\n<ul>\n<li><strong>Trend charts</strong>: See how broker activity, price trends, and sales volumes have changed over time</li>\n<li><strong>Top cities data</strong>: Understand which markets each broker is most active in</li>\n<li><strong>Historical comparison</strong>: Look back over months to understand patterns and cycles</li>\n</ul>\n<p>Whether you're curious about a specific broker or researching the broader market, you now have the data to make informed decisions.</p>\n<hr />\n<h2 id=\"the-experience-so-far\" data-toc-text=\"The Experience So Far\">The Experience So Far</h2>\n<p>These updates are built on feedback from our users. Account creation, better filters, and email alerts are features people have asked for since day one. Broker data makes Maklarinfo useful not just for finding your next home, but for understanding the Swedish property market itself.</p>\n<p>Ready to get started? <a href=\"https://maklarinfo.se/\" target=\"_blank\" rel=\"noopener noreferrer\">Head over to Maklarinfo</a> and try it out for yourself.</p>\n<p>We're committed to making Maklarinfo the tool you reach for when you're serious about property search—whether you're browsing casually or ready to make a move.</p>\n",
            "date_published": "2026-03-06T00:00:00Z",
            "tags": ["alerts","maklarinfo","product","search"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/focused-execution-8-weeks/",
            "url": "https://yetric.com/blog/posts/focused-execution-8-weeks/",
            "title": "Focused Execution: An 8-Week Experiment in Disciplined Product Building",
            "summary": "How we're committing to 8 weeks of focused execution without evaluation, pivots, or distractions.",
            "content_html": "<h2 id=\"the-problem-with-constant-evaluation\" data-toc-text=\"The Problem with Constant Evaluation\">The Problem with Constant Evaluation</h2>\n<p>Most product teams evaluate too often. You ship something. A week passes. No hockey stick growth. Someone says &quot;maybe we should pivot.&quot; A new idea sounds exciting. Focus shifts. Nothing gets finished.</p>\n<p>Eight weeks in, you have a dozen half-baked experiments and no clarity on whether anything actually works.</p>\n<p>We decided to run an experiment in disciplined execution: <strong>8 weeks of consistent building without evaluation, pivoting, or starting new projects.</strong></p>\n<hr />\n<h2 id=\"the-rules\" data-toc-text=\"The Rules\">The Rules</h2>\n<p>From March 1st through April 26th, 2026, the following are forbidden:</p>\n<ul>\n<li>No new projects</li>\n<li>No tech stack changes</li>\n<li>No redesigns for aesthetic reasons</li>\n<li>No pivoting based on early signals</li>\n<li>No existential analysis of product viability</li>\n</ul>\n<p>We're treating this as a controlled execution window. Not a lifetime decision. Not a reputation gamble. Just 56 days.</p>\n<hr />\n<h2 id=\"the-weekly-rhythm\" data-toc-text=\"The Weekly Rhythm\">The Weekly Rhythm</h2>\n<p>Each week follows a structured pattern:</p>\n<ul>\n<li><strong>2 × Build Blocks</strong> — Infrastructure, backend systems, data pipelines</li>\n<li><strong>1 × Product Block</strong> — UI improvements, usability fixes, packaging refinements</li>\n<li><strong>1 × Visibility Block</strong> — Publish one insight or analysis derived from data</li>\n</ul>\n<p>We publish something every single week. Not marketing fluff. Actual data insights from what we're building.</p>\n<hr />\n<h2 id=\"what-we-re-actually-measuring\" data-toc-text=\"What We're Actually Measuring\">What We're Actually Measuring</h2>\n<p>One metric matters: <strong>actual customer adoption and payment.</strong></p>\n<p>No vanity metrics. No follower counts. No &quot;this feels promising&quot; vibes.</p>\n<p>Either real customers are using the product and paying for it, or they're not. That's the signal we care about.</p>\n<hr />\n<h2 id=\"why-this-approach-works\" data-toc-text=\"Why This Approach Works\">Why This Approach Works</h2>\n<p><strong>Consistency compounds.</strong> Eight weeks of focused effort on the same problem creates momentum that scattered work never achieves.</p>\n<p><strong>You actually learn.</strong> When you stop pivoting, you finish things. Finished products reveal their real strengths and weaknesses. Half-baked experiments reveal nothing.</p>\n<p><strong>Urgency focuses thinking.</strong> A 56-day window forces prioritization. What's truly important? What's just interesting? What can wait?</p>\n<hr />\n<h2 id=\"evaluation-day\" data-toc-text=\"Evaluation Day\">Evaluation Day</h2>\n<p>On April 26th, and not before, we apply cold analysis:</p>\n<ol>\n<li>Is there inbound interest?</li>\n<li>Are there trial users?</li>\n<li>Are there paying customers?</li>\n<li>Is there a clear signal of usefulness?</li>\n</ol>\n<p>Then we decide: Kill it, adjust the approach, or double down.</p>\n<p>No emotional framing. Just data.</p>\n<hr />\n<h2 id=\"the-anti-self-sabotage-clause\" data-toc-text=\"The Anti-Self-Sabotage Clause\">The Anti-Self-Sabotage Clause</h2>\n<p>When doubt creeps in—&quot;This is inefficient,&quot; &quot;This is boring,&quot; &quot;There's something more exciting&quot;—the answer is simple:</p>\n<p><strong>Evaluation is on April 26th.</strong></p>\n<p>Not today. Not next week. April 26th.</p>\n<hr />\n<h2 id=\"why-you-should-consider-this\" data-toc-text=\"Why You Should Consider This\">Why You Should Consider This</h2>\n<p>If your product team is scattered across multiple priorities, constantly re-evaluating based on weak signals, and nothing feels like it's moving forward, an 8-week execution contract might be exactly what you need.</p>\n<p>The key insight: <strong>data beats vibes, but only if you give yourself time to gather it.</strong></p>\n<p>You can't evaluate whether something works after two weeks. You can't validate a business model in a month. But you can absolutely tell the difference between &quot;this is broken&quot; and &quot;this actually has potential&quot; after two months of focused execution.</p>\n<hr />\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li><strong>Focused execution beats scattered effort.</strong> Always.</li>\n<li><strong>Evaluation is a specific moment, not a constant state.</strong> Defer judgment until you have enough data.</li>\n<li><strong>One metric is often enough.</strong> Vanity metrics beat a dashboard full of noise.</li>\n<li><strong>Urgency clarifies priorities.</strong> A deadline forces hard choices.</li>\n<li><strong>This is an experiment, not an identity.</strong> Eight weeks is long enough to learn something real, short enough to fail safely.</li>\n</ol>\n<hr />\n<h2 id=\"the-bottom-line\" data-toc-text=\"The Bottom Line\">The Bottom Line</h2>\n<p>Execution mode doesn't mean ignoring feedback or being inflexible. It means: commit to a direction, build consistently, gather real data, and defer major decisions until you have enough information to make them well.</p>\n<p>Try it. Eight weeks. One metric. No pivots. See what happens.</p>\n",
            "date_published": "2026-03-03T00:00:00Z",
            "tags": ["execution","product","strategy"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/maklarinfo-devops-improvements-2026/",
            "url": "https://yetric.com/blog/posts/maklarinfo-devops-improvements-2026/",
            "title": "Behind the Scenes: DevOps Improvements at Maklarinfo",
            "summary": "How we're making our CI/CD pipeline faster, our deployments more reliable, and our infrastructure more observable without compromising security.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>We've made significant investments in our CI/CD pipeline, logging infrastructure, and deployment reliability over the past three months. Pull request checks now run 50% faster through parallelization. We've added structured logging across the entire stack. And we've hardened our build process to be more resilient to edge cases.</p>\n<hr />\n<h2 id=\"faster-feedback-loops\" data-toc-text=\"Faster Feedback Loops\">Faster Feedback Loops</h2>\n<p>One of the biggest wins for developer experience is speed. When you push code, you want to know if it passes quality gates in seconds, not minutes.</p>\n<h3 id=\"parallel-ci-cd-jobs\" data-toc-text=\"Parallel CI/CD Jobs\">Parallel CI/CD Jobs</h3>\n<p>We restructured our pull request quality checks to run in parallel instead of sequentially. What used to take 4+ minutes now completes in about 2 minutes for most changes.</p>\n<p>How? By running linting, type checking, tests, and formatting checks concurrently rather than one after another. They don't depend on each other, so there's no reason to serialize them.</p>\n<p>We also implemented smart caching of dependencies and build artifacts, so repeat checks skip expensive install and build steps when nothing has changed.</p>\n<h3 id=\"change-detection\" data-toc-text=\"Change Detection\">Change Detection</h3>\n<p>Not all changes require the same level of scrutiny. If a PR only modifies documentation or markdown files, we skip the full build step entirely. This saves time on documentation-only PRs without sacrificing quality on code changes.</p>\n<hr />\n<h2 id=\"observable-systems\" data-toc-text=\"Observable Systems\">Observable Systems</h2>\n<p>You can't manage what you can't measure. We've invested in structured logging across the entire application stack—from API routes to background workers to third-party integrations.</p>\n<h3 id=\"structured-logging\" data-toc-text=\"Structured Logging\">Structured Logging</h3>\n<p>Instead of freeform log messages, we now log events with consistent structure: context, severity levels, timestamps, and relevant metadata. This makes it possible to:</p>\n<ul>\n<li>Search and filter logs efficiently in production</li>\n<li>Correlate events across services</li>\n<li>Build alerts on specific patterns</li>\n<li>Debug issues faster with more context</li>\n</ul>\n<p>Structured logging is invisible to end users, but it's the foundation for reliability. When something goes wrong at 3 AM, better logs mean faster resolution.</p>\n<h3 id=\"production-observability\" data-toc-text=\"Production Observability\">Production Observability</h3>\n<p>We've instrumented critical paths in the application to emit detailed events—from user actions to third-party API calls. This lets us:</p>\n<ul>\n<li>Detect anomalies before users notice them</li>\n<li>Understand where time is being spent in the system</li>\n<li>Validate that background jobs are running as expected</li>\n<li>Track data quality in real-time</li>\n</ul>\n<hr />\n<h2 id=\"resilient-builds\" data-toc-text=\"Resilient Builds\">Resilient Builds</h2>\n<p>Production systems need to handle edge cases gracefully. We've hardened our build and deployment processes to be more resilient.</p>\n<h3 id=\"defensive-configuration\" data-toc-text=\"Defensive Configuration\">Defensive Configuration</h3>\n<p>The build now handles missing configuration gracefully. If an environment variable isn't set, the build doesn't fail—it either uses a sensible default or continues with a warning. This prevents cascading failures where missing one config value brings down the entire pipeline.</p>\n<h3 id=\"safer-dependency-management\" data-toc-text=\"Safer Dependency Management\">Safer Dependency Management</h3>\n<p>We've added versioning constraints and fallback logic to ensure that third-party dependencies don't introduce breaking changes silently. Dependency updates are tested more thoroughly before they reach production.</p>\n<h3 id=\"test-stability\" data-toc-text=\"Test Stability\">Test Stability</h3>\n<p>We've fixed flaky tests and improved test infrastructure to reduce false negatives. When a test fails, it means something is actually broken—not that the test framework had a hiccup.</p>\n<hr />\n<h2 id=\"security-first-infrastructure\" data-toc-text=\"Security-First Infrastructure\">Security-First Infrastructure</h2>\n<p>DevOps isn't just about speed—it's about doing things securely at scale.</p>\n<h3 id=\"owasp-compliance\" data-toc-text=\"OWASP Compliance\">OWASP Compliance</h3>\n<p>We conducted a comprehensive security audit and addressed all OWASP Top 10 findings. This includes improvements to how we handle authentication, rate limiting, input validation, and more.</p>\n<h3 id=\"secret-management\" data-toc-text=\"Secret Management\">Secret Management</h3>\n<p>We've hardened how secrets (API keys, database credentials) are stored and accessed. Secrets are never logged, never stored in version control, and are rotated regularly.</p>\n<h3 id=\"rate-limiting-ddos-protection\" data-toc-text=\"Rate Limiting &amp; DDoS Protection\">Rate Limiting &amp; DDoS Protection</h3>\n<p>We've implemented rate limiting at multiple layers to protect against abuse while ensuring legitimate traffic always gets through.</p>\n<hr />\n<h2 id=\"looking-forward\" data-toc-text=\"Looking Forward\">Looking Forward</h2>\n<p>These improvements compound over time. Faster CI means developers get feedback sooner and ship features quicker. Better observability means we catch issues before users do. Harder infrastructure means we can scale confidently.</p>\n<p>The next phase of work focuses on deployment automation, canary releases, and more sophisticated monitoring. The goal is to make deploying code as boring and reliable as possible—just push to main, everything works, no drama.</p>\n<hr />\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li><strong>Speed matters</strong>: 50% faster PR checks keeps developers in flow and lets us iterate faster.</li>\n<li><strong>You manage what you measure</strong>: Structured logging is a force multiplier for reliability.</li>\n<li><strong>Resilience requires discipline</strong>: Defensive coding, solid testing, and gradual rollouts prevent most production issues.</li>\n<li><strong>Security is a feature</strong>: Compliance and hardening aren't obstacles—they're table stakes for trustworthy systems.</li>\n<li><strong>Infrastructure compounds</strong>: Each small improvement makes the next improvement easier to build.</li>\n</ol>\n",
            "date_published": "2026-03-01T00:00:00Z",
            "tags": ["ci-cd","devops","engineering","infrastructure"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/new-site-new-chapter/",
            "url": "https://yetric.com/blog/posts/new-site-new-chapter/",
            "title": "New Site, New Chapter",
            "summary": "yetric.com has a new home. A fresh site, a renewed commitment to writing, and a collection of older posts worth revisiting.",
            "content_html": "<p>The new yetric.com is up.</p>\n<p>It's been a while since the old site was actively maintained, and I decided it was time to start fresh — cleaner design, better structure, and a real commitment to writing more regularly.</p>\n<p>Yetric is my software development and consulting practice based in Sweden. I work with teams on building products, modernizing systems, and making better decisions around architecture and data. If any of that sounds relevant to what you're working on, the <a href=\"https://yetric.com/about/\">about page</a> has more.</p>\n<h2 id=\"what-s-coming\" data-toc-text=\"What's coming\">What's coming</h2>\n<p>This blog is where I'll write about things I run into in real work:</p>\n<ul>\n<li>Architecture decisions and how to make them without pretending they're permanent.</li>\n<li>Moving away from legacy systems without burning everything down.</li>\n<li>Building short feedback loops so mistakes stay small.</li>\n<li>The intersection of data, product, and engineering — and how to align them.</li>\n</ul>\n<p>More soon, and more regularly than before.</p>\n<h2 id=\"worth-reading-from-the-archive\" data-toc-text=\"Worth reading from the archive\">Worth reading from the archive</h2>\n<p>I've brought over a handful of older posts from the previous site that I think still hold up:</p>\n<ul>\n<li><a href=\"https://yetric.com/blog/posts/technical-debt/\">Unraveling Technical Debt: The Silent Software Killer</a> — on the compounding cost of ignoring shortcuts in your codebase.</li>\n<li><a href=\"https://yetric.com/blog/posts/analytics-gdpr-compliance/\">Navigating Analytics and GDPR Compliance</a> — key considerations for running analytics without running afoul of data protection law.</li>\n<li><a href=\"https://yetric.com/blog/posts/alternatives-to-react/\">Modern Alternatives to React</a> — a look at Svelte, Preact, Solid, and Web Components.</li>\n<li><a href=\"https://yetric.com/blog/posts/whats-in-a-name/\">What's in a Name?</a> — the story behind Yetric, for anyone curious about where the name came from.</li>\n</ul>\n",
            "date_published": "2026-02-20T00:00:00Z",
            "tags": ["company","site-updates","writing"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/alternatives-to-react/",
            "url": "https://yetric.com/blog/posts/alternatives-to-react/",
            "title": "Modern Alternatives to React",
            "summary": "React dominates, but Svelte, Preact, Solid, and Web Components offer compelling alternatives depending on your project's priorities.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>React has been a dominant force in web development, but several modern alternatives offer unique features and benefits. Svelte, Preact, Solid, and Web Components are noteworthy alternatives to consider. Whether you prioritize performance, bundle size, simplicity, or interoperability, these alternatives provide fresh perspectives on building user interfaces.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>React has been the default for a long time. But several alternatives have matured into real options worth understanding on their own terms.</p>\n<h2 id=\"1-svelte\" data-toc-text=\"1. Svelte\">1. Svelte</h2>\n<p>Svelte is a compile-time framework that compiles your components into highly efficient JavaScript code, resulting in smaller bundle sizes and faster performance. With its intuitive syntax and automatic reactivity, Svelte offers a refreshing and efficient way to build web applications.</p>\n<p><strong>Pros:</strong></p>\n<ul>\n<li>Automatic reactivity for efficient updates</li>\n<li>Smaller bundle sizes and faster performance</li>\n<li>Intuitive syntax and ease of use</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li>Relatively smaller ecosystem compared to React</li>\n<li>Limited tooling and community support compared to React</li>\n</ul>\n<h2 id=\"2-preact\" data-toc-text=\"2. Preact\">2. Preact</h2>\n<p>Preact is a lightweight alternative to React, prioritizing performance and providing a similar API. Its small size makes it an excellent choice for applications where performance and bundle size are critical.</p>\n<p><strong>Pros:</strong></p>\n<ul>\n<li>Similar API to React, making it easy to switch</li>\n<li>Lightweight with a small bundle size</li>\n<li>Compatible with most React ecosystem tools</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li>May not provide as many advanced features as React</li>\n<li>Smaller community and ecosystem compared to React</li>\n</ul>\n<h2 id=\"3-solid\" data-toc-text=\"3. Solid\">3. Solid</h2>\n<p>Solid is a declarative JavaScript library that efficiently updates the DOM using fine-grained reactivity. Its simplicity and performance make it a popular choice for building user interfaces.</p>\n<p><strong>Pros:</strong></p>\n<ul>\n<li>Fine-grained reactivity for efficient updates</li>\n<li>Simplicity and ease of use</li>\n<li>Excellent performance and small bundle size</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li>Smaller community and ecosystem compared to React</li>\n<li>Limited availability of third-party libraries and components</li>\n</ul>\n<h2 id=\"4-web-components\" data-toc-text=\"4. Web Components\">4. Web Components</h2>\n<p>Web Components is a set of web platform APIs that allow you to create custom, reusable UI components. They offer native browser support and can be used alongside any JavaScript framework, including React.</p>\n<p><strong>Pros:</strong></p>\n<ul>\n<li>Native browser support</li>\n<li>Interoperability with any JavaScript framework, including React</li>\n<li>Reusability and encapsulation of UI components</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li>Steeper learning curve compared to other alternatives</li>\n<li>Requires a good understanding of web standards and APIs</li>\n</ul>\n<p>React is still the default for good reason, but Svelte, Preact, Solid, and Web Components are all capable choices depending on what matters most for your project. Performance, bundle size, simplicity, interoperability: each makes a different trade-off worth understanding before you reach for React out of habit.</p>\n",
            "date_published": "2025-05-08T00:00:00Z",
            "tags": ["frameworks","frontend","javascript","react"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/analytics-gdpr-compliance/",
            "url": "https://yetric.com/blog/posts/analytics-gdpr-compliance/",
            "title": "Navigating Analytics and GDPR Compliance: Key Considerations",
            "summary": "Key considerations for running web analytics while staying compliant with GDPR — lawful basis, data minimization, anonymization, and user rights.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>Analytics and GDPR compliance require understanding lawful data processing, purpose limitation, anonymization, data minimization, user rights transparency, data security, and appropriate cross-border data transfer mechanisms.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>Analytics and GDPR aren't naturally in tension, but they require deliberate alignment. The GDPR sets clear rules for collecting and processing personal data, and those rules apply to analytics just as much as any other data activity.</p>\n<h2 id=\"understanding-the-gdpr-and-its-impact-on-analytics\" data-toc-text=\"Understanding the GDPR and Its Impact on Analytics\">Understanding the GDPR and Its Impact on Analytics</h2>\n<p>The GDPR is a comprehensive data protection regulation designed to safeguard personal data and enhance individuals' privacy rights within the European Union (EU) and the European Economic Area (EEA). While the GDPR primarily focuses on personal data handling, it also applies to analytics practices that involve processing personal data.</p>\n<h3 id=\"key-considerations-for-analytics-and-gdpr-compliance\" data-toc-text=\"Key Considerations for Analytics and GDPR Compliance\">Key Considerations for Analytics and GDPR Compliance</h3>\n<ol>\n<li>\n<p><strong>Lawful Basis for Data Processing</strong>: Ensure you have a lawful basis, as defined by the GDPR, for processing personal data in your analytics activities. This can include obtaining user consent, fulfilling a contractual obligation, or legitimate interests pursued by your organization.</p>\n</li>\n<li>\n<p><strong>Purpose Limitation</strong>: Clearly define the purpose of your analytics activities and collect only the data necessary to achieve those objectives. Avoid collecting excessive or irrelevant personal data.</p>\n</li>\n<li>\n<p><strong>Anonymization and Pseudonymization</strong>: Anonymize or pseudonymize personal data before using it for analytics whenever possible. By doing so, you minimize the risk of directly or indirectly identifying individuals.</p>\n</li>\n<li>\n<p><strong>Data Minimization</strong>: Apply the principle of data minimization by collecting and retaining only the minimum amount of personal data required for your analytics purposes. Regularly review and delete any unnecessary data.</p>\n</li>\n<li>\n<p><strong>User Rights and Transparency</strong>: Inform users about your analytics practices, including the types of data collected, how it's used, and their rights under the GDPR. Provide a clear and easily accessible privacy policy that explains your data processing activities.</p>\n</li>\n<li>\n<p><strong>Data Security Measures</strong>: Implement appropriate technical and organizational measures to protect personal data used in analytics against unauthorized access, loss, or alteration. Regularly review and update your security practices to address emerging threats.</p>\n</li>\n<li>\n<p><strong>Data Processor Agreements</strong>: If you use third-party analytics providers, ensure you have appropriate data processing agreements (DPAs) in place that outline their responsibilities and compliance with GDPR requirements.</p>\n</li>\n<li>\n<p><strong>Cross-Border Data Transfers</strong>: If you transfer personal data outside the EU/EEA for analytics purposes, ensure you have lawful mechanisms in place to legitimize these transfers, such as standard contractual clauses or binding corporate rules.</p>\n</li>\n</ol>\n<h3 id=\"balancing-analytics-and-data-privacy\" data-toc-text=\"Balancing Analytics and Data Privacy\">Balancing Analytics and Data Privacy</h3>\n<p>Achieving GDPR compliance doesn't mean sacrificing the benefits of analytics. By implementing privacy-by-design principles and adopting privacy-enhancing technologies, you can strike a balance between data privacy and analytics-driven insights. Consider the following approaches:</p>\n<ul>\n<li>\n<p><strong>Aggregated and Anonymous Data</strong>: Use aggregated and anonymized data for broader analytics purposes to mitigate privacy risks while still gaining valuable insights.</p>\n</li>\n<li>\n<p><strong>User-centric Analytics</strong>: Adopt user-centric analytics approaches that prioritize privacy and individual rights, such as pseudonymous tracking, where identifiers are replaced with pseudonyms.</p>\n</li>\n<li>\n<p><strong>Data Protection Impact Assessments (DPIAs)</strong>: Conduct DPIAs to assess and mitigate the risks associated with your analytics practices, especially if you process sensitive personal data or engage in large-scale analytics initiatives.</p>\n</li>\n</ul>\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li>Understand the GDPR's impact on analytics and ensure a lawful basis for data processing.</li>\n<li>Clearly define the purpose of analytics activities and collect only necessary data.</li>\n<li>Anonymize or pseudonymize personal data whenever possible to minimize privacy risks.</li>\n<li>Follow the principles of data minimization and regularly review and delete unnecessary data.</li>\n<li>Inform users about analytics practices, their rights, and provide a transparent privacy policy.</li>\n<li>Implement appropriate data security measures to protect personal data used in analytics.</li>\n<li>Establish data processing agreements (DPAs) with third-party analytics providers.</li>\n<li>Legitimize cross-border data transfers by utilizing lawful mechanisms.</li>\n</ol>\n<h2 id=\"tools-worth-knowing\" data-toc-text=\"Tools Worth Knowing\">Tools Worth Knowing</h2>\n<ul>\n<li><strong>Matomo</strong> (formerly Piwik): An open-source web analytics platform that gives you full control over your data with customizable privacy settings aligned to GDPR.</li>\n<li><strong>Plausible</strong>: A lightweight, privacy-friendly analytics tool that doesn't use cookies or collect personal data.</li>\n<li><strong>Osano Cookie Consent Manager</strong>: Helps obtain and manage user consents for cookies and other tracking technologies.</li>\n<li><strong>GitGuardian</strong>: Scans code repositories for accidental exposure of sensitive data, including personal data.</li>\n</ul>\n<p>These are starting points. Assess each tool against your own data flows before committing. This is general guidance, not legal advice — consult a data protection professional for specifics.</p>\n",
            "date_published": "2025-01-21T00:00:00Z",
            "tags": ["analytics","data-privacy","gdpr"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/technical-debt/",
            "url": "https://yetric.com/blog/posts/technical-debt/",
            "title": "Unraveling Technical Debt: The Silent Software Killer",
            "summary": "Technical debt is the future cost of revisiting shortcuts in code. Ignoring it leads to slower teams, higher costs, and unsatisfied customers.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>Technical debt is the future cost of revisiting and refining code due to initial trade-offs between speed and quality. Ignoring technical debt can lead to decreased developer productivity, increased costs, and unsatisfied customers. It is crucial to identify high-risk areas, visualize your technical debt, and address it proactively to avoid long-term consequences.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>In the rapid, iterative world of software development, the goal is often to get a product to market as quickly as possible. However, as software development teams rush to implement new features or meet deadlines, they often have to cut corners. The result of these shortcuts is a concept known in the software industry as 'Technical Debt'.</p>\n<p>Technical debt refers to the future cost of revisiting and refining code due to initial trade-offs between speed and quality. Like financial debt, if not managed well, it accrues interest over time - the longer it goes unaddressed, the more costly and time-consuming it becomes to fix. Left unchecked, it leads to slower release cycles, buggy software, unhappy developers, and ultimately, unhappy customers.</p>\n<h2 id=\"identifying-high-risk-areas\" data-toc-text=\"Identifying High-Risk Areas\">Identifying High-Risk Areas</h2>\n<p>The first step in managing technical debt is to identify high-risk areas within the codebase. These areas are usually files or code blocks with high complexity, high coupling, or high rates of change. This requires comprehensive code analysis and an understanding of the code's architecture and dependencies.</p>\n<h2 id=\"visualizing-your-technical-debt\" data-toc-text=\"Visualizing Your Technical Debt\">Visualizing Your Technical Debt</h2>\n<p>Visualizing your technical debt helps prioritize refactoring. That might mean identifying the modules with the highest complexity, the highest coupling, or the parts of the code that change most often.</p>\n<h2 id=\"the-cost-of-ignoring-technical-debt\" data-toc-text=\"The Cost of Ignoring Technical Debt\">The Cost of Ignoring Technical Debt</h2>\n<p>A study by the software analysis and measurement company CAST found that on average, a single dollar of technical debt decreases developer output by $3.61. This means that a significant amount of technical debt can substantially slow down a development team, reducing their productivity and increasing the cost of software projects.</p>\n<p>To put this into perspective: suppose you have a team of 20 engineers, each earning an average of $50 per hour. If each engineer loses just one hour per day dealing with issues related to technical debt - a conservative estimate - that's $1,000 per day in lost productivity, or $260,000 per year. And that doesn't account for the indirect costs: decreased morale, higher bug rates, slower delivery of new features.</p>\n<h2 id=\"embracing-a-proactive-mindset\" data-toc-text=\"Embracing a Proactive Mindset\">Embracing a Proactive Mindset</h2>\n<p>Addressing technical debt requires a proactive mindset from the entire team. This means taking the time to write clean, maintainable code from the start, conducting regular code reviews, and scheduling time for refactoring when necessary.</p>\n<p>By investing time and resources upfront in reducing technical debt, teams can realize significant cost savings in the long run. Not only can this improve the team's productivity and morale, but it can also lead to higher quality software, faster delivery times, and ultimately, more satisfied customers.</p>\n<h2 id=\"takeaway\" data-toc-text=\"Takeaway\">Takeaway</h2>\n<p>Addressing technical debt requires a proactive mindset from the entire team. By investing time and resources upfront in reducing technical debt, teams can realize significant cost savings in the long run. This improves productivity, code quality, and ultimately leads to more satisfied customers.</p>\n<h2 id=\"related-links\" data-toc-text=\"Related Links\">Related Links</h2>\n<ul>\n<li><a href=\"https://www.toptal.com/developers/blog/managing-technical-debt-strategies-and-best-practices\" target=\"_blank\" rel=\"noopener noreferrer\">Managing Technical Debt: Strategies and Best Practices</a></li>\n<li><a href=\"https://www.seguetech.com/business-case-for-technical-debt\" target=\"_blank\" rel=\"noopener noreferrer\">The Business Case for Addressing Technical Debt</a></li>\n<li><a href=\"https://martinfowler.com/bliki/TechnicalDebt.html\" target=\"_blank\" rel=\"noopener noreferrer\">Technical Debt: What Every Developer Should Know</a></li>\n</ul>\n",
            "date_published": "2024-09-03T00:00:00Z",
            "tags": ["software-architecture","technical-debt","technical-leadership"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/mastering-user-onboarding/",
            "url": "https://yetric.com/blog/posts/mastering-user-onboarding/",
            "title": "Mastering User Onboarding: Best Practices for Engaging New Users",
            "summary": "Best practices for onboarding new users in a way that drives engagement, reduces frustration, and sets the stage for long-term retention.",
            "content_html": "<p>The onboarding process sets the stage for everything that follows. Get it wrong and users leave before they've seen what the product can do. Get it right and they reach the moment where the value clicks - and stick around.</p>\n<h2 id=\"the-importance-of-user-onboarding\" data-toc-text=\"The Importance of User Onboarding\">The Importance of User Onboarding</h2>\n<p>User onboarding is the initial experience users have with your app. It's the process of guiding users through the necessary steps to get started and demonstrating the app's value proposition. A well-designed onboarding experience can:</p>\n<ul>\n<li>\n<p><strong>Increase User Engagement</strong>: A smooth onboarding process helps users quickly understand and utilize your app's features, leading to higher engagement levels.</p>\n</li>\n<li>\n<p><strong>Reduce User Frustration</strong>: Clear instructions and intuitive design during onboarding minimize user confusion and frustration, ensuring a positive user experience.</p>\n</li>\n<li>\n<p><strong>Drive User Retention</strong>: When users successfully navigate onboarding and understand the value your app provides, they are more likely to become long-term, loyal users.</p>\n</li>\n</ul>\n<h2 id=\"best-practices-for-user-onboarding\" data-toc-text=\"Best Practices for User Onboarding\">Best Practices for User Onboarding</h2>\n<ol>\n<li>\n<p><strong>Simplify the Onboarding Process</strong>: Keep the onboarding process simple, focusing on essential steps that introduce key features and demonstrate value. Avoid overwhelming new users with excessive information or too many steps upfront.</p>\n</li>\n<li>\n<p><strong>Provide Clear and Concise Instructions</strong>: Clearly communicate how users can get started and navigate your app. Use simple language, visual cues, and interactive tutorials to guide users through the onboarding process.</p>\n</li>\n<li>\n<p><strong>Showcase Core Features</strong>: Highlight the core features and benefits of your app during onboarding. Demonstrate how these features address users' pain points or provide solutions to their needs.</p>\n</li>\n<li>\n<p><strong>Offer Progressive Disclosure</strong>: Introduce features gradually as users progress through onboarding and become familiar with the app's interface. This approach prevents overwhelming users with too much information upfront.</p>\n</li>\n<li>\n<p><strong>Utilize Visual Elements</strong>: Incorporate visuals such as illustrations, videos, or interactive tours to enhance the onboarding experience. Visual elements can effectively communicate complex concepts and engage users.</p>\n</li>\n<li>\n<p><strong>Personalize the Onboarding Experience</strong>: Tailor the onboarding process to individual users whenever possible. Collect relevant user data during signup and utilize it to provide a more personalized onboarding journey.</p>\n</li>\n<li>\n<p><strong>Provide Contextual Help</strong>: Offer in-context help and tooltips within the app interface to assist users when they encounter unfamiliar features or actions. Contextual guidance reduces friction and improves user understanding.</p>\n</li>\n<li>\n<p><strong>Encourage Interaction</strong>: Encourage users to interact with your app during onboarding. Incorporate interactive elements that allow users to explore features, complete tasks, and experience the app's value firsthand.</p>\n</li>\n<li>\n<p><strong>Measure and Iterate</strong>: Continuously monitor user onboarding metrics and gather user feedback to identify areas for improvement. Iterate on your onboarding process to enhance its effectiveness over time.</p>\n</li>\n</ol>\n<p>Good onboarding is never finished. Measure where users drop off, talk to people who churned early, and keep iterating. The goal is simple: help users reach the moment where the product's value becomes obvious, as quickly as possible.</p>\n",
            "date_published": "2024-05-13T00:00:00Z",
            "tags": ["onboarding","product","user-experience"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/mastering-user-acquisition/",
            "url": "https://yetric.com/blog/posts/mastering-user-acquisition/",
            "title": "Mastering User Acquisition: Effective Strategies for Web and Native Apps",
            "summary": "Effective strategies for growing your app's user base — from SEO and content marketing to referral programs and app store optimization.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>User acquisition is essential for growing your web or native app's user base. Effective strategies include defining your target audience, optimizing for search engines, utilizing content marketing, leveraging paid advertising, collaborating with influencers, implementing referral programs, optimizing app store presence, and utilizing social media marketing. Continuously analyze and adapt your strategies to improve outcomes.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>Growing an app's user base means making deliberate choices about which channels to invest in and continuously measuring what works. Here are the strategies that tend to matter most.</p>\n<p><strong>Define Your Target Audience</strong>: Understand your target audience - their demographics, preferences, and pain points. This knowledge lets you focus acquisition efforts where they'll have the most impact.</p>\n<p><strong>Search Engine Optimization (SEO)</strong>: Optimize your app's website and landing pages for search engines. Identify relevant keywords, create high-quality content, and ensure your site is user-friendly and mobile-responsive. This helps improve your app's visibility and attracts organic traffic.</p>\n<p><strong>Content Marketing</strong>: Create valuable content such as blog posts, videos, or tutorials related to your app's niche. Share your expertise, engage your audience, and establish your brand as a thought leader. Content marketing can attract and convert users who find value in your content.</p>\n<p><strong>Paid Advertising</strong>: Use paid channels such as social media ads or search engine marketing to reach specific audiences. Develop clear ad creatives, use precise targeting, and track campaign performance to optimize results.</p>\n<p><strong>Influencer Marketing</strong>: Collaborate with influencers or industry experts who have a relevant following. Their endorsement can introduce your app to new audiences and build trust. Select influencers who align with your brand values and have an engaged and active following.</p>\n<p><strong>Referral Programs</strong>: Incentivize existing users to refer new ones. Offer rewards, discounts, or exclusive features to both sides. Word-of-mouth is one of the most effective acquisition channels when the product is actually good.</p>\n<p><strong>App Store Optimization (ASO)</strong>: Optimize your app's presence in the app stores by using relevant keywords, compelling app descriptions, engaging screenshots, and positive user reviews. ASO helps improve visibility, increase app store rankings, and attract organic downloads.</p>\n<p><strong>Social Media Marketing</strong>: Use social media to promote your app, engage with your audience, and reach new users. Create useful content, run targeted ads, and participate in relevant communities to build awareness.</p>\n<p><strong>Partnerships and Collaborations</strong>: Partner with complementary apps, businesses, or creators. Cross-promote or collaborate on joint initiatives to reach new user segments you wouldn't otherwise access.</p>\n<p>Remember, user acquisition is an ongoing process that requires experimentation, monitoring, and adaptation. Continuously analyze your acquisition strategies, measure their effectiveness, and make data-driven optimizations to improve results.</p>\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li>Define your target audience and tailor your acquisition efforts to reach the right users.</li>\n<li>Optimize your app's website and landing pages for search engines to improve visibility and attract organic traffic.</li>\n<li>Create valuable content through content marketing to engage your audience and establish your brand as a thought leader.</li>\n<li>Utilize paid advertising channels and influencer collaborations to target specific audiences and expand your reach.</li>\n<li>Implement referral programs to leverage word-of-mouth marketing and incentivize existing users to refer new users.</li>\n<li>Optimize your app's presence in the app stores through app store optimization (ASO) techniques.</li>\n<li>Leverage social media platforms to promote your app, engage with your audience, and drive user acquisition.</li>\n<li>Forge strategic partnerships and collaborations to tap into new user segments and expand your reach.</li>\n</ol>\n",
            "date_published": "2024-02-20T00:00:00Z",
            "tags": ["growth","product","user-acquisition"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/user-retention-strategies/",
            "url": "https://yetric.com/blog/posts/user-retention-strategies/",
            "title": "Navigating User Retention: Essential Strategies for Web and Native Apps",
            "summary": "Essential strategies for keeping users coming back — personalization, push notifications, feedback loops, onboarding, and community building.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>User retention is crucial for the success of your web or native app. Key strategies include understanding user behavior, personalizing the user experience, leveraging push notifications, incorporating user feedback, providing regular updates, offering excellent customer support, implementing user onboarding, and creating a user community. Segmentation and context are essential for effective retention strategies.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>Retaining users is almost always more cost-effective than acquiring new ones. It's also a more direct signal that your product is delivering real value. Here are the strategies that tend to matter most.</p>\n<h2 id=\"how-to-improve-user-retention\" data-toc-text=\"How to Improve User Retention\">How to Improve User Retention</h2>\n<p><strong>Understand User Behavior</strong>: To retain users, first understand their behavior within your app. Use analytics tools to track key metrics such as active users, session length, and screen flow. Identifying patterns can inform effective engagement and retention strategies.</p>\n<p><strong>Personalize User Experience</strong>: Personalization can make users feel valued and increase their connection with your app. This could involve customizing content based on a user's preferences, behavior, or location, or even simple gestures like using their name.</p>\n<p><strong>Push Notifications</strong>: Used sparingly, push notifications can bring users back. The bar should be high: only send something when it adds real value - a new feature relevant to them, a meaningful update, or genuinely personalized content. Notifications that don't clear that bar train users to ignore or disable them.</p>\n<p><strong>Incorporate User Feedback</strong>: Paying attention to user feedback can reveal what users like and dislike about your app. Regularly collecting feedback via surveys, reviews, or direct communication can guide improvements that boost retention.</p>\n<p><strong>Frequent Updates and Improvements</strong>: Regular updates signal to users that your app is active and evolving. Updates should strive to improve the app experience, fix bugs, and introduce new features based on user feedback and needs.</p>\n<p><strong>Offer Excellent Customer Support</strong>: When users face issues or have questions, swift and helpful customer support can make the difference between them staying or leaving. Prioritize efficient, friendly, and effective customer support.</p>\n<p><strong>Implement a User Onboarding Process</strong>: A user-friendly onboarding process can help new users understand how to navigate your app and its benefits. This can greatly improve initial user retention.</p>\n<p><strong>Create a User Community</strong>: Fostering a sense of community can make users feel part of something larger, encouraging them to stick around. This can be achieved through features like forums, user-generated content, or social media interactions.</p>\n<p>Remember, all users are unique, and what works for one might not work for another. Segmenting your users and tailoring strategies to different groups can significantly improve retention outcomes.</p>\n<p>User retention requires continuous effort, adaptation, and a user-centric mindset. By listening to your users, understanding their needs, and providing value, you can improve user retention and drive business growth.</p>\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li>Understand user behavior and preferences to tailor your app experience to their needs.</li>\n<li>Personalize the user experience to make users feel valued and connected to your app.</li>\n<li>Utilize push notifications strategically to engage users and bring them back to your app.</li>\n<li>Incorporate user feedback to continuously improve your app based on user preferences.</li>\n<li>Regularly provide updates and improvements to keep your app fresh and exciting.</li>\n<li>Offer excellent customer support to address user concerns promptly and effectively.</li>\n<li>Implement a user onboarding process to help new users understand and navigate your app.</li>\n<li>Foster a sense of community to create a loyal user base and encourage long-term engagement.</li>\n</ol>\n",
            "date_published": "2023-11-07T00:00:00Z",
            "tags": ["engagement","product","retention"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/decoding-user-engagement/",
            "url": "https://yetric.com/blog/posts/decoding-user-engagement/",
            "title": "Decoding User Engagement: Measuring Engagement in Web and Native Apps",
            "summary": "How to measure user engagement in web and native apps using both quantitative metrics like DAU/MAU and qualitative signals like NPS and user interviews.",
            "content_html": "<h2 id=\"tl-dr\" data-toc-text=\"TL;DR\">TL;DR</h2>\n<p>User engagement is crucial for the success of your web or native app. Key metrics include active users, session length, frequency of use, screen flow, and retention rate. Qualitative metrics such as user feedback, Net Promoter Score (NPS), and user interviews provide deeper insights. Segment your audience for nuanced understanding. Context is essential in interpreting metrics. User engagement requires a comprehensive approach combining quantitative and qualitative measures.</p>\n<h2 id=\"introduction\" data-toc-text=\"Introduction\">Introduction</h2>\n<p>User engagement directly affects customer loyalty, revenue growth, and product direction. Measuring it well means combining quantitative metrics - the numbers - with qualitative signals that explain the why behind them.</p>\n<h2 id=\"how-to-measure-user-engagement\" data-toc-text=\"How to Measure User Engagement\">How to Measure User Engagement</h2>\n<p>Quantitative metrics provide numerical data that can measure user engagement in web and native apps. Some primary quantitative metrics include:</p>\n<ol>\n<li>\n<p><strong>Active Users</strong>: Both Daily Active Users (DAU) and Monthly Active Users (MAU) are fundamental metrics for engagement. They measure the number of users who interact with your application on a daily and monthly basis.</p>\n</li>\n<li>\n<p><strong>Session Length</strong>: This tracks the duration of user interaction during a single visit. The longer the session, the higher the level of engagement.</p>\n</li>\n<li>\n<p><strong>Frequency of Use</strong>: This metric reveals how often users open and use your app. More frequent usage suggests stronger user engagement.</p>\n</li>\n<li>\n<p><strong>Screen Flow</strong>: Tracking the paths users take through your app can illuminate which features are engaging and where users drop off.</p>\n</li>\n<li>\n<p><strong>Retention Rate</strong>: Retention rate is the proportion of users who return to your app after the first visit. A high retention rate indicates strong user engagement.</p>\n</li>\n</ol>\n<p>While quantitative metrics provide a broad overview of user activity, qualitative metrics add depth by highlighting the 'why' behind user actions. These include:</p>\n<ol>\n<li>\n<p><strong>User Feedback</strong>: User reviews, ratings, and feedback can give direct insights into what users think about your app and what improvements they desire.</p>\n</li>\n<li>\n<p><strong>Net Promoter Score (NPS)</strong>: NPS measures the willingness of customers to recommend your app to others. It's a strong indicator of customer satisfaction and, indirectly, of engagement.</p>\n</li>\n<li>\n<p><strong>User Interviews and Surveys</strong>: These can provide a deeper understanding of user preferences and behaviours, further illuminating user engagement.</p>\n</li>\n</ol>\n<p>Not all users are the same. Segmenting by user profile, behavior, or lifecycle stage gives you more accurate readings than aggregate averages.</p>\n<p>Context matters when reading these numbers. A short session length might signal poor engagement - or it might mean users are getting what they need quickly. You need to know which before acting on it.</p>\n<p>No single metric captures engagement. Use a combination of quantitative and qualitative measures, revisit them regularly, and let the patterns guide product decisions.</p>\n<h2 id=\"takeaways\" data-toc-text=\"Takeaways\">Takeaways</h2>\n<ol>\n<li>Monitor quantitative metrics such as active users, session length, frequency of use, screen flow, and retention rate to assess overall user engagement.</li>\n<li>Incorporate qualitative metrics such as user feedback, NPS, and user interviews to gain deeper insights into user preferences and behaviors.</li>\n<li>Segment your audience based on user profiles and behaviors to understand varying levels of engagement within your user base.</li>\n<li>Consider the context when interpreting engagement metrics, as different app designs and objectives can impact the perceived level of engagement.</li>\n<li>Use a combination of quantitative and qualitative measures to obtain a comprehensive understanding of user engagement.</li>\n<li>Regularly analyze engagement metrics to identify areas for improvement and optimize your app accordingly.</li>\n<li>Continuously monitor user engagement to stay attuned to your users' needs and enhance user experience.</li>\n<li>Prioritize user engagement as a key metric for driving growth, customer loyalty, and overall success of your web or native app.</li>\n</ol>\n",
            "date_published": "2023-08-14T00:00:00Z",
            "tags": ["analytics","engagement","product-metrics"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/big-update-to-podcast-app/",
            "url": "https://yetric.com/blog/posts/big-update-to-podcast-app/",
            "title": "Big Update to the Podcast App",
            "summary": "A rundown of the major new features shipped in the latest update to HittaPodd.se — the Swedish podcast browser app built with React, TypeScript, and Node.js.",
            "content_html": "<p>We just released a big update to <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a>, the podcast app for Swedish listeners we launched back in 2019.</p>\n<h2 id=\"new-features\" data-toc-text=\"New Features\">New Features</h2>\n<ul>\n<li>Daily updated toplists (based on iTunes)</li>\n<li>Personalized playlists</li>\n<li>Seasons for podcasts that have multiple seasons</li>\n<li>Trend tracking based on toplist positions</li>\n<li>Keeping track of podcast name changes (known as)</li>\n<li>More sources for finding new podcasts</li>\n<li>A growing list of curated collections of podcasts</li>\n<li>Groundwork laid for user accounts and personalized collections of podcasts, playlists, and episode collections — shareable or kept private</li>\n</ul>\n<h2 id=\"roadmap\" data-toc-text=\"Roadmap\">Roadmap</h2>\n<ul>\n<li>User accounts (login with Google, Apple, etc.)</li>\n<li>Create your own collections of podcasts</li>\n<li>Increase the number of sources for finding new podcasts</li>\n<li>Import toplists for more countries</li>\n<li>Native app for iOS and Android</li>\n</ul>\n<p>Feel free to check it out at <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a>.</p>\n",
            "date_published": "2022-08-01T00:00:00Z",
            "tags": ["case-study","podcasts","product-updates"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/new-podcast-app/",
            "url": "https://yetric.com/blog/posts/new-podcast-app/",
            "title": "We Launched a Swedish Browser-Based Podcast App",
            "summary": "Yetric built HittaPodd.se, a browser-based podcast app for Swedish listeners that surfaces popular podcasts from iTunes and RSS feeds.",
            "content_html": "<p>We at Yetric love listening to podcasts and love APIs. So we built a simple app for browsing Swedish top podcasts — a React-based application with an API that grabs data from iTunes, RSS feeds, and more to automatically update itself with the newest, most popular podcasts in Sweden.</p>\n<p>We have some ideas on how to make it stand out from other applications, and we'll be doing continued work until we feel it's an app we prefer over others for discovering and listening to podcasts.</p>\n<p>Feel free to check it out at <a href=\"https://hittapodd.se/\" target=\"_blank\" rel=\"noopener noreferrer\">HittaPodd.se</a>.</p>\n",
            "date_published": "2021-06-19T00:00:00Z",
            "tags": ["case-study","podcasts","product-launch"]
        },
        
        {
            "id": "https://yetric.com/blog/posts/whats-in-a-name/",
            "url": "https://yetric.com/blog/posts/whats-in-a-name/",
            "title": "What's in a Name?",
            "summary": "The story behind the name Yetric — from Strategio to 80 Ridge Street Media to \"yet another metric solution\".",
            "content_html": "<p>This week a friend of mine asked me: &quot;Why is it called Yetric? Any idea behind it or is it just something you grabbed from thin air?&quot;. There is an idea. Actually. If you have 2–3 minutes to spare, here's how the name came about.</p>\n<h2 id=\"why-is-the-company-called-yetric\" data-toc-text=\"Why is the company called Yetric?\">Why is the company called Yetric?</h2>\n<p>I've had a company for over 10 years. Mainly focusing on building smaller projects and hoping that one of them would sooner or later generate some income. During that period I learned a lot about finding niches, crafting the offer, and measuring how well a product delivers to the user and to the product's owner (which was often me).</p>\n<p>One of the things I am really proud of in my life is that me and my dad built a house in 2010. I lived there for over 7 years with my three kids and my wife. Around 2011 I changed my individual company — named Strategio — to a limited company. I tried to keep the name, but I wasn't allowed, since naming limited companies is harder than individual ones (at least here in Sweden). So I had to pick a new name.</p>\n<p>I used the address to the house me and my dad built: <strong>80 Ridge Street Media</strong>. I added &quot;Media&quot; since it's vague and kind of lets you offer a lot of different services and products. I was quite happy with the name.</p>\n<p>In 2017 me and my wife went through a divorce and we sold the house. I was really close to quitting everything that had to do with having a business. But after some reasoning with myself, I decided to continue — the name just felt strange. It was named after something I didn't own anymore, and it didn't feel right.</p>\n<p>So I had to come up with a new name.</p>\n<p>&quot;What do I actually want to do for a living?&quot; That was the big question.</p>\n<p>I want to live off my products. In order to do that, I need to either scale them up, build new ones, or build and sell products. I don't want to sell stuff I built — it felt bad when I sold the house my dad and I had built together. I really wanted to create things I owned and cared about.</p>\n<p>What am I good at? I'm quite good at coding, building user experiences, measuring the impact, and tweaking products according to data. So I decided on two things:</p>\n<ol>\n<li>I must do some consulting in order to make a living the first few years.</li>\n<li>I want to build a product that helps small business owners with the stuff I had been working on for a long time.</li>\n</ol>\n<p>What name should that product have? <em>Yet another metric solution.</em></p>\n<p>That's where I found it. I checked domain names, social media accounts — and <strong>Yetric</strong> was born. I registered the new name, and that's what's in a name.</p>\n",
            "date_published": "2019-10-20T00:00:00Z",
            "tags": ["branding","company","founder-story"]
        }
        
    ]
}
