<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Foundry 5</title>
    <description>The latest articles on DEV Community by Foundry 5 (@foundry5).</description>
    <link>https://dev.to/foundry5</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4210492%2Fad5cc880-62b8-4134-a03b-ecc9f5f9afdc.png</url>
      <title>DEV Community: Foundry 5</title>
      <link>https://dev.to/foundry5</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/foundry5"/>
    <language>en</language>
    <item>
      <title>UX Design Myths That Sound Sensible Until You Ship</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Thu, 19 Nov 2026 12:06:26 +0000</pubDate>
      <link>https://dev.to/foundry5/ux-design-myths-that-sound-sensible-until-you-ship-15ji</link>
      <guid>https://dev.to/foundry5/ux-design-myths-that-sound-sensible-until-you-ship-15ji</guid>
      <description>&lt;p&gt;Ask a room of founders what UX design is for and you will hear a version of the same answer: making the product look good so people trust it. That answer is not wrong, exactly. It is just small enough to cause real damage when it becomes the basis for how a team spends its design budget.&lt;/p&gt;

&lt;p&gt;Here are four beliefs that sound reasonable in a planning meeting and turn expensive later.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: Design is what happens after the requirements are settled
&lt;/h2&gt;

&lt;p&gt;The tidy version of a product build goes: decide what to build, then design it, then engineer it. Design sits in the middle as a translation step, turning a spec into screens.&lt;/p&gt;

&lt;p&gt;The problem is that requirements are usually guesses. Someone believes users will want a particular flow, and the design job becomes making that flow look convincing. Nobody has watched a real person attempt it. By the time the flow is built and tested, the guess has hardened into code, and changing it means a sprint rather than a sketch.&lt;/p&gt;

&lt;p&gt;Design that earns its keep sits earlier than that. Research and journey mapping are not extras bolted on before the visuals; they are the part that tells you whether the thing you are about to build is the right thing. Teams that treat design as decoration discover the answer in production, where it costs the most.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: A beautiful mockup is a finished design
&lt;/h2&gt;

&lt;p&gt;A polished screen in a design tool creates a strong sense of progress. Stakeholders approve it, the meeting ends well, and everyone assumes the design is done.&lt;/p&gt;

&lt;p&gt;What the mockup does not answer: what happens when the field is empty, when the network drops, when the text is twice as long in German, when the user is on a small phone in bright sunlight. Those states are where products actually break, and they are rarely in the picture.&lt;/p&gt;

&lt;p&gt;A design that is genuinely ready for engineering carries interaction detail, responsive behaviour and the awkward edge cases. Without them, developers fill the gaps with assumptions. The build drifts from the design, and both sides end up frustrated with the other.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: Consistency is a nice-to-have for later
&lt;/h2&gt;

&lt;p&gt;Early on, every screen gets designed on its own terms. It feels faster. There is no system to think about, just the next page.&lt;/p&gt;

&lt;p&gt;The cost arrives quietly. Spacing shifts by a few pixels between screens. Buttons behave differently in different places. Users cannot say what is wrong, but the product starts to feel like several apps stitched together, and trust erodes with each inconsistency.&lt;/p&gt;

&lt;p&gt;A shared set of components, spacing rules and type scales is cheaper to build early than to retrofit. The interesting part is that it also speeds up development, because engineers map tokens to code instead of guessing at values.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: User testing is a luxury for big budgets
&lt;/h2&gt;

&lt;p&gt;Testing has a reputation as a formal, expensive phase involving a lab and a report nobody reads. So it gets deferred until there is time, which is to say never.&lt;/p&gt;

&lt;p&gt;In practice the useful version is small and early: watching a handful of people try the flows that matter, before a line of code exists. The findings are rarely subtle. What matters is that they arrive while changes are still cheap.&lt;/p&gt;

&lt;p&gt;The belief that design is about making things attractive is not so much false as incomplete. Attractive is a side effect of clarity, and clarity comes from evidence. Teams that skip the evidence do not save money; they move the spend to a later, more painful stage.&lt;/p&gt;

&lt;p&gt;There is a fuller version of this argument, with the specific methods behind each of these points, on the &lt;a href="https://foundry-5.com/services/ux-ui-design" rel="noopener noreferrer"&gt;UX UI design services in London&lt;/a&gt; page.&lt;/p&gt;

</description>
      <category>uxdesign</category>
      <category>productdesign</category>
      <category>designsystems</category>
      <category>userresearch</category>
    </item>
    <item>
      <title>A Redesign Marketplace Fails on Trust, Not on Style</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Wed, 18 Nov 2026 11:52:15 +0000</pubDate>
      <link>https://dev.to/foundry5/a-redesign-marketplace-fails-on-trust-not-on-style-2gdl</link>
      <guid>https://dev.to/foundry5/a-redesign-marketplace-fails-on-trust-not-on-style-2gdl</guid>
      <description>&lt;p&gt;Most people building a clothing redesign marketplace spend their early energy on the wrong surface. They agonise over the upload flow, the photo quality, the colour of the call-to-action. Those things matter, but they are not what decides whether the platform works. What decides it is whether a customer who has never met a designer can hand over a favourite jacket and feel confident it comes back better rather than ruined. The product is a trust machine dressed as a shopping app.&lt;/p&gt;

&lt;p&gt;This runs against the usual advice, which is to ship the browsing and discovery experience first and let the transaction layer catch up. That order is backwards for this category. Discovery is a solved problem in fashion; people know how to scroll a feed. Redesign is not solved, because it asks a stranger to spend money on an outcome nobody can preview. A customer posting a project is not buying a dress off a rack. They are commissioning work, on a garment they cannot replace, from someone whose skill they cannot independently verify. Every design decision either reduces that uncertainty or quietly adds to it.&lt;/p&gt;

&lt;h2&gt;
  
  
  The price is a conversation, not a number
&lt;/h2&gt;

&lt;p&gt;A conventional marketplace pushes sellers to list a fixed price so buyers can compare. That model breaks here. Redesign work depends on the garment, the ambition, and the designer's read of what is achievable, so a flat number is either guesswork or a race to the bottom. The healthier pattern is a structured response where designers explain their thinking alongside their quote, which lets the customer compare reasoning rather than digits. It also filters out the people who would underprice to win and then cut corners. When you let the quote carry an explanation, you turn a price comparison into a competence comparison, and that is what the customer actually needs.&lt;/p&gt;

&lt;h2&gt;
  
  
  Chat is a feature you will regret leaving open
&lt;/h2&gt;

&lt;p&gt;The instinct is to unlock messaging as early as possible so buyers and designers can "build rapport". In practice, an open channel before any commitment becomes a place for scope creep, off-platform deals, and disputes with no record. The interesting design question is not whether to have chat but when it opens and what it is scoped to. A channel that appears only after a designer is selected, and that is attached to the project rather than to the person, keeps the conversation about the work. It also gives you something to point to when a customer says the brief was different. That constraint feels unfriendly to some founders; it is the opposite. Clear boundaries are what make people willing to transact with a stranger at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  What good looks like
&lt;/h2&gt;

&lt;p&gt;The signals of a marketplace that has got this right are unglamorous. Projects post with enough detail that designers can respond usefully. Quotes arrive with reasoning attached. Conversations stay inside the platform because the platform made staying easier than leaving. Designers build a visible record of completed work, and that record does more for their next booking than any profile photo. Customers come back with a second garment because the first one went well, which is the only retention metric that matters in a category built on trust.&lt;/p&gt;

&lt;p&gt;None of this is about aesthetics, and none of it can be bolted on after launch. It has to be in the data model and the permission logic from the start. If you want to see how these decisions fit together in a shipped product, the &lt;a href="https://foundry-5.com/portfolio/loom-fashion" rel="noopener noreferrer"&gt;Loom fashion marketplace case study&lt;/a&gt; walks through the actual flows, the matching logic, and the chat and commission rules that made the platform hold together.&lt;/p&gt;

</description>
      <category>marketplacedesign</category>
      <category>mobileapps</category>
      <category>fashiontech</category>
      <category>trustandsafety</category>
    </item>
    <item>
      <title>Seven Signs Your Health App Idea Has Outgrown a Simple Tracker</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Tue, 17 Nov 2026 14:55:21 +0000</pubDate>
      <link>https://dev.to/foundry5/seven-signs-your-health-app-idea-has-outgrown-a-simple-tracker-1ma0</link>
      <guid>https://dev.to/foundry5/seven-signs-your-health-app-idea-has-outgrown-a-simple-tracker-1ma0</guid>
      <description>&lt;p&gt;Most wellness apps start as a calendar with a few buttons. That is a reasonable place to begin. The trouble starts when the product is expected to explain, reassure and adapt, and the architecture was never built for any of that.&lt;/p&gt;

&lt;p&gt;Here are signs worth checking against your own product.&lt;/p&gt;

&lt;h2&gt;
  
  
  Signs in the product itself
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Users log symptoms faithfully and still ask what the data means. Logging without interpretation shifts the work back onto the person, and engagement quietly drops.&lt;/li&gt;
&lt;li&gt;Your insights are static copy that fires on a date. If two users with very different histories see identical text, the personalisation is cosmetic.&lt;/li&gt;
&lt;li&gt;The chat feature answers general questions but not ones tied to what the user logged this week. Symptom-aware responses are a different build from a generic assistant.&lt;/li&gt;
&lt;li&gt;Cycle predictions are treated as a simple average. Irregular cycles, missed logs and life events all bend the curve, and a confident wrong prediction costs more trust than a cautious one.&lt;/li&gt;
&lt;li&gt;Tone is decided late. In an emotional wellness product, wording is a feature, and it needs review from people who understand the audience, not just the design team.&lt;/li&gt;
&lt;li&gt;Free and paid features were never clearly separated. If the boundary is unclear to you, it will feel arbitrary to users, and that erodes trust faster than a paywall does.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Questions about the people using it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Do you know how your youngest users talk about their bodies, and whether your copy sounds like a clinician, a friend or a stranger?&lt;/li&gt;
&lt;li&gt;Have you tested the app with the actual demographic, or with colleagues who already understand the domain?&lt;/li&gt;
&lt;li&gt;Would a user describing a difficult week find the app supportive, or would it hand them a chart?&lt;/li&gt;
&lt;li&gt;Is there a plan for what happens when someone reports something serious, and does the product avoid pretending to be a medical service?&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Questions about the build and the obligations
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Is privacy a constraint on the architecture, or a paragraph in the settings screen?&lt;/li&gt;
&lt;li&gt;If your audience includes minors, do you know which rules apply to data handling and consent before the first line of code, rather than after the store review?&lt;/li&gt;
&lt;li&gt;Does your subscription logic sit on top of a backend that can scale, or will premium features need a rebuild in month three?&lt;/li&gt;
&lt;li&gt;Has anyone stress-tested the AI layer for usage limits, cost per conversation and what happens when the model is slow or wrong?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A good outcome looks unglamorous: the app explains a pattern in plain language, the chat knows what the user logged, the prediction admits uncertainty, and the privacy decisions were made before the screens were drawn. Users feel understood rather than processed, and the team stops patching trust after launch.&lt;/p&gt;

&lt;p&gt;The full breakdown of how Ove Care was researched, designed and built, including the AI insight engine, the symptom-aware chat and the compliance decisions behind it, is on the &lt;a href="https://foundry-5.com/portfolio/ove-care" rel="noopener noreferrer"&gt;Ove Care AI health app case study&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>healthtech</category>
      <category>mobileapps</category>
      <category>aiproduct</category>
      <category>privacy</category>
    </item>
    <item>
      <title>What It Takes to Trust an AI Agent With Real Work</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Mon, 16 Nov 2026 08:30:42 +0000</pubDate>
      <link>https://dev.to/foundry5/what-it-takes-to-trust-an-ai-agent-with-real-work-4e2l</link>
      <guid>https://dev.to/foundry5/what-it-takes-to-trust-an-ai-agent-with-real-work-4e2l</guid>
      <description>&lt;p&gt;A video of an AI agent booking a meeting, reconciling an invoice, or clearing a support queue is easy to find. Getting that same agent to do those things on a Tuesday, against your actual systems, with inputs nobody scripted, is a different project. The gap between the two is where most of the budget goes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who this is actually for
&lt;/h2&gt;

&lt;p&gt;Agent work pays off when the job involves judgement that shifts from case to case: reading a messy request, deciding which system to touch, and choosing between plausible next moves. Back-office operations, research triage, and support resolution fit that shape.&lt;/p&gt;

&lt;p&gt;Plenty of tasks do not. If the work follows fixed steps, a plain script is faster, cheaper and far easier to reason about when it breaks. Adding a reasoning loop to a job a function already handles buys you cost, latency and a new class of failure. Knowing which side of that line you sit on is the first decision, and it is worth making honestly before any code exists.&lt;/p&gt;

&lt;h2&gt;
  
  
  What usually goes wrong
&lt;/h2&gt;

&lt;p&gt;The recurring failure is scope. An agent handed broad permissions and a vague goal will act confidently and wrongly, and the trail of why it did so is often missing entirely. Without scoped tools, approval checkpoints where mistakes cost money, and traces of each decision, you have a machine that generates expensive surprises nobody can reconstruct afterwards.&lt;/p&gt;

&lt;p&gt;Then there is reliability. Demos assume tools respond, inputs are clean and the happy path holds. Production assumes the opposite. Retries, fallbacks, cost ceilings and latency limits are not polish layered on at the end; they are the work.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a trustworthy agent feels like
&lt;/h2&gt;

&lt;p&gt;Done well, the agent has a narrow, named job and a defined boundary around what it may and may not do. It retrieves from your real data rather than guessing, and it remembers what it has already attempted. Risky actions pause for a human.&lt;/p&gt;

&lt;p&gt;Behind it sits a test suite covering edge cases as well as the easy path, and a trace of every run that a non-engineer can follow. Costs are bounded, so a loop cannot quietly spend a week's budget overnight. And the code belongs to you, not to whoever built it, which matters the moment you want to change a tool or a rule.&lt;/p&gt;

&lt;h2&gt;
  
  
  The bar to hold a build against
&lt;/h2&gt;

&lt;p&gt;Ask what happens when a tool times out, who approves the costly step, and how you would know the agent made a bad call three days later. If those answers are vague, the demo is doing the persuading rather than the design.&lt;/p&gt;

&lt;p&gt;The full guide at &lt;a href="https://foundry-5.com/services/ai-agent-development-services" rel="noopener noreferrer"&gt;Foundry 5 on production AI agent development in London&lt;/a&gt; covers the specific package every build ships with: how tools get scoped, where approvals sit, how evals and fallbacks are structured, and what observability and cost controls look like in practice.&lt;/p&gt;

</description>
      <category>aiagents</category>
      <category>llmengineering</category>
      <category>productionai</category>
      <category>softwarereliability</category>
    </item>
    <item>
      <title>What People Assume About Building a Health App for Teenagers</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Sun, 15 Nov 2026 09:29:37 +0000</pubDate>
      <link>https://dev.to/foundry5/what-people-assume-about-building-a-health-app-for-teenagers-2e6p</link>
      <guid>https://dev.to/foundry5/what-people-assume-about-building-a-health-app-for-teenagers-2e6p</guid>
      <description>&lt;p&gt;Ask someone outside the industry what a cycle tracking app does and you will usually get a short answer: it logs dates and predicts the next one. That answer is not wrong, but it is roughly the equivalent of saying a banking app stores your balance. The feature list is real. It just is not where the product succeeds or fails.&lt;/p&gt;

&lt;p&gt;The gap between that expectation and the reality of building for young users is where most of the expensive mistakes live. These are the assumptions worth challenging before anyone opens a design tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: The hard part is the prediction logic
&lt;/h2&gt;

&lt;p&gt;Cycle prediction is maths, and the maths is well understood. What is genuinely hard is what happens around it. A young user opens the app on a day when she feels awful, and the screen either explains something or it does not. Raw data with no interpretation leaves her more anxious than before she opened it.&lt;/p&gt;

&lt;p&gt;Personalised insight is the product. The calendar is the interface. Teams that budget their effort the other way round end up with a technically accurate app that nobody opens twice.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: A chatbot is a feature you bolt on
&lt;/h2&gt;

&lt;p&gt;An AI companion inside a health app is not a support widget. Tone, boundaries and the handling of sensitive disclosures all become product decisions, not support decisions. A response that would be fine in a shopping app can be actively harmful when someone describes a symptom or a bad week.&lt;/p&gt;

&lt;p&gt;This is why the chatbot work has to be shaped by health expertise and tested with real users from the target age group, not written by whoever happens to be free. The question is never "can it answer" but "should it answer this, and in what register".&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: Privacy is a compliance checkbox
&lt;/h2&gt;

&lt;p&gt;For an app aimed at under-18s, data handling is a design constraint that shapes architecture, not a document you attach at the end. Consent, retention, encryption and what the AI is allowed to see all interact with each other. Retrofitting them after the build is where timelines die.&lt;/p&gt;

&lt;p&gt;Users feel this even when they cannot name it. A teenager who senses an app is careless with her information will not tell you she noticed. She will simply stop logging honestly, and the personalisation quietly degrades into guesswork.&lt;/p&gt;

&lt;h2&gt;
  
  
  Myth: Premium features are just gated screens
&lt;/h2&gt;

&lt;p&gt;There is a real tension in health apps between monetisation and trust, and it is sharper when the audience is young. Paywalling the emotional support or the clearer explanations reads as holding reassurance hostage, and users respond to that.&lt;/p&gt;

&lt;p&gt;A good result looks like a free experience that still feels complete, with paid tiers offering depth rather than relief. That is a positioning decision made early, not a paywall toggled late.&lt;/p&gt;

&lt;h2&gt;
  
  
  What good actually looks like
&lt;/h2&gt;

&lt;p&gt;The apps that earn long-term trust tend to share a shape: clear explanations instead of raw numbers, emotional support that stays within safe bounds, privacy built into the architecture, and a premium model that does not punish the anxious user. None of that is exotic. It is just rarely the thing teams plan for first.&lt;/p&gt;

&lt;p&gt;The full breakdown of how those decisions were made on a live AI health app, including the research, safety and subscription choices, is in the &lt;a href="https://foundry-5.com/portfolio/ove-care" rel="noopener noreferrer"&gt;Ove Care case study&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>healthapps</category>
      <category>productdesign</category>
      <category>privacy</category>
      <category>aiproducts</category>
    </item>
    <item>
      <title>What Actually Stalls a Supplier Security Review</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Sat, 14 Nov 2026 12:12:14 +0000</pubDate>
      <link>https://dev.to/foundry5/what-actually-stalls-a-supplier-security-review-2e7g</link>
      <guid>https://dev.to/foundry5/what-actually-stalls-a-supplier-security-review-2e7g</guid>
      <description>&lt;p&gt;A deal reaches the last gate. Someone inside the buying company has already decided they want your product, and their security function now gets a veto. Your contact takes your answers into a meeting you are not invited to and speaks for you from memory. That is the moment a supplier's preparation either holds or quietly falls apart.&lt;/p&gt;

&lt;h2&gt;
  
  
  The review is not a test of your product
&lt;/h2&gt;

&lt;p&gt;It helps to see what this gate actually is. A regulator is neutral at best, but an enterprise security team did not choose your software and has no reason to hurry. Their job is to decide whether trusting you is defensible. They are not judging whether your product is good; they are judging whether you can prove, on paper and quickly, that it is safe to connect to their systems.&lt;/p&gt;

&lt;p&gt;That distinction explains the strange outcomes. A genuinely well-built product can sit in review for a quarter and then go cold, not because anyone rejected it, but because the questions kept arriving slowly and the buying team moved on. In a procurement cycle, a secure product that cannot demonstrate its position fast enough ends up in the same place as an insecure one.&lt;/p&gt;

&lt;p&gt;Every gap in what you hand over becomes something your champion has to improvise. The more they improvise, the more exposed they feel, and the less energy they have for pushing the deal forward.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where prepared suppliers still come unstuck
&lt;/h2&gt;

&lt;p&gt;Most of the trouble is not technical. It is the same handful of patterns, and they repeat across companies.&lt;/p&gt;

&lt;p&gt;The pack gets rebuilt for every deal. Nothing was kept from the last review, so each buyer triggers the same few weeks of digging through old tickets and messages to reconstruct answers that were already worked out once. By the fourth deal, a meaningful slice of engineering time has gone on questions the company has answered before.&lt;/p&gt;

&lt;p&gt;The written answer and the shipped product drift apart. Someone optimistic fills in a questionnaire, and later a reviewer asks to see the thing an answer described, only to find it still on a roadmap. Consistency between answers, and between answers and reality, is where most suppliers fail without noticing.&lt;/p&gt;

&lt;p&gt;An undeclared third party surfaces. A tool added mid-sprint never made it onto the list of sub-processors, and the buyer spots it before you remember it existed. Once that happens, every other answer gets read with less trust.&lt;/p&gt;

&lt;p&gt;Access records go missing. Everyone is sure a leaver's access was removed, and it probably was, but the record of when, by whom and with whose approval is the only thing a reviewer will accept. Memory does not count.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a good outcome looks like
&lt;/h2&gt;

&lt;p&gt;The supplier who comes through this well is rarely the one with the most impressive security story. It is the one whose champion can forward a complete pack without editing it. The answers are true, consistent with each other and consistent with the product. The diagrams show where data physically sits rather than how the system is pitched. The evidence of access, incident handling and recovery has been assembled once and kept ready for the next buyer, who will ask for much the same things in a different order.&lt;/p&gt;

&lt;p&gt;That is the useful thing a supplier can do for a deal: make the person arguing for you look prepared, and take the guesswork out of their meeting. The full guide, covering the nine items procurement packs keep asking for, what fails a questionnaire, and how to be ready before it lands, is at &lt;a href="https://foundry-5.com/solutions/enterprise-security-review" rel="noopener noreferrer"&gt;passing the enterprise security review as a supplier&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>securityreview</category>
      <category>procurement</category>
      <category>enterprisesales</category>
      <category>compliance</category>
    </item>
    <item>
      <title>The Under-18 Product Mistakes That Get You Rejected</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Fri, 13 Nov 2026 08:42:35 +0000</pubDate>
      <link>https://dev.to/foundry5/the-under-18-product-mistakes-that-get-you-rejected-37eh</link>
      <guid>https://dev.to/foundry5/the-under-18-product-mistakes-that-get-you-rejected-37eh</guid>
      <description>&lt;p&gt;The most common mistake in software for under-18s is treating age as a form field. A date of birth sits next to name and email, editable, unverified, and worth nothing to a reviewer. The product knows what someone typed. It has never known how old they are.&lt;/p&gt;

&lt;p&gt;That gap is where most of the trouble starts, because everything downstream — consent, data retention, the store listing — assumes the age is real. Here are the other mistakes that tend to arrive with it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Designing the adult flow first
&lt;/h2&gt;

&lt;p&gt;A team builds the grown-up experience, gets it working, then bolts a parental branch on near the end. The seams show. Reviewers look at seams first, because a consent flow that was retrofitted tells them how much thought the rest of the product got.&lt;/p&gt;

&lt;p&gt;The deeper issue is that a children's product has two users who never agree. A teenager wants privacy from a parent; the parent wants oversight. Both are being reasonable. Every consent screen takes a side in that argument, and burying the choice in a settings toggle is the weakest answer available. Teams that defer this decision end up rebuilding the data model once they finally make it.&lt;/p&gt;

&lt;h2&gt;
  
  
  A reporting route with nothing at the other end
&lt;/h2&gt;

&lt;p&gt;There's a button. It looks like safeguarding. Where the report lands, who reads it and how quickly they respond were left for later — and the submission arrived before later did.&lt;/p&gt;

&lt;p&gt;A reporting route has four parts: the form, a named person, a response time and a record. Until somebody is named, the route doesn't exist, however polished the form looks. This is the mistake that carries the most weight, because it's the one where the failure isn't a rejection but a child using a feature that leads nowhere.&lt;/p&gt;

&lt;h2&gt;
  
  
  Treating consent as a single event
&lt;/h2&gt;

&lt;p&gt;Some accounts rest on the young person's consent, some on a parent's, some on both. Teams often record that consent was given without recording which kind applied to which account, or when it changed.&lt;/p&gt;

&lt;p&gt;It changes on a birthday, whether or not anyone is watching. A product that can't say whose consent it relied on, for what, and how it would prove that a year later is a product that can't answer a straightforward reviewer question. The Children's Code also asks the harder half of data minimisation: what you chose not to store, and evidence that the choice was deliberate. Teams rarely plan for that.&lt;/p&gt;

&lt;h2&gt;
  
  
  Scheduling submission as a formality
&lt;/h2&gt;

&lt;p&gt;The launch date assumes approval. Nobody costs a rejection, so the first one eats the buffer and the second eats the launch.&lt;/p&gt;

&lt;p&gt;The store decision rests with someone you'll never speak to, working from rules you can't negotiate. Apple's Kids Category and Google Play's Families policy both check the declared rating against what the app shows. Your data declarations have to match what you collect, and your screenshots tell the reviewer who the product is for before they open it. None of that is a formality, and a rejection lands after the date is public.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a good result looks like
&lt;/h2&gt;

&lt;p&gt;A children's product that survives review tends to share a few traits. It can show age assurance rather than self-declaration. It records which consent model applied to which account and when it shifted. It has a safeguarding route with a named owner on the other side. And its store listing matches the product, so the reviewer opening it cold sees what the team intended.&lt;/p&gt;

&lt;p&gt;The build is the easy part. Proving the decisions behind it is where the work sits.&lt;/p&gt;

&lt;p&gt;The full guide, including the week that settles consent before anyone draws a screen, is at &lt;a href="https://foundry-5.com/solutions/software-for-under-18s" rel="noopener noreferrer"&gt;building software for under-18s&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>childrensprivacy</category>
      <category>appstorereview</category>
      <category>safeguarding</category>
      <category>consentdesign</category>
    </item>
    <item>
      <title>Why Does the Review Date Always Move After the Build Starts?</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Thu, 12 Nov 2026 09:48:37 +0000</pubDate>
      <link>https://dev.to/foundry5/why-does-the-review-date-always-move-after-the-build-starts-27el</link>
      <guid>https://dev.to/foundry5/why-does-the-review-date-always-move-after-the-build-starts-27el</guid>
      <description>&lt;p&gt;Most teams can name the review they have to pass. Fewer can say what that reviewer will ask them to produce, who inside the company owns each item, and which decisions have to be settled before anyone opens an editor. That gap is where the questions below come from, and it is worth sitting with them before a build plan hardens.&lt;/p&gt;

&lt;h2&gt;
  
  
  When should compliance enter the build?
&lt;/h2&gt;

&lt;p&gt;The instinct is to treat review as a stage near the end, something you prepare for once the product exists. That framing feels efficient because it keeps the early weeks focused on features. It also quietly fixes the answers to questions like age assurance, consent handling, audit trails and data residency months before anyone asks them. By the time a reviewer raises one, the architecture has already decided the answer. A good outcome depends on when you accept that these are design inputs, not paperwork, and on whether the person who can commit to that sits in the room early enough to matter.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a useful first week actually produce?
&lt;/h2&gt;

&lt;p&gt;Plenty of discovery weeks end with a deck, a proposal written to win the work, or a document nobody reopens. The question worth asking is what physically exists on Friday that did not exist on Monday, and whether it would still be useful if you handed it to a different supplier. A good answer depends on artefacts, not conversation: a map of the gate and its approver, an evidence list with a named owner per item, and a clear record of what would have failed if tested against that list. If the week cannot survive being handed to someone else, it was a pitch.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which problems tend to surface too late?
&lt;/h2&gt;

&lt;p&gt;Four keep coming up. Evidence nobody is producing, where the current setup cannot reconstruct audit trails or consent logs after the fact. A second gate nobody named, usually a market, partner or app store with its own date that never entered the plan. An approver who has not seen the product, whether that is a compliance lead, clinical safety officer or security owner. And scope too wide for the fixed date, where cutting deliberately later costs far more than cutting early. Each is cheap to raise while it is still a line on a plan and expensive to discover in month five.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who needs to be in the room?
&lt;/h2&gt;

&lt;p&gt;The temptation is to delegate the week to whoever is least busy. That usually produces a plan nobody with authority has agreed to. The decisions that cost most to undo are sequencing decisions, and they belong to the person who can sign them off. A good answer depends on a founder or equivalent giving a few focused hours across the week, plus someone who can answer questions about existing systems. Nobody needs to be pulled off their work full time, but the wrong person in the room makes the whole exercise decorative.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a good result look like?
&lt;/h2&gt;

&lt;p&gt;Not a document. A sequence that runs backwards from a date nobody will move, a written list of what is deliberately not in version one, and a price attached to a fixed scope instead of a day rate guessing at an unknown. The test is whether the review and the build share the same evidence list, so nothing gets estimated twice from a blank page.&lt;/p&gt;

&lt;p&gt;The full guide at &lt;a href="https://foundry-5.com/how-we-work/the-week-one-review" rel="noopener noreferrer"&gt;how the Week-One Review works, day by day and what it costs to start&lt;/a&gt; sets out what happens on each of the five days, the four artefacts you keep, how the fee is credited against the build, and the terms if you walk away.&lt;/p&gt;

</description>
      <category>compliance</category>
      <category>productdesign</category>
      <category>uktech</category>
      <category>softwaredelivery</category>
    </item>
    <item>
      <title>A Readiness Check That Cannot Say Maybe Is Worth More</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Wed, 11 Nov 2026 15:32:22 +0000</pubDate>
      <link>https://dev.to/foundry5/a-readiness-check-that-cannot-say-maybe-is-worth-more-bdm</link>
      <guid>https://dev.to/foundry5/a-readiness-check-that-cannot-say-maybe-is-worth-more-bdm</guid>
      <description>&lt;p&gt;Ask a team whether they are ready for a review they have to pass and you will usually get a hedge. Nearly ready. Mostly there. One or two things to tidy up. That answer feels polite, and it is the most expensive thing a team can tell itself, because reviews do not grade on a curve. A gated review behaves like a vehicle inspection: one worn part fails the whole thing regardless of how clean everything else is. The reviewer is not weighing your effort. They are looking for a missing piece of evidence, and finding one is enough.&lt;/p&gt;

&lt;p&gt;So the argument is this: a readiness check is only worth using if it refuses to give you a maybe. A tool that returns a percentage, a colour-coded dashboard or a reassuring "you're on track" is doing you a disservice, because it lets you leave with the same comfortable ambiguity you arrived with. What you actually need is a blunt verdict, and a verdict is only credible if one of its possible outcomes is "not ready, and here is the single thing that is missing."&lt;/p&gt;

&lt;h2&gt;
  
  
  The three answers that matter
&lt;/h2&gt;

&lt;p&gt;A useful check has to be able to send you somewhere else. If every path leads back to the same next step, the questions were decoration. The honest outcomes are narrow: you are ready and you know roughly where you would start; you are not ready and you know which one gap is holding you back; or this is not the right kind of work for the people asking, and there is a better place to take it. That third answer is the one most tools omit, and its absence is what makes the other two untrustworthy. A check that can never turn you away is not assessing you, it is qualifying you.&lt;/p&gt;

&lt;p&gt;The same logic applies to the questions themselves. Each one should map to a fact that a build gets sequenced around, not a box to tick. If you cannot answer one, that is not a neutral gap. It is a finding, and it belongs in the result.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the not-knowing is the finding
&lt;/h2&gt;

&lt;p&gt;Teams tend to treat an unanswerable question as a reason to come back later. Which review applies here? Who inside the company signs it off? Has a supplier failed this before? These feel like admin, so they get deferred. But a reviewer will ask exactly these things, and a blank where an owner should be is the most common way a pack stalls. Not knowing which review you are facing usually means you have not yet worked out who is asking, and that single unknown reshapes everything downstream.&lt;/p&gt;

&lt;p&gt;The temptation is to soften the question, to let "not sure yet" pass as a valid answer and move on. Sometimes it genuinely is one, because one later question settles it. But the check still has to hold you to the consequence: an unresolved review type is a result in itself, not a footnote.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a good result looks like
&lt;/h2&gt;

&lt;p&gt;A good result is short, unflattering where it needs to be, and specific. It names the band you would most likely start in, or the one thing that is missing, or the honest reason this is not your work. It asks nothing of you before it gives you that. No account, no email, nothing stored or sent. That last part is not a privacy gimmick; it is what lets you answer truthfully instead of answering the way you would want a vendor to see.&lt;/p&gt;

&lt;p&gt;If you want the verdict turned into a plan, that is a conversation you choose to start. Nobody chases you for it. The full six questions, the three possible answers and what each one costs to close are laid out in the &lt;a href="https://foundry-5.com/tools/review-readiness-check" rel="noopener noreferrer"&gt;review readiness check&lt;/a&gt;, which is where the actual method lives.&lt;/p&gt;

</description>
      <category>compliance</category>
      <category>securityreview</category>
      <category>procurement</category>
      <category>productdelivery</category>
    </item>
    <item>
      <title>Signs Your Fintech Build Was Never Designed for an FCA Review</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Tue, 10 Nov 2026 05:41:26 +0000</pubDate>
      <link>https://dev.to/foundry5/signs-your-fintech-build-was-never-designed-for-an-fca-review-462o</link>
      <guid>https://dev.to/foundry5/signs-your-fintech-build-was-never-designed-for-an-fca-review-462o</guid>
      <description>&lt;p&gt;Most fintech teams find out their build cannot answer a reviewer's questions at the worst possible moment. The signs were there months earlier, in decisions nobody flagged as compliance decisions.&lt;/p&gt;

&lt;h2&gt;
  
  
  The evidence problem is already in the data model
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Balances are stored as a single field that gets overwritten on each change. If nobody can trace how a figure arrived at its current value, the client money question has no answer that does not involve rebuilding history.&lt;/li&gt;
&lt;li&gt;Logging is treated as a launch task. Ask yourself when the first line of audit logging was written. If the honest answer is "near the end", the months before it are a blank.&lt;/li&gt;
&lt;li&gt;Rules live in code with no version attached. Suitability logic that changed three times in a year, with nothing recording which version produced which outcome, turns a simple question into an archaeology project.&lt;/li&gt;
&lt;li&gt;The audit records exist but only an engineer can read them. A compliance officer who needs a developer to interpret a log is a firm that cannot answer its own regulator promptly.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The permission boundary is a document, not a feature
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Someone can describe the firm's permissions from memory, but nobody can point to where the product enforces them.&lt;/li&gt;
&lt;li&gt;A feature flag is doing the work of a permission boundary. Flags are policy with a switch, and switches get flipped by people who were not in the room when the rule was agreed.&lt;/li&gt;
&lt;li&gt;Features exist in the customer-facing build that no permission clearly covers. The usual justification is that nobody uses them yet.&lt;/li&gt;
&lt;li&gt;The person who signs the submission has never been shown the product. If that name is unfamiliar to the engineering team, the sequencing decisions are being made without the person who carries the risk.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The plan assumes the review happens after the build
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The roadmap has a launch date and a separate, later line for compliance. A build sequenced forwards from features rather than backwards from a submission date tends to discover its gaps when there is no time left to close them.&lt;/li&gt;
&lt;li&gt;Scope was set by what customers asked for, not by what the product will have to demonstrate. Those two lists are rarely the same, and the difference is where version one quietly grows.&lt;/li&gt;
&lt;li&gt;The team expects to handle the review later. Ask what would have to be true for the current build to prove its behaviour for the last six months. If the answer is "nothing can", the timing is the problem.&lt;/li&gt;
&lt;li&gt;Nobody has asked whether the product needs authorisation at all, or which permission covers it. That is a legal question, not an engineering one, and it belongs with a regulatory lawyer or compliance consultant before anyone scopes a build.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A good outcome is unglamorous. The product can show, on request, that a customer only did what the permissions allow, that a past decision can be explained from the record, and that money movements carry their own history. None of that is visible in a demo, which is exactly why it gets deferred.&lt;/p&gt;

&lt;p&gt;If several of these feel familiar, the useful next step is understanding what the review will actually expect the software to prove, and what a build sequenced from that looks like. The full guide on &lt;a href="https://foundry-5.com/solutions/fca-regulated-software-development" rel="noopener noreferrer"&gt;FCA regulated software development&lt;/a&gt; sets out the four things a review expects the product to evidence, the five project types worth declining before the first call, and the week-one review that settles the audit and reconciliation model before any schema work begins.&lt;/p&gt;

</description>
      <category>fintech</category>
      <category>compliance</category>
      <category>architecture</category>
      <category>fca</category>
    </item>
    <item>
      <title>Where Teams Get Custom Software Wrong in London</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Mon, 09 Nov 2026 09:58:45 +0000</pubDate>
      <link>https://dev.to/foundry5/where-teams-get-custom-software-wrong-in-london-oj4</link>
      <guid>https://dev.to/foundry5/where-teams-get-custom-software-wrong-in-london-oj4</guid>
      <description>&lt;p&gt;The most common mistake in custom software is treating it as a purchase rather than a design decision. A team decides off-the-shelf tools no longer fit, goes looking for a builder, compares quotes, and picks one. What they skipped is the harder question: what exactly is this system for, and what will it refuse to do? Everything that goes wrong later tends to trace back to that gap.&lt;/p&gt;

&lt;h2&gt;
  
  
  Believing the tool can absorb your process later
&lt;/h2&gt;

&lt;p&gt;A lot of builds begin with a compromise: the software will handle the standard flow, and the unusual parts stay in spreadsheets for now. That sounds pragmatic. In practice the unusual parts are usually the reason the business exists. The workflows that differ from everyone else's are the competitive advantage, and they are exactly what gets pushed to the edges of the first version. By the time anyone admits the spreadsheet is load-bearing, the architecture has already been shaped around the wrong centre.&lt;/p&gt;

&lt;h2&gt;
  
  
  Confusing a demo with an architecture
&lt;/h2&gt;

&lt;p&gt;A working prototype can look finished. Screens load, data moves, the happy path runs. What it does not show is whether the system has a coherent structure underneath, whether the integrations are documented, or whether the next developer could pick it up. Teams that judge progress by what they can click tend to discover the structural debt months later, when a new feature takes three times as long as it should. The signs are quiet: growing workarounds, a codebase only one person understands, no clear record of why technical choices were made.&lt;/p&gt;

&lt;h2&gt;
  
  
  Leaving ownership vague
&lt;/h2&gt;

&lt;p&gt;Custom software is often described as an asset, but only if you actually hold it. Contracts that keep source code with the vendor, or hand over a repository with no history and no documentation, leave you with a dependency dressed up as a product. This matters most at the point you least want to think about it: changing suppliers, raising investment, or bringing engineering in-house. A clean, documented codebase is what makes those transitions ordinary instead of painful.&lt;/p&gt;

&lt;h2&gt;
  
  
  Assuming scale is someone else's problem
&lt;/h2&gt;

&lt;p&gt;Pricing tiers that look reasonable at fifty users can become absurd at a thousand, and performance that felt fine in testing can collapse under real volume. Teams frequently defer this question because it feels premature. It is not a reason to over-engineer, but it is a reason to be honest about expected load and data growth before the shape of the system is fixed. A good result here is a platform whose cost and speed track your usage, not a vendor's roadmap.&lt;/p&gt;

&lt;h2&gt;
  
  
  What good actually looks like
&lt;/h2&gt;

&lt;p&gt;A sound custom build fits how the business already works, holds its complexity openly rather than hiding it in side tools, and can be handed to another team without archaeology. The people who built it stay reachable after launch, and the documentation explains not just what was built but why. That is a different bar from "it works on demo day", and it is the one worth holding.&lt;/p&gt;

&lt;p&gt;The full guide sets out the practical side this piece deliberately leaves out: how the build is structured from requirements to production, what the standard delivery package includes, and how code ownership and post-launch responsibility are handled. Read it at &lt;a href="https://foundry-5.com/services/custom-build" rel="noopener noreferrer"&gt;custom software development in London&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>customsoftware</category>
      <category>london</category>
      <category>architecture</category>
      <category>productmanagement</category>
    </item>
    <item>
      <title>Why Beautiful Mockups Still Fail Real Users</title>
      <dc:creator>Foundry 5</dc:creator>
      <pubDate>Sun, 08 Nov 2026 07:56:33 +0000</pubDate>
      <link>https://dev.to/foundry5/why-beautiful-mockups-still-fail-real-users-23m7</link>
      <guid>https://dev.to/foundry5/why-beautiful-mockups-still-fail-real-users-23m7</guid>
      <description>&lt;p&gt;A stakeholder opens a design file on a large monitor. The screens are clean, the spacing is generous, the colours are on brand. Everyone nods. The meeting ends with approval and a date for development to start. Three months later, a support inbox fills up with messages from people who cannot complete a password reset on a small phone, or who never noticed the button that moves the whole flow forward.&lt;/p&gt;

&lt;p&gt;Nothing in that story is unusual. It is the default outcome when design is judged by how it looks in a review rather than by how it behaves for someone who has never seen it before.&lt;/p&gt;

&lt;h2&gt;
  
  
  The gap between a mockup and a product
&lt;/h2&gt;

&lt;p&gt;A static screen is a photograph of one moment. A real product is a sequence of states: empty, loading, error, partial data, long text, slow connection, a thumb instead of a cursor. Design files that only show the happy path leave all of that to whoever builds it, and the builder is making guesses about intent under deadline pressure.&lt;/p&gt;

&lt;p&gt;This is where most of the cost hides. A layout problem found in a design file is a conversation. The same problem found after release is a ticket, a branch, a review, a deploy, and often a second conversation about why it happened. The later a decision gets made, the more people it touches and the more expensive it becomes.&lt;/p&gt;

&lt;p&gt;Testing with real users before code exists is the cheapest way to surface those decisions early. Not a focus group, not a survey about preferences, but someone attempting a task while you watch and say nothing. The things people do that surprise you are the design work you still have to do.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why handoff breaks even when the design is good
&lt;/h2&gt;

&lt;p&gt;There is a second failure that has little to do with visual quality. A file can be beautiful and still be unusable as an instruction. If it does not define how a component behaves at different screen widths, what an animation feels like, or what happens when a list is empty, the developer fills the gap with a reasonable assumption. Multiply that by every screen and you get a product that resembles the design without matching it.&lt;/p&gt;

&lt;p&gt;Both sides usually end up frustrated, and neither is at fault. The designer believed the intent was obvious. The developer believed they were being asked to invent things nobody had decided. The fix is not more meetings; it is design artefacts that carry the decisions with them, so the file answers the question before it is asked.&lt;/p&gt;

&lt;p&gt;Consistency is the quieter casualty. Without shared tokens and reusable components, each screen gets solved from scratch, and the product starts to feel like several apps stitched together. Users rarely name this, but they feel it as friction and, over time, as a reason not to trust the product.&lt;/p&gt;

&lt;h2&gt;
  
  
  What good looks like from the outside
&lt;/h2&gt;

&lt;p&gt;A well-run design process is not visibly dramatic. Users complete tasks without asking for help. The interface behaves the same way in the places it should. Edge cases were considered before anyone wrote a line of code. Developers build against specs rather than screenshots, and the result in production looks like the thing that was approved.&lt;/p&gt;

&lt;p&gt;None of this requires a bigger team or a longer timeline. It requires deciding that the design is finished when it has been tested and specified, not when it has been approved. That shift in definition is most of the work.&lt;/p&gt;

&lt;p&gt;The full guide on &lt;a href="https://foundry-5.com/services/ux-ui-design" rel="noopener noreferrer"&gt;UX/UI design services in London&lt;/a&gt; sets out the research, testing and handoff methods this piece deliberately leaves out, including how a design system is structured and what a complete handoff actually contains.&lt;/p&gt;

</description>
      <category>uxdesign</category>
      <category>uidesign</category>
      <category>productdesign</category>
      <category>designsystems</category>
    </item>
  </channel>
</rss>
