<?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: Adejuwon Oshadipe</title>
    <description>The latest articles on DEV Community by Adejuwon Oshadipe (@bezzy_j).</description>
    <link>https://dev.to/bezzy_j</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%2F329294%2Ff713319b-881b-4feb-9461-3b161ae8489a.jpg</url>
      <title>DEV Community: Adejuwon Oshadipe</title>
      <link>https://dev.to/bezzy_j</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/bezzy_j"/>
    <language>en</language>
    <item>
      <title># Things I Wish I Knew 5 Years Ago as a Frontend Engineer</title>
      <dc:creator>Adejuwon Oshadipe</dc:creator>
      <pubDate>Thu, 05 Nov 2026 17:09:10 +0000</pubDate>
      <link>https://dev.to/bezzy_j/-things-i-wish-i-knew-5-years-ago-as-a-frontend-engineer-1cl3</link>
      <guid>https://dev.to/bezzy_j/-things-i-wish-i-knew-5-years-ago-as-a-frontend-engineer-1cl3</guid>
      <description>&lt;p&gt;When I started my journey as a frontend engineer, I believed becoming better at my craft meant learning more frameworks, writing cleaner code, and building interfaces faster.&lt;/p&gt;

&lt;p&gt;If I could take a Figma design, turn it into a responsive interface, integrate the APIs, and get everything working as expected, I considered that a job well done.&lt;/p&gt;

&lt;p&gt;And to be fair, it was.&lt;/p&gt;

&lt;p&gt;But over six years of building production applications across different industries, particularly fintech and edtech, I've come to understand that there's much more to frontend engineering than writing code that works.&lt;/p&gt;

&lt;p&gt;I've worked on applications that started small and became increasingly complex. I've dealt with difficult bugs, changing product requirements, technical decisions that didn't age well, and features that required more thought than I initially expected.&lt;/p&gt;

&lt;p&gt;Some lessons came from making mistakes. Others came from working with different teams, learning from more experienced engineers, and seeing how software behaves in production.&lt;/p&gt;

&lt;p&gt;Looking back, there are a few things I wish I'd understood earlier.&lt;/p&gt;

&lt;p&gt;Here are ten of them.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. Understanding JavaScript Will Take You Further Than Chasing Frameworks
&lt;/h2&gt;

&lt;p&gt;Early in my career, I was always interested in learning the next framework or library.&lt;/p&gt;

&lt;p&gt;There was always something new to explore, and it sometimes felt like keeping up with the ecosystem was the only way to stay relevant.&lt;/p&gt;

&lt;p&gt;But the more I worked with Vue, Nuxt, and other frontend technologies, the more I realised that a solid understanding of JavaScript was far more valuable than knowing the syntax of several frameworks.&lt;/p&gt;

&lt;p&gt;Understanding closures, promises, asynchronous operations, the event loop, and how JavaScript handles objects and references has helped me solve problems that framework knowledge alone couldn't explain.&lt;/p&gt;

&lt;p&gt;For example, knowing how asynchronous operations behave makes it easier to understand race conditions, unexpected state updates, and why a component might display outdated data.&lt;/p&gt;

&lt;p&gt;Frameworks provide convenient ways to build applications, but the fundamentals explain what's happening underneath.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What I'd tell myself five years ago:&lt;/strong&gt; Learn your framework, but invest just as much effort in understanding JavaScript and how the browser works.&lt;/p&gt;




&lt;h2&gt;
  
  
  2. Getting a Feature to Work Doesn't Mean It's Finished
&lt;/h2&gt;

&lt;p&gt;Earlier in my career, I was mostly concerned with getting features to work.&lt;/p&gt;

&lt;p&gt;If the API returned the expected response, the form submitted successfully, and the UI matched the design, I felt the task was complete.&lt;/p&gt;

&lt;p&gt;Production experience changed that perspective.&lt;/p&gt;

&lt;p&gt;Today, I find myself asking questions like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happens when the API fails?&lt;/li&gt;
&lt;li&gt;What if the user submits the form twice?&lt;/li&gt;
&lt;li&gt;What happens when the response is delayed?&lt;/li&gt;
&lt;li&gt;What if the data is incomplete?&lt;/li&gt;
&lt;li&gt;How easy will it be for another engineer to modify this feature?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are the situations that often separate a feature that works during development from one that works reliably in production.&lt;/p&gt;

&lt;p&gt;I've learned to think beyond the happy path and consider how the application should behave when things don't go as planned.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; A feature isn't truly complete simply because it works under ideal conditions. It should also handle unexpected situations gracefully.&lt;/p&gt;




&lt;h2&gt;
  
  
  3. Understanding the Product Makes You a Better Engineer
&lt;/h2&gt;

&lt;p&gt;This is probably one of the biggest changes in how I approach my work.&lt;/p&gt;

&lt;p&gt;When I was starting out, I focused heavily on implementation.&lt;/p&gt;

&lt;p&gt;I'd receive a ticket, review the design, integrate the API, and move on to the next task.&lt;/p&gt;

&lt;p&gt;Over time, I started paying more attention to the problem behind the ticket.&lt;/p&gt;

&lt;p&gt;Why are we building this feature?&lt;/p&gt;

&lt;p&gt;What problem does it solve?&lt;/p&gt;

&lt;p&gt;How does it improve the user's experience?&lt;/p&gt;

&lt;p&gt;And how does it contribute to the business?&lt;/p&gt;

&lt;p&gt;Working on fintech products has made this particularly important.&lt;/p&gt;

&lt;p&gt;For example, building a transfer flow isn't simply about collecting an amount, selecting a beneficiary, and calling an API.&lt;/p&gt;

&lt;p&gt;You also need to think about how users understand transaction statuses, what happens when a transfer is delayed, and how the interface communicates errors without creating unnecessary confusion.&lt;/p&gt;

&lt;p&gt;The technical implementation matters, but understanding the product helps you make better decisions about that implementation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Don't just focus on delivering features. Understand the problem you're solving and why it matters.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Simple Code Is Often Better Than Clever Code
&lt;/h2&gt;

&lt;p&gt;There was a time when I thought writing sophisticated code was a sign of being a better engineer.&lt;/p&gt;

&lt;p&gt;More abstractions, reusable utilities, design patterns, and layers of separation seemed like good architecture.&lt;/p&gt;

&lt;p&gt;But working on larger applications has taught me that complexity comes with a cost.&lt;/p&gt;

&lt;p&gt;I've encountered situations where a relatively simple feature became difficult to understand because the implementation had too many moving parts.&lt;/p&gt;

&lt;p&gt;Sometimes, a straightforward function is all you need.&lt;/p&gt;

&lt;p&gt;Sometimes, local component state is better than introducing another Pinia store.&lt;/p&gt;

&lt;p&gt;And sometimes, having two focused components is more maintainable than creating one highly configurable component that tries to handle every possible use case.&lt;/p&gt;

&lt;p&gt;This doesn't mean abstraction or reusability is bad.&lt;/p&gt;

&lt;p&gt;It means we should introduce them when they solve a real problem.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Good engineering isn't about how complicated your solution looks. It's about how clearly it solves the problem and how easy it is to maintain.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Debugging Is a Skill You Have to Develop Deliberately
&lt;/h2&gt;

&lt;p&gt;I can remember times when my first response to a bug was to start changing code.&lt;/p&gt;

&lt;p&gt;I'd try a different condition, move some logic around, add a console log, and hope the issue disappeared.&lt;/p&gt;

&lt;p&gt;Sometimes it worked, but it wasn't an effective way to solve problems consistently.&lt;/p&gt;

&lt;p&gt;Over the years, I've become more deliberate about debugging.&lt;/p&gt;

&lt;p&gt;Before making changes, I try to understand what is happening.&lt;/p&gt;

&lt;p&gt;What should the application be doing?&lt;/p&gt;

&lt;p&gt;What is it actually doing?&lt;/p&gt;

&lt;p&gt;Can I reproduce the issue?&lt;/p&gt;

&lt;p&gt;Where does the behaviour begin to differ from what I expect?&lt;/p&gt;

&lt;p&gt;Is the problem coming from the frontend, the API response, or an incorrect assumption?&lt;/p&gt;

&lt;p&gt;This approach has been particularly useful when dealing with Vue reactivity, asynchronous operations, complex forms, and API integrations.&lt;/p&gt;

&lt;p&gt;I've also learned to make better use of browser DevTools, Vue Devtools, network inspection, and automated tests.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Understanding why something is broken is often more valuable than quickly finding a way to make the error disappear.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. Performance Should Be Considered From the Beginning
&lt;/h2&gt;

&lt;p&gt;Performance used to feel like something you worked on after completing a feature.&lt;/p&gt;

&lt;p&gt;Build it first, then optimise it later.&lt;/p&gt;

&lt;p&gt;While I still believe premature optimisation can create unnecessary complexity, I've learned that performance problems often come from decisions made much earlier.&lt;/p&gt;

&lt;p&gt;Unnecessary API requests, large JavaScript bundles, poorly managed reactive state, and unoptimized assets can gradually affect the user experience.&lt;/p&gt;

&lt;p&gt;In Vue and Nuxt applications, I've become more conscious of things like component rendering, lazy loading, API request patterns, and how data is fetched and shared across pages.&lt;/p&gt;

&lt;p&gt;The goal isn't to optimise everything.&lt;/p&gt;

&lt;p&gt;It's to understand the potential cost of technical decisions and measure performance where it matters.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Performance isn't something you simply add at the end. It should influence how you design and build features.&lt;/p&gt;




&lt;h2&gt;
  
  
  7. Communication Is Just as Important as Technical Ability
&lt;/h2&gt;

&lt;p&gt;One thing I've learned from working with different teams is that being technically good doesn't automatically make you effective.&lt;/p&gt;

&lt;p&gt;You also need to communicate clearly.&lt;/p&gt;

&lt;p&gt;That means knowing when to ask questions, explain technical decisions, raise concerns, and communicate blockers before they become bigger problems.&lt;/p&gt;

&lt;p&gt;It also means being able to discuss technical trade-offs with product managers, designers, and other stakeholders who may not have the same technical background.&lt;/p&gt;

&lt;p&gt;I've come to appreciate that good communication reduces misunderstandings and helps teams make better decisions.&lt;/p&gt;

&lt;p&gt;And sometimes, asking the right question early can save hours of unnecessary implementation.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Your ability to communicate your thinking is part of your value as an engineer.&lt;/p&gt;




&lt;h2&gt;
  
  
  8. Document Your Work and the Impact It Creates
&lt;/h2&gt;

&lt;p&gt;This is something I genuinely wish I'd started doing much earlier.&lt;/p&gt;

&lt;p&gt;As engineers, we often move from one task to another without taking time to reflect on what we've accomplished.&lt;/p&gt;

&lt;p&gt;You build a dashboard, improve a user flow, fix a difficult bug, or introduce a reusable component.&lt;/p&gt;

&lt;p&gt;Then you move on.&lt;/p&gt;

&lt;p&gt;Months later, when you're updating your CV or preparing for an interview, you struggle to remember the details.&lt;/p&gt;

&lt;p&gt;I've learned that it's important to document not just what you built, but why you built it and what changed as a result.&lt;/p&gt;

&lt;p&gt;For example, instead of simply writing:&lt;/p&gt;

&lt;p&gt;"Built a new onboarding flow."&lt;/p&gt;

&lt;p&gt;It's more useful to explain the problem with the previous experience, the changes you introduced, and any improvements you were able to measure.&lt;/p&gt;

&lt;p&gt;Not every contribution will have a percentage attached to it, and that's fine.&lt;/p&gt;

&lt;p&gt;But being able to explain the reasoning and impact behind your work makes your experience much easier to communicate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Don't wait until you're applying for a job before trying to remember everything you've accomplished.&lt;/p&gt;




&lt;h2&gt;
  
  
  9. AI Can Make You Faster, but You Still Need to Think
&lt;/h2&gt;

&lt;p&gt;AI-assisted development has become a significant part of modern software engineering.&lt;/p&gt;

&lt;p&gt;Today, we can use AI tools to explore implementation approaches, generate tests, review code, understand unfamiliar systems, and speed up repetitive tasks.&lt;/p&gt;

&lt;p&gt;I've found these tools useful, particularly when exploring unfamiliar technologies or working through complex problems.&lt;/p&gt;

&lt;p&gt;But I've also learned that generating code quickly isn't the same as solving a problem correctly.&lt;/p&gt;

&lt;p&gt;AI can suggest an implementation that looks reasonable but doesn't account for your application's architecture, business requirements, or edge cases.&lt;/p&gt;

&lt;p&gt;That's why understanding what you're building remains important.&lt;/p&gt;

&lt;p&gt;You still need to review the output, question assumptions, test the implementation, and take responsibility for what eventually reaches production.&lt;/p&gt;

&lt;p&gt;I see AI as something that should improve my productivity and engineering judgment, not replace them.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Use AI to work more effectively, but don't outsource your understanding of the problem.&lt;/p&gt;




&lt;h2&gt;
  
  
  10. Be Intentional About Your Career Growth
&lt;/h2&gt;

&lt;p&gt;For a long time, I believed that if I continued improving technically and delivering good work, career growth would naturally follow.&lt;/p&gt;

&lt;p&gt;I've since realised that becoming a better engineer and building a meaningful career require different kinds of effort.&lt;/p&gt;

&lt;p&gt;Technical ability matters, but so does how you position yourself, the problems you choose to work on, and the relationships you build along the way.&lt;/p&gt;

&lt;p&gt;You also need to think about what you want to be known for.&lt;/p&gt;

&lt;p&gt;For me, that has meant becoming more intentional about sharing what I've learned from building production applications, writing technical articles, participating in developer communities, and developing a deeper understanding of software architecture.&lt;/p&gt;

&lt;p&gt;It's also one of the reasons I started sharing my Vue Nuggets series.&lt;/p&gt;

&lt;p&gt;I wanted to do more than simply consume knowledge. I wanted to document what I've learned, contribute to conversations within the developer community, and hopefully help someone avoid mistakes I've made.&lt;/p&gt;

&lt;p&gt;I'm still learning how to do that consistently.&lt;/p&gt;

&lt;p&gt;But I wish I'd started earlier.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The lesson:&lt;/strong&gt; Don't leave your career growth entirely to chance. Be deliberate about the skills you develop, the work you do, and how you communicate your value.&lt;/p&gt;




&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Looking back over the past six years, I can confidently say that my understanding of frontend engineering has changed.&lt;/p&gt;

&lt;p&gt;I still enjoy building interfaces, solving technical problems, and exploring new technologies.&lt;/p&gt;

&lt;p&gt;But I now spend more time thinking about the bigger picture.&lt;/p&gt;

&lt;p&gt;How does this feature affect the user?&lt;/p&gt;

&lt;p&gt;Will this implementation be easy to maintain?&lt;/p&gt;

&lt;p&gt;What happens when something goes wrong?&lt;/p&gt;

&lt;p&gt;Are we solving the right problem?&lt;/p&gt;

&lt;p&gt;And how can I make the work easier for the next engineer who touches this code?&lt;/p&gt;

&lt;p&gt;I don't have all the answers, and I don't expect to.&lt;/p&gt;

&lt;p&gt;There are still things I'm learning, decisions I would approach differently, and areas where I want to improve.&lt;/p&gt;

&lt;p&gt;But if there's one thing these years have taught me, it's that growth in software engineering goes beyond becoming better at writing code.&lt;/p&gt;

&lt;p&gt;It's about developing better judgment, understanding the impact of your work, and learning to approach problems with more clarity and intention.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;If I could go back five years, I'd tell myself this:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Don't focus only on becoming an engineer who can build anything. Work towards becoming an engineer who understands what is worth building, why it matters, and how to build it well.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;And if you've been in frontend engineering for a while, I'd love to know:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What's one thing you wish you'd understood earlier in your career?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>career</category>
      <category>frontend</category>
      <category>webdev</category>
      <category>programming</category>
    </item>
    <item>
      <title>7 Frontend Architecture Mistakes That Hurt Teams as Applications Grow</title>
      <dc:creator>Adejuwon Oshadipe</dc:creator>
      <pubDate>Tue, 22 Sep 2026 14:10:02 +0000</pubDate>
      <link>https://dev.to/bezzy_j/7-frontend-architecture-mistakes-that-hurt-teams-as-applications-grow-638</link>
      <guid>https://dev.to/bezzy_j/7-frontend-architecture-mistakes-that-hurt-teams-as-applications-grow-638</guid>
      <description>&lt;h2&gt;
  
  
  7 Frontend Architecture Mistakes That Hurt Teams as Applications Grow
&lt;/h2&gt;

&lt;p&gt;Most frontend architecture problems don't look like problems at first.&lt;/p&gt;

&lt;p&gt;The application works. Features ship. The team moves quickly.&lt;/p&gt;

&lt;p&gt;Then the product grows.&lt;/p&gt;

&lt;p&gt;More developers join. Business logic becomes more complicated. Components become interconnected, and changes that once took hours start taking days because nobody is completely sure what else they might break.&lt;/p&gt;

&lt;p&gt;That's when architecture starts to matter.&lt;/p&gt;

&lt;p&gt;One thing production frontend work has taught me is that scalability isn't only about performance.&lt;/p&gt;

&lt;p&gt;It's also about &lt;strong&gt;how easily a team can continue changing an application as it grows.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Here are seven mistakes that make that increasingly difficult.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. Putting Too Much Business Logic Inside Components
&lt;/h2&gt;

&lt;p&gt;Components often start simple and gradually become responsible for everything:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Rendering UI&lt;/li&gt;
&lt;li&gt;Fetching data&lt;/li&gt;
&lt;li&gt;Validation&lt;/li&gt;
&lt;li&gt;Business rules&lt;/li&gt;
&lt;li&gt;Error handling&lt;/li&gt;
&lt;li&gt;Navigation&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Consider a transfer form.&lt;/p&gt;

&lt;p&gt;It might begin as a few inputs but eventually handle balance validation, transaction limits, fees, currency formatting, API calls, errors, and successful transaction behaviour.&lt;/p&gt;

&lt;p&gt;Now that logic is tightly coupled to one interface.&lt;/p&gt;

&lt;p&gt;A better separation might be:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;useTransfer()&lt;/code&gt; → reusable behavior&lt;/p&gt;

&lt;p&gt;&lt;code&gt;transferService&lt;/code&gt; → API communication&lt;/p&gt;

&lt;p&gt;&lt;code&gt;TransferForm.vue&lt;/code&gt; → UI and user interaction&lt;/p&gt;

&lt;p&gt;Not every function needs its own abstraction. The important question is whether the logic belongs specifically to that UI.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Components should primarily describe interfaces. Give reusable business logic somewhere else to live.&lt;/p&gt;




&lt;h2&gt;
  
  
  2. Making Everything Global State
&lt;/h2&gt;

&lt;p&gt;Pinia makes global state easy.&lt;/p&gt;

&lt;p&gt;That doesn't mean everything belongs there.&lt;/p&gt;

&lt;p&gt;I've seen applications store everything globally—from authenticated users and wallet balances to modal visibility and temporary form values.&lt;/p&gt;

&lt;p&gt;The result is a state layer that becomes increasingly difficult to understand.&lt;/p&gt;

&lt;p&gt;Instead, ask:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who actually needs this state?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If one component needs it, keep it local.&lt;/p&gt;

&lt;p&gt;If a component tree needs it, keep it close to that tree.&lt;/p&gt;

&lt;p&gt;If unrelated parts of the application genuinely need it, then global state makes sense.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;const isModalOpen = ref(false)&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;probably doesn't need to live beside your authentication state.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Keep state as close as possible to whoever owns it.&lt;/p&gt;




&lt;h2&gt;
  
  
  3. Building Giant "Reusable" Components
&lt;/h2&gt;

&lt;p&gt;Reusability can become a trap.&lt;/p&gt;

&lt;p&gt;You start with a reusable table.&lt;/p&gt;

&lt;p&gt;Then you add:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Pagination&lt;/li&gt;
&lt;li&gt;Selection&lt;/li&gt;
&lt;li&gt;Editing&lt;/li&gt;
&lt;li&gt;Search&lt;/li&gt;
&lt;li&gt;Actions&lt;/li&gt;
&lt;li&gt;Custom headers&lt;/li&gt;
&lt;li&gt;Loading states&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Eventually:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;&amp;lt;AppTable :selectable :editable :paginated :searchable :show-actions ... /&amp;gt;&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;You now have a component with 20 props, numerous events, and conditional behaviour everywhere.&lt;/p&gt;

&lt;p&gt;Technically reusable.&lt;/p&gt;

&lt;p&gt;Practically difficult to maintain.&lt;/p&gt;

&lt;p&gt;Composition often scales better.&lt;/p&gt;

&lt;p&gt;Instead of making one component understand every scenario, build smaller primitives that can work together:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;Table&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;TableRow&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;Pagination&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;EmptyState&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Don't measure reusability by how many scenarios one component supports. Measure it by how easily your abstractions can be combined.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Mixing Server State With UI State
&lt;/h2&gt;

&lt;p&gt;Not all state represents the same kind of truth.&lt;/p&gt;

&lt;p&gt;Consider a transaction page.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Server state:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Wallet balance&lt;/li&gt;
&lt;li&gt;Transactions&lt;/li&gt;
&lt;li&gt;Beneficiaries&lt;/li&gt;
&lt;li&gt;Transfer limits&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;UI state:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Selected tab&lt;/li&gt;
&lt;li&gt;Open modal&lt;/li&gt;
&lt;li&gt;Search query&lt;/li&gt;
&lt;li&gt;Current form step&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Server state has concerns like fetching, caching, synchronisation, staleness, and refetching.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;isConfirmationModalOpen&lt;/code&gt; doesn't.&lt;/p&gt;

&lt;p&gt;Keeping these concerns separate makes state transitions much easier to reason about.&lt;/p&gt;

&lt;p&gt;After a successful transfer, for example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The modal closes&lt;/li&gt;
&lt;li&gt;The form resets&lt;/li&gt;
&lt;li&gt;The wallet balance refreshes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Those are three different state transitions with different lifecycles.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Understand where your state comes from before deciding how to manage it.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Organising Code Without Considering How the Product Grows
&lt;/h2&gt;

&lt;p&gt;Most Vue/Nuxt applications start with:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;components/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;composables/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;stores/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;services/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;types/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;That can work perfectly well.&lt;/p&gt;

&lt;p&gt;But as applications grow, a single feature may become scattered across all five directories.&lt;/p&gt;

&lt;p&gt;For larger products, grouping related code by domain can sometimes make navigation easier:&lt;/p&gt;

&lt;p&gt;&lt;code&gt;features/transfers/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;features/wallets/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;&lt;code&gt;features/transactions/&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;Each feature can contain the components, composables, services, and types that belong to it, while genuinely shared code remains elsewhere.&lt;/p&gt;

&lt;p&gt;There's no universally correct folder structure.&lt;/p&gt;

&lt;p&gt;The question is:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does your structure reflect how your team actually changes the product?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Optimize architecture for change, not for having the prettiest folder tree.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. Abstracting Too Early
&lt;/h2&gt;

&lt;p&gt;Frontend architecture can also become &lt;em&gt;too&lt;/em&gt; sophisticated.&lt;/p&gt;

&lt;p&gt;A simple request suddenly becomes:&lt;/p&gt;

&lt;p&gt;Component → composable → repository → service → adapter → HTTP client.&lt;/p&gt;

&lt;p&gt;For one endpoint.&lt;/p&gt;

&lt;p&gt;Abstraction is valuable when it hides meaningful complexity or creates useful reuse.&lt;/p&gt;

&lt;p&gt;Otherwise, you've simply replaced simple code with more code.&lt;/p&gt;

&lt;p&gt;Before adding another layer, ask:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is this repeated?&lt;/li&gt;
&lt;li&gt;Does it create a meaningful boundary?&lt;/li&gt;
&lt;li&gt;Will it change independently?&lt;/li&gt;
&lt;li&gt;Does it make the calling code easier to understand?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If not, you may not need the abstraction yet.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Let complexity earn its abstractions.&lt;/p&gt;




&lt;h2&gt;
  
  
  7. Ignoring Developer Experience
&lt;/h2&gt;

&lt;p&gt;Architecture isn't only about code.&lt;/p&gt;

&lt;p&gt;It's about &lt;strong&gt;people changing code&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Warning signs include developers regularly asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Where should this logic go?"&lt;/p&gt;

&lt;p&gt;"Why do we have three ways of fetching data?"&lt;/p&gt;

&lt;p&gt;"Which component am I supposed to use?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Good architecture reduces these repeated decisions.&lt;/p&gt;

&lt;p&gt;Teams benefit from shared conventions around:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;State ownership&lt;/li&gt;
&lt;li&gt;Component boundaries&lt;/li&gt;
&lt;li&gt;API communication&lt;/li&gt;
&lt;li&gt;Error handling&lt;/li&gt;
&lt;li&gt;Naming&lt;/li&gt;
&lt;li&gt;Testing&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;They don't need to be rigid rules.&lt;/p&gt;

&lt;p&gt;But there should be a clear default.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Takeaway:&lt;/strong&gt; Good architecture should reduce cognitive load for the team, not increase it.&lt;/p&gt;




&lt;h2&gt;
  
  
  Architecture Is About the Cost of Change
&lt;/h2&gt;

&lt;p&gt;Almost any architecture works when an application is small.&lt;/p&gt;

&lt;p&gt;The real test comes later.&lt;/p&gt;

&lt;p&gt;What happens when five engineers need to work on related features?&lt;/p&gt;

&lt;p&gt;What happens when a requirement contradicts an assumption made two years ago?&lt;/p&gt;

&lt;p&gt;What happens when the engineer who originally built a feature leaves?&lt;/p&gt;

&lt;p&gt;Good architecture doesn't remove complexity.&lt;/p&gt;

&lt;p&gt;It puts complexity somewhere the team can understand and manage.&lt;/p&gt;

&lt;p&gt;That's why I've gradually started thinking about frontend architecture less in terms of folder structures and design patterns and more in terms of one question:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;How expensive will the next change be?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If every new feature makes the next feature harder to build, the architecture is working against the team.&lt;/p&gt;

&lt;p&gt;If developers can understand ownership, make changes confidently, and extend the system without constantly breaking unrelated functionality, the architecture is doing its job.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Good frontend architecture makes change predictable.&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>webdev</category>
      <category>frontend</category>
      <category>architecture</category>
      <category>programming</category>
    </item>
    <item>
      <title>How We Structured a Large Vue/Nuxt Application Without Losing Our Sanity</title>
      <dc:creator>Adejuwon Oshadipe</dc:creator>
      <pubDate>Fri, 07 Aug 2026 10:06:37 +0000</pubDate>
      <link>https://dev.to/bezzy_j/how-we-structured-a-large-vuenuxt-application-without-losing-our-sanity-56oa</link>
      <guid>https://dev.to/bezzy_j/how-we-structured-a-large-vuenuxt-application-without-losing-our-sanity-56oa</guid>
      <description>&lt;p&gt;Every Vue application starts the same way.&lt;/p&gt;

&lt;p&gt;A few pages.&lt;/p&gt;

&lt;p&gt;A handful of components.&lt;/p&gt;

&lt;p&gt;One or two API calls.&lt;/p&gt;

&lt;p&gt;Everything feels simple.&lt;/p&gt;

&lt;p&gt;Then the product grows.&lt;/p&gt;

&lt;p&gt;New features are added.&lt;/p&gt;

&lt;p&gt;More engineers join the team.&lt;/p&gt;

&lt;p&gt;Business requirements evolve.&lt;/p&gt;

&lt;p&gt;Before long, you're working with hundreds of components, dozens of API endpoints, multiple user roles, and features that all depend on one another.&lt;/p&gt;

&lt;p&gt;At that point, the biggest challenge is no longer writing Vue.&lt;/p&gt;

&lt;p&gt;It's &lt;strong&gt;managing complexity.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Over the last few years building production applications with Vue and Nuxt—particularly in fintech products—I've learned that architecture decisions made early can either accelerate a team or slow it down for years.&lt;/p&gt;

&lt;p&gt;Here are some of the principles that have helped us keep growing applications maintainable.&lt;/p&gt;




&lt;h1&gt;
  
  
  The Framework Was Never the Problem
&lt;/h1&gt;

&lt;p&gt;One lesson I've learned is that Vue rarely becomes the bottleneck.&lt;/p&gt;

&lt;p&gt;Developers do.&lt;/p&gt;

&lt;p&gt;Vue is intentionally flexible.&lt;/p&gt;

&lt;p&gt;There are multiple ways to solve almost every problem.&lt;/p&gt;

&lt;p&gt;That flexibility is one of its biggest strengths.&lt;/p&gt;

&lt;p&gt;But without agreed conventions, every engineer naturally solves similar problems differently.&lt;/p&gt;

&lt;p&gt;One page fetches data inside the component.&lt;/p&gt;

&lt;p&gt;Another uses a composable.&lt;/p&gt;

&lt;p&gt;A third talks directly to the store.&lt;/p&gt;

&lt;p&gt;Everything works...&lt;/p&gt;

&lt;p&gt;Until six months later when nobody remembers why things are different.&lt;/p&gt;

&lt;p&gt;Scaling a Vue application isn't about choosing the perfect framework.&lt;/p&gt;

&lt;p&gt;It's about reducing unnecessary decisions.&lt;/p&gt;




&lt;h1&gt;
  
  
  We Started Organising Around Features, Not File Types
&lt;/h1&gt;

&lt;p&gt;Early in my career, I organised projects the way many tutorials teach.&lt;/p&gt;

&lt;p&gt;Everything lived inside folders like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Components&lt;/li&gt;
&lt;li&gt;Views&lt;/li&gt;
&lt;li&gt;Utils&lt;/li&gt;
&lt;li&gt;Services&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It worked.&lt;/p&gt;

&lt;p&gt;Until the project became large.&lt;/p&gt;

&lt;p&gt;Finding everything related to one feature meant jumping between five or six folders.&lt;/p&gt;

&lt;p&gt;When working on financial products, we shifted our thinking.&lt;/p&gt;

&lt;p&gt;Instead of organising code around &lt;em&gt;what it was&lt;/em&gt;, we started organising it around &lt;em&gt;what it did&lt;/em&gt;.&lt;/p&gt;

&lt;p&gt;Instead of thinking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Where should this component live?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;We started asking:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Which business feature owns this?"&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That single mindset shift changed how we navigated the codebase.&lt;/p&gt;




&lt;h1&gt;
  
  
  A Real Example: Wallets, Transfers and Transactions
&lt;/h1&gt;

&lt;p&gt;One of the products I worked on included several closely related financial features:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Wallet management&lt;/li&gt;
&lt;li&gt;Money transfers&lt;/li&gt;
&lt;li&gt;Transaction history&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;At first glance, they seem like one feature.&lt;/p&gt;

&lt;p&gt;They're not.&lt;/p&gt;

&lt;p&gt;Each has its own responsibilities.&lt;/p&gt;

&lt;p&gt;The wallet is responsible for balances, funding methods and available accounts.&lt;/p&gt;

&lt;p&gt;Transfers focus on initiating movement of funds, validation, recipients and confirmation.&lt;/p&gt;

&lt;p&gt;Transactions are historical records, filtering, pagination and status tracking.&lt;/p&gt;

&lt;p&gt;Early versions of the application had logic scattered across shared folders.&lt;/p&gt;

&lt;p&gt;Wallet components referenced transfer utilities.&lt;/p&gt;

&lt;p&gt;Transfer pages duplicated transaction formatting.&lt;/p&gt;

&lt;p&gt;Several components were making similar API calls in slightly different ways.&lt;/p&gt;

&lt;p&gt;Nothing was technically broken.&lt;/p&gt;

&lt;p&gt;But the codebase was becoming harder to understand.&lt;/p&gt;

&lt;p&gt;So we reorganised the application around business domains instead.&lt;/p&gt;

&lt;p&gt;Each feature owned:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Its components&lt;/li&gt;
&lt;li&gt;Its composables&lt;/li&gt;
&lt;li&gt;Its API layer&lt;/li&gt;
&lt;li&gt;Its types&lt;/li&gt;
&lt;li&gt;Its tests&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Instead of a developer searching the entire project to understand how transfers worked, almost everything related to transfers lived together.&lt;/p&gt;

&lt;p&gt;The result wasn't fewer lines of code.&lt;/p&gt;

&lt;p&gt;The result was less cognitive load.&lt;/p&gt;

&lt;p&gt;New engineers could understand features much faster because the project reflected how the business actually worked.&lt;/p&gt;

&lt;p&gt;That experience completely changed how I think about frontend architecture.&lt;/p&gt;




&lt;h1&gt;
  
  
  Components Should Render Interfaces
&lt;/h1&gt;

&lt;p&gt;One mistake I've made—and reviewed many times—is allowing components to become responsible for everything.&lt;/p&gt;

&lt;p&gt;Fetching data.&lt;/p&gt;

&lt;p&gt;Formatting values.&lt;/p&gt;

&lt;p&gt;Opening modals.&lt;/p&gt;

&lt;p&gt;Handling permissions.&lt;/p&gt;

&lt;p&gt;Managing API errors.&lt;/p&gt;

&lt;p&gt;Rendering UI.&lt;/p&gt;

&lt;p&gt;Eventually you end up with components hundreds of lines long.&lt;/p&gt;

&lt;p&gt;Now I ask a much simpler question:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Is this component displaying information, or making business decisions?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If it's making business decisions, that logic probably belongs somewhere else.&lt;/p&gt;

&lt;p&gt;Presentation becomes easier when business logic has a clear home.&lt;/p&gt;




&lt;h1&gt;
  
  
  Composables Became Our Building Blocks
&lt;/h1&gt;

&lt;p&gt;Vue 3's Composition API changed how I think about reusable code.&lt;/p&gt;

&lt;p&gt;Instead of copying logic between pages, we extracted repeated behaviour into composables.&lt;/p&gt;

&lt;p&gt;Things like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Pagination&lt;/li&gt;
&lt;li&gt;Search&lt;/li&gt;
&lt;li&gt;Currency formatting&lt;/li&gt;
&lt;li&gt;Permissions&lt;/li&gt;
&lt;li&gt;Data fetching&lt;/li&gt;
&lt;li&gt;Infinite scrolling&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But one lesson became very important.&lt;/p&gt;

&lt;p&gt;A composable should solve &lt;strong&gt;one problem well&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Once it starts becoming responsible for unrelated concerns, you've simply created another large component—just in a different file.&lt;/p&gt;




&lt;h1&gt;
  
  
  We Became Much More Careful About Global State
&lt;/h1&gt;

&lt;p&gt;One of the easiest mistakes to make in growing applications is putting everything into Pinia.&lt;/p&gt;

&lt;p&gt;Just because multiple components &lt;em&gt;can&lt;/em&gt; access state doesn't mean they should.&lt;/p&gt;

&lt;p&gt;We started asking one question before adding anything to the global store:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Who actually needs this?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If the answer was:&lt;/p&gt;

&lt;p&gt;"Only this page."&lt;/p&gt;

&lt;p&gt;Then it stayed local.&lt;/p&gt;

&lt;p&gt;Global state became reserved for information that genuinely belonged to the entire application:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Authenticated user&lt;/li&gt;
&lt;li&gt;Permissions&lt;/li&gt;
&lt;li&gt;Shared configuration&lt;/li&gt;
&lt;li&gt;Common reference data&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Everything else stayed close to where it was used.&lt;/p&gt;

&lt;p&gt;That one rule significantly reduced unnecessary complexity.&lt;/p&gt;




&lt;h1&gt;
  
  
  Separate Business State From UI State
&lt;/h1&gt;

&lt;p&gt;One subtle improvement that paid dividends was separating business data from interface state.&lt;/p&gt;

&lt;p&gt;Take a transfer page.&lt;/p&gt;

&lt;p&gt;Business state includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Amount&lt;/li&gt;
&lt;li&gt;Currency&lt;/li&gt;
&lt;li&gt;Recipient&lt;/li&gt;
&lt;li&gt;Exchange rate&lt;/li&gt;
&lt;li&gt;Transfer status&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;UI state includes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is the drawer open?&lt;/li&gt;
&lt;li&gt;Which tab is selected?&lt;/li&gt;
&lt;li&gt;Is the confirmation modal visible?&lt;/li&gt;
&lt;li&gt;Is the filter expanded?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;They're both reactive.&lt;/p&gt;

&lt;p&gt;But they represent completely different concerns.&lt;/p&gt;

&lt;p&gt;Keeping them separate made components easier to reason about and far easier to debug.&lt;/p&gt;




&lt;h1&gt;
  
  
  Consistency Beats Cleverness
&lt;/h1&gt;

&lt;p&gt;I've stopped chasing "perfect architecture."&lt;/p&gt;

&lt;p&gt;Instead, I value predictable architecture.&lt;/p&gt;

&lt;p&gt;Developers don't need ten different ways to solve the same problem.&lt;/p&gt;

&lt;p&gt;They need one good approach that everyone understands.&lt;/p&gt;

&lt;p&gt;Consistency speeds up:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Onboarding&lt;/li&gt;
&lt;li&gt;Code reviews&lt;/li&gt;
&lt;li&gt;Debugging&lt;/li&gt;
&lt;li&gt;Feature development&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It's one of the highest-leverage investments a team can make.&lt;/p&gt;




&lt;h1&gt;
  
  
  Architecture Is Really About People
&lt;/h1&gt;

&lt;p&gt;When we hear the word architecture, it's easy to think about diagrams, layers and patterns.&lt;/p&gt;

&lt;p&gt;I've come to think about it differently.&lt;/p&gt;

&lt;p&gt;Architecture is communication.&lt;/p&gt;

&lt;p&gt;Good architecture helps another engineer understand your decisions without asking you.&lt;/p&gt;

&lt;p&gt;It reduces guessing.&lt;/p&gt;

&lt;p&gt;It reduces duplication.&lt;/p&gt;

&lt;p&gt;It makes the next feature easier to build than the previous one.&lt;/p&gt;

&lt;p&gt;That's the real goal.&lt;/p&gt;




&lt;h1&gt;
  
  
  Final Thoughts
&lt;/h1&gt;

&lt;p&gt;One lesson has stayed with me throughout every large Vue project I've worked on.&lt;/p&gt;

&lt;p&gt;Frameworks don't become messy.&lt;/p&gt;

&lt;p&gt;Projects do.&lt;/p&gt;

&lt;p&gt;And projects become messy because every small decision compounds over time.&lt;/p&gt;

&lt;p&gt;Choosing where state belongs.&lt;/p&gt;

&lt;p&gt;Deciding how components communicate.&lt;/p&gt;

&lt;p&gt;Organising features around the business instead of the framework.&lt;/p&gt;

&lt;p&gt;Separating concerns before they become problems.&lt;/p&gt;

&lt;p&gt;None of these decisions feels significant on day one.&lt;/p&gt;

&lt;p&gt;But two years later, they're often the difference between a codebase that enables engineers and one that slows them down.&lt;/p&gt;

&lt;p&gt;For me, scalable frontend engineering isn't about writing more code.&lt;/p&gt;

&lt;p&gt;It's about making sure the next engineer can understand, extend, and improve what you've already built with confidence.&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>frontend</category>
      <category>vue</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Lessons Learned Building Fintech Frontends: Things Nobody Teaches You About Handling Money, State, and User Trust</title>
      <dc:creator>Adejuwon Oshadipe</dc:creator>
      <pubDate>Mon, 15 Jun 2026 06:05:13 +0000</pubDate>
      <link>https://dev.to/bezzy_j/lessons-learned-building-fintech-frontends-things-nobody-teaches-you-about-handling-money-state-27p1</link>
      <guid>https://dev.to/bezzy_j/lessons-learned-building-fintech-frontends-things-nobody-teaches-you-about-handling-money-state-27p1</guid>
      <description>&lt;p&gt;When people think about fintech engineering, they often focus on the backend.&lt;/p&gt;

&lt;p&gt;Payments.&lt;br&gt;
Bank integrations.&lt;br&gt;
Ledgers.&lt;br&gt;
Settlement systems.&lt;/p&gt;

&lt;p&gt;And rightly so—those systems carry enormous responsibility.&lt;/p&gt;

&lt;p&gt;But after spending time building frontend experiences around financial products, I've learned that the frontend carries a different kind of responsibility:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;User trust.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;In many cases, users don't see your backend architecture.&lt;/p&gt;

&lt;p&gt;They don't know about your microservices.&lt;/p&gt;

&lt;p&gt;They don't care about your event-driven infrastructure.&lt;/p&gt;

&lt;p&gt;What they see is the interface.&lt;/p&gt;

&lt;p&gt;And when money is involved, every button, loading state, error message, and transaction status affects confidence.&lt;/p&gt;

&lt;p&gt;Here are some of the most important lessons I've learned while building fintech frontends.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Money Is Different From Every Other Type of Data
&lt;/h2&gt;

&lt;p&gt;In many applications, a small display bug is annoying.&lt;/p&gt;

&lt;p&gt;In fintech, it can be terrifying.&lt;/p&gt;

&lt;p&gt;Imagine seeing:&lt;/p&gt;

&lt;p&gt;₦100,000 become ₦10,000&lt;/p&gt;

&lt;p&gt;or&lt;/p&gt;

&lt;p&gt;$1,000.00 become $999.99&lt;/p&gt;

&lt;p&gt;even temporarily.&lt;/p&gt;

&lt;p&gt;Users immediately assume something is wrong.&lt;/p&gt;

&lt;p&gt;That's why money should never be treated like ordinary numbers.&lt;/p&gt;

&lt;p&gt;Frontend engineers must understand:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Formatting&lt;/li&gt;
&lt;li&gt;Precision&lt;/li&gt;
&lt;li&gt;Decimal handling&lt;/li&gt;
&lt;li&gt;Currency conversion&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A simple rounding mistake can create support tickets and damage trust.&lt;/p&gt;

&lt;p&gt;The lesson:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Treat money as a first-class concern, not a display concern.&lt;/strong&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  2. Loading States Matter More Than You Think
&lt;/h2&gt;

&lt;p&gt;One of the fastest ways to create anxiety is silence.&lt;/p&gt;

&lt;p&gt;Imagine a user clicks "Send Money."&lt;/p&gt;

&lt;p&gt;Nothing happens.&lt;/p&gt;

&lt;p&gt;No spinner.&lt;/p&gt;

&lt;p&gt;No feedback.&lt;/p&gt;

&lt;p&gt;No status update.&lt;/p&gt;

&lt;p&gt;Within seconds, they begin asking:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Did it go through?&lt;/li&gt;
&lt;li&gt;Should I click again?&lt;/li&gt;
&lt;li&gt;Was I charged twice?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Good loading states reduce uncertainty.&lt;/p&gt;

&lt;p&gt;Great loading states communicate progress.&lt;/p&gt;

&lt;p&gt;When dealing with financial transactions, feedback is not just UX.&lt;/p&gt;

&lt;p&gt;It's reassurance.&lt;/p&gt;




&lt;h2&gt;
  
  
  3. Every Transaction Has More States Than You Expect
&lt;/h2&gt;

&lt;p&gt;Many developers think a transaction is either:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Successful&lt;/li&gt;
&lt;li&gt;Failed&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Reality is far more complicated.&lt;/p&gt;

&lt;p&gt;Transactions often move through states like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Pending&lt;/li&gt;
&lt;li&gt;Processing&lt;/li&gt;
&lt;li&gt;Awaiting confirmation&lt;/li&gt;
&lt;li&gt;Successful&lt;/li&gt;
&lt;li&gt;Reversed&lt;/li&gt;
&lt;li&gt;Failed&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Frontend systems must be designed to handle every possibility.&lt;/p&gt;

&lt;p&gt;The worst bugs often happen when we only design for the happy path.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Error Messages Should Build Confidence
&lt;/h2&gt;

&lt;p&gt;Generic errors create frustration.&lt;/p&gt;

&lt;p&gt;Messages like:&lt;/p&gt;

&lt;p&gt;"Something went wrong"&lt;/p&gt;

&lt;p&gt;tell users almost nothing.&lt;/p&gt;

&lt;p&gt;Financial applications should aim for clarity.&lt;/p&gt;

&lt;p&gt;Users need to know:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What happened&lt;/li&gt;
&lt;li&gt;What it means&lt;/li&gt;
&lt;li&gt;What they should do next&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A good error message reduces support requests.&lt;/p&gt;

&lt;p&gt;A great error message preserves trust.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Users Care About Outcomes, Not APIs
&lt;/h2&gt;

&lt;p&gt;As engineers, we often think in requests and responses.&lt;/p&gt;

&lt;p&gt;Users think in goals.&lt;/p&gt;

&lt;p&gt;They don't care that an endpoint returned a 200 status.&lt;/p&gt;

&lt;p&gt;They care that:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The transfer arrived&lt;/li&gt;
&lt;li&gt;The payment succeeded&lt;/li&gt;
&lt;li&gt;The account was funded&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Designing around outcomes rather than technical events creates better user experiences.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. Consistency Builds Trust
&lt;/h2&gt;

&lt;p&gt;One of the most underrated qualities in fintech products is consistency.&lt;/p&gt;

&lt;p&gt;The same action should behave the same way every time.&lt;/p&gt;

&lt;p&gt;The same status should mean the same thing everywhere.&lt;/p&gt;

&lt;p&gt;The same currency should be formatted consistently across the application.&lt;/p&gt;

&lt;p&gt;Inconsistency creates doubt.&lt;/p&gt;

&lt;p&gt;And doubt is expensive in financial products.&lt;/p&gt;




&lt;h2&gt;
  
  
  7. Frontend Engineers Are Trust Engineers
&lt;/h2&gt;

&lt;p&gt;This is probably the biggest lesson I've learned.&lt;/p&gt;

&lt;p&gt;When building financial products, your job is not simply to render data.&lt;/p&gt;

&lt;p&gt;Your job is to help users feel confident about what is happening to their money.&lt;/p&gt;

&lt;p&gt;Every interaction contributes to that feeling.&lt;/p&gt;

&lt;p&gt;Every loading state.&lt;/p&gt;

&lt;p&gt;Every confirmation screen.&lt;/p&gt;

&lt;p&gt;Every receipt.&lt;/p&gt;

&lt;p&gt;Every transaction history page.&lt;/p&gt;

&lt;p&gt;Trust is built through thousands of small decisions.&lt;/p&gt;

&lt;p&gt;And frontend engineers play a much larger role in that than most people realise.&lt;/p&gt;

&lt;h2&gt;
  
  
  Final Thoughts
&lt;/h2&gt;

&lt;p&gt;Building fintech frontends has changed the way I think about software.&lt;/p&gt;

&lt;p&gt;I've learned that technical correctness is only part of the equation.&lt;/p&gt;

&lt;p&gt;A transaction can be perfectly processed by the backend and still create anxiety if the frontend fails to communicate clearly.&lt;/p&gt;

&lt;p&gt;The best financial products don't just move money.&lt;/p&gt;

&lt;p&gt;They help users understand what is happening every step of the way.&lt;/p&gt;

&lt;p&gt;And that responsibility belongs to all of us who build the experiences people interact with every day.&lt;/p&gt;

</description>
      <category>frontend</category>
      <category>ux</category>
      <category>fintech</category>
    </item>
    <item>
      <title>30 Vue Nuggets from Production Experience 💚</title>
      <dc:creator>Adejuwon Oshadipe</dc:creator>
      <pubDate>Wed, 13 May 2026 17:31:17 +0000</pubDate>
      <link>https://dev.to/bezzy_j/30-vue-nuggets-from-production-experience-44lo</link>
      <guid>https://dev.to/bezzy_j/30-vue-nuggets-from-production-experience-44lo</guid>
      <description>&lt;p&gt;Most Vue tutorials teach you how to use Vue.&lt;br&gt;
Very few teach you how Vue behaves in real production systems.&lt;/p&gt;

&lt;p&gt;After working on large-scale frontend applications — especially in fintech products where state, performance, and maintainability matter — I’ve realised that the biggest difference between beginner and senior Vue developers is not syntax.&lt;/p&gt;

&lt;p&gt;It’s how they think about:&lt;/p&gt;

&lt;p&gt;Reactivity&lt;br&gt;
State ownership&lt;br&gt;
Component boundaries&lt;br&gt;
Data flow&lt;br&gt;
Architecture&lt;/p&gt;

&lt;p&gt;So I decided to compile 30 practical Vue nuggets pulled from real-world experience building production applications with Vue and Nuxt.&lt;/p&gt;

&lt;p&gt;Not theory.&lt;br&gt;
Not tutorial fluff.&lt;br&gt;
Just lessons that consistently matter when applications grow.&lt;/p&gt;

&lt;p&gt;🟢 1. ref vs reactive — they solve different problems&lt;/p&gt;

&lt;p&gt;One of the earliest Vue mistakes is using reactive for everything.&lt;/p&gt;

&lt;p&gt;The mental model is simple:&lt;/p&gt;

&lt;p&gt;Use ref for single values&lt;br&gt;
Use reactive for structured objects&lt;/p&gt;

&lt;p&gt;ref exists because primitives cannot be proxied like objects. Understanding this distinction early prevents a lot of confusion later in large applications.&lt;/p&gt;

&lt;p&gt;🟢 2. v-if and v-show are not interchangeable&lt;/p&gt;

&lt;p&gt;They may look similar, but they behave differently.&lt;/p&gt;

&lt;p&gt;v-if creates and destroys DOM nodes&lt;br&gt;
v-show only toggles visibility&lt;/p&gt;

&lt;p&gt;The real question is:&lt;/p&gt;

&lt;p&gt;How often will this element change visibility?&lt;/p&gt;

&lt;p&gt;That answer determines which directive you should use.&lt;/p&gt;

&lt;p&gt;🟢 3. Props are read-only for a reason&lt;/p&gt;

&lt;p&gt;Mutating props breaks predictable data flow.&lt;/p&gt;

&lt;p&gt;Vue’s architecture is intentionally directional:&lt;/p&gt;

&lt;p&gt;Props go down&lt;br&gt;
Events go up&lt;/p&gt;

&lt;p&gt;Once both parent and child can modify the same state, debugging becomes painful.&lt;/p&gt;

&lt;p&gt;🟢 4. computed is about caching, not convenience&lt;/p&gt;

&lt;p&gt;A method recalculates every render.&lt;/p&gt;

&lt;p&gt;A computed property recalculates only when dependencies change.&lt;/p&gt;

&lt;p&gt;In small apps, you won’t notice the difference.&lt;br&gt;
In large systems, you absolutely will.&lt;/p&gt;

&lt;p&gt;🟢 5. key in v-for is about identity&lt;/p&gt;

&lt;p&gt;Vue doesn’t use key to silence warnings.&lt;/p&gt;

&lt;p&gt;It uses a key to track identity.&lt;/p&gt;

&lt;p&gt;Without proper keys:&lt;/p&gt;

&lt;p&gt;DOM reuse becomes incorrect&lt;br&gt;
Component state leaks&lt;br&gt;
Animations break&lt;/p&gt;

&lt;p&gt;Using an index as a key is often a hidden bug waiting to happen.&lt;/p&gt;

&lt;p&gt;🟢 6. Events scale better than passing functions as props&lt;/p&gt;

&lt;p&gt;Passing functions deeply into child components creates coupling.&lt;/p&gt;

&lt;p&gt;Events keep communication directional and predictable.&lt;/p&gt;

&lt;p&gt;A reusable component should communicate intent — not know parent implementation details.&lt;/p&gt;

&lt;p&gt;🟢 7. Most watch usage is unnecessary&lt;/p&gt;

&lt;p&gt;A surprising number of watchers should actually be computed properties.&lt;/p&gt;

&lt;p&gt;Use:&lt;/p&gt;

&lt;p&gt;computed for the derived state&lt;br&gt;
Watch for side effects&lt;/p&gt;

&lt;p&gt;That distinction keeps logic cleaner and easier to reason about.&lt;/p&gt;

&lt;p&gt;🟢 8. Too many props usually means poor component design&lt;/p&gt;

&lt;p&gt;When components need 7–10 props, they’re often doing too much.&lt;/p&gt;

&lt;p&gt;A good component accepts meaningful concepts, not scattered fragments of state.&lt;/p&gt;

&lt;p&gt;🟢 9. Components re-render more than most developers realise&lt;/p&gt;

&lt;p&gt;Every reactive dependency exposed to the template becomes something Vue must track.&lt;/p&gt;

&lt;p&gt;The larger the reactive surface area, the more expensive the rendering becomes.&lt;/p&gt;

&lt;p&gt;Being intentional with reactivity matters.&lt;/p&gt;

&lt;p&gt;🟢 10. Duplicate state creates synchronisation bugs&lt;/p&gt;

&lt;p&gt;If the same state exists:&lt;/p&gt;

&lt;p&gt;In Pinia&lt;br&gt;
In local refs&lt;br&gt;
In props&lt;/p&gt;

&lt;p&gt;…you eventually create inconsistency.&lt;/p&gt;

&lt;p&gt;A strong Vue architecture has a clear source of truth.&lt;/p&gt;

&lt;p&gt;🟢 11. watch vs watchEffect&lt;/p&gt;

&lt;p&gt;The difference is precision.&lt;/p&gt;

&lt;p&gt;Watch tracks explicit dependencies&lt;br&gt;
watchEffect tracks everything accessed during execution&lt;/p&gt;

&lt;p&gt;Convenience is nice. Precision scales better.&lt;/p&gt;

&lt;p&gt;🟢 12. Watchers should be rare&lt;/p&gt;

&lt;p&gt;If a watcher is simply updating another reactive value, it’s often a sign that computed properties were misunderstood.&lt;/p&gt;

&lt;p&gt;Watchers are not state management tools.&lt;/p&gt;

&lt;p&gt;🟢 13. Composables should encapsulate logic, not become hidden stores&lt;/p&gt;

&lt;p&gt;A composable that secretly acts like a global state becomes difficult to reason about.&lt;/p&gt;

&lt;p&gt;Good composables:&lt;/p&gt;

&lt;p&gt;Encapsulate reusable behavior&lt;br&gt;
Expose minimal state&lt;br&gt;
Avoid hidden coupling&lt;br&gt;
🟢 14. Not everything belongs in Pinia&lt;/p&gt;

&lt;p&gt;Global state should hold application-wide concerns:&lt;/p&gt;

&lt;p&gt;Auth&lt;br&gt;
Shared API data&lt;br&gt;
Permissions&lt;/p&gt;

&lt;p&gt;Not:&lt;/p&gt;

&lt;p&gt;Modal visibility&lt;br&gt;
Form input values&lt;br&gt;
Dropdown state&lt;/p&gt;

&lt;p&gt;Local UI state should stay local.&lt;/p&gt;

&lt;p&gt;🟢 15. Dynamic components simplify templates&lt;/p&gt;

&lt;p&gt;Large v-if trees quickly become difficult to maintain.&lt;/p&gt;

&lt;p&gt;Dynamic components help templates stay declarative instead of becoming logic-heavy.&lt;/p&gt;

&lt;p&gt;🟢 16. Slots are a scalability tool&lt;/p&gt;

&lt;p&gt;Slots are not just placeholders.&lt;/p&gt;

&lt;p&gt;They allow structural flexibility without duplicating components.&lt;/p&gt;

&lt;p&gt;This becomes incredibly powerful in design systems and reusable UI libraries.&lt;/p&gt;

&lt;p&gt;🟢 17. Async state needs structure&lt;/p&gt;

&lt;p&gt;Scattered refs like:&lt;/p&gt;

&lt;p&gt;loading&lt;br&gt;
error&lt;br&gt;
data&lt;/p&gt;

&lt;p&gt;across multiple components eventually becomes chaos.&lt;/p&gt;

&lt;p&gt;Treat async state as a single structured concern.&lt;/p&gt;

&lt;p&gt;🟢 18. Prop drilling is often a structural problem&lt;/p&gt;

&lt;p&gt;Passing props through many layers usually means state placement needs reconsideration.&lt;/p&gt;

&lt;p&gt;Composables and provide/inject exist for a reason.&lt;/p&gt;

&lt;p&gt;🟢 19. Folder structure influences architecture&lt;/p&gt;

&lt;p&gt;When everything lives in components/, architecture eventually degrades.&lt;/p&gt;

&lt;p&gt;Good structure encourages separation of concerns:&lt;/p&gt;

&lt;p&gt;Components&lt;br&gt;
Stores&lt;br&gt;
Services&lt;br&gt;
Composables&lt;/p&gt;

&lt;p&gt;Organisation affects maintainability more than people realise.&lt;/p&gt;

&lt;p&gt;🟢 20. Hard-to-read components are trying to do too much&lt;/p&gt;

&lt;p&gt;A good component should be understandable quickly.&lt;/p&gt;

&lt;p&gt;If understanding a component requires scrolling endlessly, the boundaries are likely wrong.&lt;/p&gt;

&lt;p&gt;🟢 21. Scalable composables feel like tools, not dependencies&lt;/p&gt;

&lt;p&gt;Reusable composables should avoid assumptions about pages or layouts.&lt;/p&gt;

&lt;p&gt;The more assumptions a composable makes, the less reusable it becomes.&lt;/p&gt;

&lt;p&gt;🟢 22. Tight coupling kills flexibility&lt;/p&gt;

&lt;p&gt;Coupling often hides inside “convenient” shortcuts.&lt;/p&gt;

&lt;p&gt;Components that deeply understand each other become hard to refactor independently.&lt;/p&gt;

&lt;p&gt;Loose coupling is one of the most underrated frontend engineering skills.&lt;/p&gt;

&lt;p&gt;🟢 23. Co-locate state whenever possible&lt;/p&gt;

&lt;p&gt;The best place for a state is usually the closest possible place to where it’s used.&lt;/p&gt;

&lt;p&gt;An over-centralised state creates unnecessary complexity.&lt;/p&gt;

&lt;p&gt;🟢 24. Large reactive objects can become performance traps&lt;/p&gt;

&lt;p&gt;Vue tracks reactivity deeply.&lt;/p&gt;

&lt;p&gt;Passing large objects unnecessarily increases tracking overhead and rendering cost.&lt;/p&gt;

&lt;p&gt;Smaller reactive boundaries scale better.&lt;/p&gt;

&lt;p&gt;🟢 25. Separate UI state from server state&lt;/p&gt;

&lt;p&gt;This distinction matters enormously in production apps.&lt;/p&gt;

&lt;p&gt;UI state:&lt;/p&gt;

&lt;p&gt;Tabs&lt;br&gt;
Filters&lt;br&gt;
Modals&lt;/p&gt;

&lt;p&gt;Server state:&lt;/p&gt;

&lt;p&gt;API data&lt;br&gt;
Cached responses&lt;br&gt;
Backend truth&lt;/p&gt;

&lt;p&gt;Mixing them creates confusion and unpredictable resets.&lt;/p&gt;

&lt;p&gt;🟢 26. Too many emits signals poor boundaries&lt;/p&gt;

&lt;p&gt;A child component emitting many different events usually indicates responsibility overload.&lt;/p&gt;

&lt;p&gt;Smaller, focused components scale better than “super components.”&lt;/p&gt;

&lt;p&gt;🟢 27. Complex forms need architecture&lt;/p&gt;

&lt;p&gt;Large forms become difficult because developers treat them like collections of inputs instead of systems.&lt;/p&gt;

&lt;p&gt;Good form architecture matters more than styling.&lt;/p&gt;

&lt;p&gt;🟢 28. Reactivity debugging starts with dependency tracing&lt;/p&gt;

&lt;p&gt;Most Vue bugs are not random.&lt;/p&gt;

&lt;p&gt;They’re dependency misunderstandings.&lt;/p&gt;

&lt;p&gt;Understanding what Vue is tracking internally dramatically improves debugging speed.&lt;/p&gt;

&lt;p&gt;🟢 29. Simple components scale better than clever ones&lt;/p&gt;

&lt;p&gt;The most maintainable frontend systems are often the least “impressive.”&lt;/p&gt;

&lt;p&gt;Predictability scales better than cleverness.&lt;/p&gt;

&lt;p&gt;🟢 30. Senior Vue developers think in data flow&lt;/p&gt;

&lt;p&gt;Beginners focus on features.&lt;/p&gt;

&lt;p&gt;Experienced engineers focus on:&lt;/p&gt;

&lt;p&gt;State ownership&lt;br&gt;
Flow direction&lt;br&gt;
Component responsibility&lt;br&gt;
Long-term maintainability&lt;/p&gt;

&lt;p&gt;That mindset shift changes everything.&lt;/p&gt;

&lt;p&gt;Final Thoughts&lt;/p&gt;

&lt;p&gt;Vue is approachable, but building scalable Vue systems still requires engineering discipline.&lt;/p&gt;

&lt;p&gt;The framework gives developers incredible flexibility.&lt;br&gt;
The challenge is learning which patterns continue to work as applications grow.&lt;/p&gt;

&lt;p&gt;Over time, I’ve realized that good Vue architecture is less about mastering APIs and more about mastering:&lt;/p&gt;

&lt;p&gt;Simplicity&lt;br&gt;
Boundaries&lt;br&gt;
Predictability&lt;br&gt;
Data flow&lt;/p&gt;

&lt;p&gt;And honestly, those lessons apply far beyond Vue itself.&lt;/p&gt;

</description>
      <category>vue</category>
      <category>nuxt</category>
      <category>webdev</category>
    </item>
  </channel>
</rss>
