<?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: Christiana Mabel Nyuma</title>
    <description>The latest articles on DEV Community by Christiana Mabel Nyuma (@najbuilds).</description>
    <link>https://dev.to/najbuilds</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%2F4206784%2F364aad83-2942-4802-b0e2-450b8b1f797e.png</url>
      <title>DEV Community: Christiana Mabel Nyuma</title>
      <link>https://dev.to/najbuilds</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/najbuilds"/>
    <language>en</language>
    <item>
      <title>From React to React Native &amp; Expo: How an HNG Task Became My Mobile Engineering Journey</title>
      <dc:creator>Christiana Mabel Nyuma</dc:creator>
      <pubDate>Wed, 18 Nov 2026 09:30:00 +0000</pubDate>
      <link>https://dev.to/najbuilds/from-react-to-react-native-expo-how-an-hng-task-became-my-mobile-engineering-journey-afg</link>
      <guid>https://dev.to/najbuilds/from-react-to-react-native-expo-how-an-hng-task-became-my-mobile-engineering-journey-afg</guid>
      <description>&lt;h2&gt;
  
  
  The task that started it
&lt;/h2&gt;

&lt;p&gt;I thought the hard part would be making the phone talk to the backend. It wasn't.&lt;/p&gt;

&lt;p&gt;The task arrived during my HNG internship. Lesson 2 asked for a shopping web experience. I built one: a storefront called Lumé House, in React and TypeScript, with Supabase behind it. Lesson 3 asked for a mobile counterpart connected to the same backend.&lt;/p&gt;

&lt;p&gt;I chose React Native and Expo. I wanted to explore mobile development, and Expo let me do that while building on the React knowledge I already had. That was my reason: curiosity first, and a shorter path from what I already knew. The task asked for a mobile counterpart; the choice of framework was mine.&lt;/p&gt;

&lt;p&gt;One expectation shaped everything that followed. I expected a change made to an authenticated cart on one client to appear on the other. If I added something on the web, the phone should know. That is the version of the story I had in my head.&lt;/p&gt;

&lt;p&gt;The version I built is simpler, and I should say so at the start: each client reads the shared server state when it refreshes. There is no live push between them. The gap between what I expected and what I built is most of what this article is about.&lt;/p&gt;

&lt;p&gt;I submitted the mobile task. Then I kept building. The task gave me a reason to start; the rest of this article is about what the device taught me after that.&lt;/p&gt;

&lt;h2&gt;
  
  
  What came with me from React
&lt;/h2&gt;

&lt;p&gt;The React model transferred almost intact. Components, props, hooks, state, TypeScript types, the habit of splitting a screen into pieces that can be reasoned about separately. Expo SDK 57 runs React Native 0.86 with React 19.2, and the code I wrote looked like React because it was React.&lt;/p&gt;

&lt;p&gt;The Supabase client transferred too: the same JavaScript library, and the same shapes for products, variants, prices and orders. I did not have to relearn my own data model. Both clients were built against the same schema, so neither one needed its own version of what a product or an order was. That was the part I could trust while everything around it changed.&lt;/p&gt;

&lt;p&gt;The catalogue's search, category filtering and four sort modes were plain logic operating on plain objects; moving that logic was not the hard part.&lt;/p&gt;

&lt;p&gt;The app has four tabs now — Home, Shop, Cart and Account — and a catalogue that can search, filter and sort. The four-tab shell came after the first version, but the domain was already familiar.&lt;/p&gt;

&lt;p&gt;The testing habit transferred as well, at least in principle: write tests around behaviour rather than appearance. I would later learn that the principle was right and my test harness was not, but that is a story for later.&lt;/p&gt;

&lt;p&gt;What helped most was that the web storefront already existed. I was not starting from a blank page. I knew what a product was, what a variant was, what the cart was supposed to do. The mobile app was a second client for a domain I already understood.&lt;/p&gt;

&lt;p&gt;I did not port the app. The mobile repository is its own codebase with its own navigation, storage and interface. What the two share is a backend and a set of ideas about how the shop should behave. That distinction matters: a port would have been a copy, and a copy would have hidden the parts that do not travel.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I had to learn
&lt;/h2&gt;

&lt;p&gt;The first thing that stopped transferring was the browser.&lt;/p&gt;

&lt;p&gt;On the web, routing is a history object and a URL. In Expo Router, routes are files, and the navigator is a native stack or a set of tabs. Typed routes help, but the mental shift is bigger than the API: back is a platform behaviour, not a browser button. A deep link is a route that must exist before anyone opens it.&lt;/p&gt;

&lt;p&gt;That sounds small until a sign-in link arrives from outside the app. On the web it is another page load. On the phone it has to wake the app, find the right route, and still know what the user was doing before the link arrived.&lt;/p&gt;

&lt;p&gt;Storage changed next. In the browser I had storage that the page could reach whenever it wanted. On the phone, session state lives in AsyncStorage, and the Supabase client has to be configured for it: persisted sessions, token refresh, and a refresh when the app comes back to the foreground. There is no shared cookie jar and no address bar. The app is the only context.&lt;/p&gt;

&lt;p&gt;Authentication made the difference clearest. On the web, Google sign-in is a redirect. The browser leaves my page, the provider sends the user back, and the session is waiting. On mobile there is no page to return to. I needed a custom URL scheme, a system browser session, a callback route and an exchange of the authorization code. That meant PKCE, a pending-authorization timestamp, and deduplication for the case where the callback fires twice. The browser had been doing more for me than I had noticed.&lt;/p&gt;

&lt;p&gt;Layout was the quietest change and the one that kept showing up. CSS grid and flexbox became style objects, &lt;code&gt;FlatList&lt;/code&gt;, safe areas and density-independent pixels. A 320 dp screen and a 1.3 font scale are not edge cases; they are configurations a real person can be using. Android treats a font-scale change as a configuration change, and the generated manifest did not declare it. I added a small config plugin so the activity handles it instead of being recreated. That was the first time accessibility showed up in my work as a lifecycle problem rather than a style problem.&lt;/p&gt;

&lt;p&gt;None of these changes were impossible. They were simply not optional, and each one removed a little more of the assumption that the browser would handle it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzm7i1d45ndccdwnmuxlx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzm7i1d45ndccdwnmuxlx.png" alt="Comparison of React knowledge that transferred to React Native and native concepts I had to learn" width="800" height="600"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;What transferred — and what I had to learn. The framework versions listed are this project's stack, not a general recommendation.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The phone fights back
&lt;/h2&gt;

&lt;p&gt;The Shop tab crashed every time I opened it on the device.&lt;/p&gt;

&lt;p&gt;Not sometimes. Every time, from the tab bar and from the hero action on the home screen. The same screen worked in tests. On the phone it closed the app.&lt;/p&gt;

&lt;p&gt;The device log pointed at the layout handler, not at the data or the network. That narrowed the problem to the lifetime of a value I had assumed would still be there.&lt;/p&gt;

&lt;p&gt;The cause was a reference to a synthetic event that React Native had already released. I was reading the layout width inside a state updater:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight tsx"&gt;&lt;code&gt;&lt;span class="c1"&gt;// before: the updater reads the event after React Native releases it&lt;/span&gt;
&lt;span class="n"&gt;onLayout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;setRail&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;viewport&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;nativeEvent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layout&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;
  &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="n"&gt;previous&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;viewport&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;nativeEvent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layout&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="c1"&gt;// after: read the value while the event is alive, then queue the update&lt;/span&gt;
&lt;span class="n"&gt;onLayout&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="n"&gt;viewport&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;event&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;nativeEvent&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layout&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="nf"&gt;setRail&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;viewport&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="n"&gt;viewport&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="n"&gt;previous&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;previous&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;viewport&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;React may run the updater later. React Native releases the synthetic event when the handler returns. By the time the updater ran, &lt;code&gt;nativeEvent&lt;/code&gt; was null, and the app died on a property read. The fix was small: read the number while the event is alive, then queue the update with the number.&lt;/p&gt;

&lt;p&gt;The fix is not the interesting part. The interesting part is why my tests missed it.&lt;/p&gt;

&lt;p&gt;My test harness applied state updates immediately. That is convenient, and it is not how React behaves. The crash lived in the gap between "the handler returned" and "the updater ran", and my harness had no such gap. The tests were green because they were not modelling that timing.&lt;/p&gt;

&lt;p&gt;So I wrote a test that does model it: it queues the updater, nulls out &lt;code&gt;event.nativeEvent&lt;/code&gt; before flushing, and asserts that the width survived. A second test does the same through the React 19 renderer. Then I put the original implementation back and ran both tests: both failed. I restored the corrected implementation and ran them again: both passed. That is the result I wanted — the tests fail on the code the fix replaced and pass on the code that replaced it.&lt;/p&gt;

&lt;p&gt;That falsification is the part I trust. A regression test that has never failed on the bug it targets is not yet evidence that it covers the bug.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8a3dtgc3pn238tg23ssp.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8a3dtgc3pn238tg23ssp.png" alt="Four-step diagram showing a React Native event being released before a queued updater reads it, causing a crash" width="800" height="500"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The event-lifetime defect recorded in this project — not a claim about universal React Native behaviour.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Designing for two clients
&lt;/h2&gt;

&lt;p&gt;One of the interesting parts of building the mobile app was connecting it to the same backend as the web storefront.&lt;/p&gt;

&lt;p&gt;I wanted someone to be able to interact with their cart on one platform and find the same information on the other. But sharing a backend introduced questions I hadn't fully considered when I started.&lt;/p&gt;

&lt;p&gt;What happens when two clients try to change the same cart? What happens when a request succeeds but the response never reaches the app? And how do you prevent a retry from accidentally adding the same item twice?&lt;/p&gt;

&lt;p&gt;Working through those questions introduced me to idempotency, conflict handling and the importance of treating the server as the source of truth.&lt;/p&gt;

&lt;p&gt;The approach I built uses server-backed cart operations and makes conflicting changes visible rather than silently overwriting them. Updates between the web and mobile clients become visible when the other client refreshes, rather than appearing instantly.&lt;/p&gt;

&lt;p&gt;It taught me that connecting two applications is not just about making API requests. It's also about deciding how they should behave when things don't go as expected.&lt;/p&gt;

&lt;h2&gt;
  
  
  After submission
&lt;/h2&gt;

&lt;p&gt;Submitting the HNG mobile task wasn't the end of the project for me.&lt;/p&gt;

&lt;p&gt;I kept working on the application, expanding the shopping experience with authentication, cart management, checkout, order history and improvements to the Android build.&lt;/p&gt;

&lt;p&gt;One milestone that meant a lot to me was installing the standalone app on my Android phone and opening it without a development server running in the background.&lt;/p&gt;

&lt;p&gt;Seeing the application run independently was different from watching it work inside my development environment. It made the transition from web development to mobile engineering feel much more tangible.&lt;/p&gt;

&lt;p&gt;I also started paying closer attention to things I hadn't thought about as much when building for the browser: app configuration, navigation behaviour, screen sizes and how changes behave on an actual device.&lt;/p&gt;

&lt;p&gt;The project is still evolving, but continuing beyond the original task gave me opportunities to learn that I wouldn't have encountered by stopping at submission.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this experience taught me
&lt;/h2&gt;

&lt;p&gt;Moving from React to React Native taught me that knowing a framework doesn't mean knowing every environment it runs in.&lt;/p&gt;

&lt;p&gt;I brought my understanding of components, state, TypeScript and API integration with me. But mobile development introduced a different set of challenges, from navigation and authentication to layout behaviour and debugging issues I hadn't encountered on the web.&lt;/p&gt;

&lt;p&gt;My QA background also changed how I approached those challenges. I wasn't satisfied with getting a feature to work once. I wanted to understand what could break, test the behaviour and make the implementation more reliable.&lt;/p&gt;

&lt;p&gt;Some of that confidence came from automated tests, while other parts came from working through the application on an actual device. I also learned to distinguish what I'd verified locally from what still needed testing in a real environment. Testing also taught me to be precise about what I could confidently say worked. My automated checks covered the authentication and checkout logic using mocked backend responses, while live-account verification remained a separate step.&lt;/p&gt;

&lt;p&gt;That's probably my biggest takeaway from this transition: &lt;strong&gt;building something and validating it are two different responsibilities, and both matter.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'm still learning React Native and Expo, but I now understand mobile engineering much better than I did when I started.&lt;/p&gt;

&lt;p&gt;And that's progress worth sharing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where this leaves me
&lt;/h2&gt;

&lt;p&gt;The web taught me to build. The phone taught me to check what the platform was doing for me.&lt;/p&gt;

&lt;p&gt;What I want next is not dramatic: an iOS build, a TalkBack pass, and a store build I can stand behind. Lumé House is still an ongoing project, with more I want to explore on both the web and mobile sides. This article focuses on my move from React to React Native and Expo, but that is only one part of the engineering journey. As I keep building, I will have more to share about the decisions, challenges and testing behind both applications.&lt;/p&gt;

&lt;p&gt;If you write React and you are thinking about mobile, start with the parts you already know. Then go looking for the help the browser used to give you. That is where the learning is.&lt;/p&gt;

</description>
      <category>reactnative</category>
      <category>expo</category>
      <category>react</category>
      <category>testing</category>
    </item>
    <item>
      <title>From Requirements to Test Cases: How I Turn Features into Testable Scenarios</title>
      <dc:creator>Christiana Mabel Nyuma</dc:creator>
      <pubDate>Wed, 11 Nov 2026 09:36:48 +0000</pubDate>
      <link>https://dev.to/najbuilds/from-requirements-to-test-cases-how-i-turn-features-into-testable-scenarios-1e77</link>
      <guid>https://dev.to/najbuilds/from-requirements-to-test-cases-how-i-turn-features-into-testable-scenarios-1e77</guid>
      <description>&lt;h1&gt;
  
  
  From Requirements to Test Cases: How I Turn Features into Testable Scenarios
&lt;/h1&gt;

&lt;p&gt;A feature request describes a destination. A test case describes how we will know we arrived. Between them are questions that are easy to skip.&lt;/p&gt;

&lt;p&gt;The Lumé House examples below are reconstructed from local QA records and rewritten for publication. They are illustrative, not verbatim requirements or fresh results. Customer data and unverified execution claims are excluded.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why requirements need questions
&lt;/h2&gt;

&lt;p&gt;"Customers should be able to choose delivery or pickup at checkout" sounds complete. It is not.&lt;/p&gt;

&lt;p&gt;Which fields appear? What makes an address usable? Is delivery available everywhere? What happens on a mode switch? Which rule belongs to the browser, client or server?&lt;/p&gt;

&lt;p&gt;"Required" can mean rendered, non-empty, meaningful after trimming, or accepted by the server. Four claims, four tests.&lt;/p&gt;

&lt;p&gt;A test case needs an oracle: the requirement, a business rule, a data constraint or an approved design. "It looked right" cannot. In my QA work, I compare behaviour with requirements and record the expected result, the actual result and the difference.&lt;/p&gt;

&lt;h2&gt;
  
  
  From feature request to acceptance criteria
&lt;/h2&gt;

&lt;p&gt;I turn a request into acceptance criteria before writing cases. Each names an actor, condition, action, observable outcome, source and version.&lt;/p&gt;

&lt;p&gt;For the checkout example, the criteria might include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Given delivery, when the customer submits without a street address, then submission is blocked, focus moves to the first invalid field, and an error is associated.&lt;/li&gt;
&lt;li&gt;Given pickup, when the customer submits, then delivery-only fields are not required and no delivery address is sent.&lt;/li&gt;
&lt;li&gt;Given a delivery zone, when the total is calculated, then the server-selected fee is used, not a browser-supplied one.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If the original is unavailable, I label the criterion as reconstructed and say what it was reconstructed from. That tells the next person how much weight it can bear, and stops a test artifact becoming the requirement.&lt;/p&gt;

&lt;p&gt;I separate business rules (what the service offers), UI rules (what the customer sees) and data rules (what the system stores or rejects). One end-to-end test can touch all three without telling you which failed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Delivery versus pickup: a worked example
&lt;/h2&gt;

&lt;p&gt;The wording below is an illustrative reconstruction, not the original stakeholder requirement:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Customers may choose delivery or pickup. Delivery requires contact details and a valid address; pickup does not require an address. The total must reflect the delivery fee for the selected zone.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The field inventory:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Field group&lt;/th&gt;
&lt;th&gt;Delivery&lt;/th&gt;
&lt;th&gt;Pickup&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Contact: name, phone, email&lt;/td&gt;
&lt;td&gt;Required&lt;/td&gt;
&lt;td&gt;Required&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Delivery: street, area, city, zone, instructions&lt;/td&gt;
&lt;td&gt;Required, except instructions&lt;/td&gt;
&lt;td&gt;Not required&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Payment: provider, mobile-money number&lt;/td&gt;
&lt;td&gt;Required&lt;/td&gt;
&lt;td&gt;Required&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The inventory answers which fields appear, not the useful questions. Is the city free text? Is delivery restricted? Are delivery fields hidden or disabled on pickup? Are values cleared on a mode change? Is the fee calculated client-side or server-side? Does a hidden field still submit?&lt;/p&gt;

&lt;p&gt;A 19 October 2026 review inspected a branch snapshot. An automated guest-checkout check against a local mock found native validation blocking blank required fields and focusing the first invalid control. Whitespace-only values passed native validation for some text fields, and the server-side validator rejected them generically.&lt;/p&gt;

&lt;p&gt;Those findings describe one branch, not the current build. A finding becomes a defect only when reproduced against a named build with evidence.&lt;/p&gt;

&lt;p&gt;The lesson: "delivery details are required" produced three questions. Is the field present? Is the value meaningful? Is the feedback useful?&lt;/p&gt;

&lt;h2&gt;
  
  
  Positive, negative, boundary and conditional cases
&lt;/h2&gt;

&lt;p&gt;A &lt;strong&gt;positive&lt;/strong&gt; case uses valid input and checks the intended outcome. A delivery order with a complete synthetic address should reach the server with the expected fields; pickup should omit delivery-only values. The oracle is the accepted order state and payload, not a clickable button.&lt;/p&gt;

&lt;p&gt;A &lt;strong&gt;negative&lt;/strong&gt; case uses input that should be rejected. Each required field gets a missing-value case; malformed phone and email values get their own. An unsupported city, missing zone, empty Cart and unauthenticated session fail differently.&lt;/p&gt;

&lt;p&gt;A &lt;strong&gt;boundary&lt;/strong&gt; case sits at a rule's edge. Empty differs from whitespace-only; a city with trailing spaces differs from an unsupported city name. Cart quantities of 1, 99 and 100 test the range and first rejection.&lt;/p&gt;

&lt;p&gt;A &lt;strong&gt;conditional&lt;/strong&gt; case changes the state that determines which rules apply. Switching to pickup after an invalid address should not leave a stale error blocking pickup; switching back restores the delivery requirement.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;Question&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;th&gt;Oracle&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Positive&lt;/td&gt;
&lt;td&gt;Valid delivery produces an order?&lt;/td&gt;
&lt;td&gt;Complete address, selected zone&lt;/td&gt;
&lt;td&gt;Order accepted with expected fields&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Negative&lt;/td&gt;
&lt;td&gt;Missing zone rejected?&lt;/td&gt;
&lt;td&gt;Zone left unselected&lt;/td&gt;
&lt;td&gt;Blocked, zone-specific message&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Boundary&lt;/td&gt;
&lt;td&gt;Whitespace treated as empty?&lt;/td&gt;
&lt;td&gt;Street contains only spaces&lt;/td&gt;
&lt;td&gt;Field-specific rejection, no order&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Conditional&lt;/td&gt;
&lt;td&gt;Pickup ignores delivery errors?&lt;/td&gt;
&lt;td&gt;Invalid street, then pickup&lt;/td&gt;
&lt;td&gt;Pickup submits; no delivery values&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A good suite covers partitions, not every possible string. The aim is to make each rule visible, not prove every combination.&lt;/p&gt;

&lt;h2&gt;
  
  
  A traceability table with expected results
&lt;/h2&gt;

&lt;p&gt;A traceability table links each requirement to its cases, layer and evidence. It exposes gaps and stops a passing check at one layer being described as proof at another.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;ID&lt;/th&gt;
&lt;th&gt;Requirement&lt;/th&gt;
&lt;th&gt;Action&lt;/th&gt;
&lt;th&gt;Expected result&lt;/th&gt;
&lt;th&gt;Layer&lt;/th&gt;
&lt;th&gt;Status&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;T01&lt;/td&gt;
&lt;td&gt;Delivery needs a street address&lt;/td&gt;
&lt;td&gt;Submit street blank&lt;/td&gt;
&lt;td&gt;Submission is blocked, the first invalid field receives focus, and a relevant error message is displayed.&lt;/td&gt;
&lt;td&gt;Browser&lt;/td&gt;
&lt;td&gt;Designed; historical observation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T02&lt;/td&gt;
&lt;td&gt;Address must be meaningful&lt;/td&gt;
&lt;td&gt;Submit spaces only&lt;/td&gt;
&lt;td&gt;Field-specific rejection; no order&lt;/td&gt;
&lt;td&gt;Browser + backend&lt;/td&gt;
&lt;td&gt;Historical divergence; not retested&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T03&lt;/td&gt;
&lt;td&gt;Delivery is limited to one city&lt;/td&gt;
&lt;td&gt;Enter unsupported city&lt;/td&gt;
&lt;td&gt;City message; no order&lt;/td&gt;
&lt;td&gt;Browser + backend&lt;/td&gt;
&lt;td&gt;Historical gap; not retested&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T04&lt;/td&gt;
&lt;td&gt;Delivery needs a zone&lt;/td&gt;
&lt;td&gt;Submit with no zone&lt;/td&gt;
&lt;td&gt;Blocked; a zone message appears&lt;/td&gt;
&lt;td&gt;Browser&lt;/td&gt;
&lt;td&gt;Designed; field association was a historical gap&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T05&lt;/td&gt;
&lt;td&gt;Pickup skips delivery fields&lt;/td&gt;
&lt;td&gt;Choose pickup, submit valid details&lt;/td&gt;
&lt;td&gt;Delivery values absent or null&lt;/td&gt;
&lt;td&gt;Harness + payload + backend&lt;/td&gt;
&lt;td&gt;Harness observed omission; integrated blocked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T06&lt;/td&gt;
&lt;td&gt;Mode switch clears conditions&lt;/td&gt;
&lt;td&gt;Invalid delivery data, then pickup&lt;/td&gt;
&lt;td&gt;Pickup not blocked by hidden errors&lt;/td&gt;
&lt;td&gt;Browser&lt;/td&gt;
&lt;td&gt;Designed; not run&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T07&lt;/td&gt;
&lt;td&gt;Server owns the delivery fee&lt;/td&gt;
&lt;td&gt;Tamper with browser fee or zone label&lt;/td&gt;
&lt;td&gt;Server fee used; tampering ignored&lt;/td&gt;
&lt;td&gt;Backend&lt;/td&gt;
&lt;td&gt;Source-inspected; live not verified&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;"Expected result" matters most. "No error" is not an oracle; it describes an absent signal. "No order is created, the response identifies the field, and the record has no delivery address" is an oracle because it can be checked independently.&lt;/p&gt;

&lt;p&gt;No row says PASS. Some have historical observations, one is source-inspected, one blocked, several designed but not run. The table claims only that we know what evidence would settle each question.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the Cart conflict example taught me about test layers
&lt;/h2&gt;

&lt;p&gt;Let's consider another example: a shopping cart conflict. This is an illustrative scenario reconstructed to demonstrate how a requirement becomes a test case, rather than a direct quotation from a stakeholder.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;If the server rejects a Cart change because the quantity changed elsewhere, the client must not silently retry. It must ask the customer to refresh and review, then send a new expected quantity.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Each change carries an operation id. A change or removal on an existing line also carries the expected quantity; an add sends none.&lt;/p&gt;

&lt;p&gt;The mobile repository contains an offline contract test for the stale-quantity path, using a stand-in repository. It loads quantity 2, tries to set 3, and the stand-in rejects it as &lt;code&gt;CART_CHANGED&lt;/code&gt;. It asserts an error state, a message about another session, and no automatic retry; a second identical change is refused. It refreshes to 4, submits 5, and checks expected quantities 2 and 4, with different ids.&lt;/p&gt;

&lt;p&gt;That is a meaningful client-contract result: it does not loop on a conflict it can treat as final. It refreshes and builds the next request from the reviewed state.&lt;/p&gt;

&lt;p&gt;It is not proof that the server rejects stale writes. Every repository is mocked; the real database rule, session and network are outside the test.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Question&lt;/th&gt;
&lt;th&gt;Browser observation&lt;/th&gt;
&lt;th&gt;Mocked client contract&lt;/th&gt;
&lt;th&gt;Live backend&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Customer-visible behaviour?&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Partly&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Client conflict handling?&lt;/td&gt;
&lt;td&gt;Not reliably&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Server rejects stale quantity?&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ownership isolation?&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A mocked test is not lesser; it has a narrower claim. It can be precise about the client state machine while saying nothing about the server. A browser observation can show the message while saying nothing about the database. A live backend check can prove the rule but not what the customer understands.&lt;/p&gt;

&lt;p&gt;The manual equivalent is a two-session scenario: load the Cart in both, change one, then try from the stale state in the other. It is designed, not executed. Until it runs against a named environment, the mock is the only evidence for client behaviour.&lt;/p&gt;

&lt;h2&gt;
  
  
  Designed is not executed
&lt;/h2&gt;

&lt;p&gt;A test case is a plan. A test result is a claim about an execution. The difference needs to survive into the report.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Status&lt;/th&gt;
&lt;th&gt;Meaning&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Designed / planned&lt;/td&gt;
&lt;td&gt;Case exists; no execution claimed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Not run&lt;/td&gt;
&lt;td&gt;Not executed in this cycle&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Blocked&lt;/td&gt;
&lt;td&gt;Precondition prevented execution; not a failure or pass&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Fail&lt;/td&gt;
&lt;td&gt;Observed differs from expected&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pass&lt;/td&gt;
&lt;td&gt;Expected observed on a named build, with evidence&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The integrated manual QA pack is an example. Its delivery and pickup cases were BLOCKED because the integrated environment and approved test writes were unavailable. No browser case was marked passed. That is a result about the environment, not proof that checkout was broken. A blocked prerequisite is neither a failure nor a pass.&lt;/p&gt;

&lt;p&gt;The same discipline applies to automation. A synthetic-session DOM harness is not a real browser; an automated check against a local mock is not a manual integrated session. Each produces evidence for a narrower sentence than "checkout works".&lt;/p&gt;

&lt;p&gt;A status has a scope. "Pass in an automated local-browser check against a mock on 19 October 2026" differs from "pass in the current production build". Without build, environment or date, it is not reproducible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Defects, retesting and evidence
&lt;/h2&gt;

&lt;p&gt;A defect record is a test case with a disagreement attached. It should contain the requirement or case id, environment and build, preconditions, steps, expected and actual results, evidence and severity. The actual result describes what happened, not an assumed cause.&lt;/p&gt;

&lt;p&gt;The whitespace finding is an example. Illustratively, its record would read: the expected result was a field-specific rejection for a street address of only spaces; native validation accepted the spaces-only value, the request reached the server-side validator, and the rejection came back as a generic message without field association. The record recommended a client-side check and better feedback; it did not claim a fix.&lt;/p&gt;

&lt;p&gt;A retest is not "the code looks different now". It is the same case, on the corrected build, with the same preconditions, producing a new result and evidence. The original failure stays. If the case passes, the history shows what changed; if not, the defect remains open.&lt;/p&gt;

&lt;p&gt;A code change can create regressions nearby. After a validation fix, I would rerun the positive delivery, pickup, whitespace boundary and error-association cases. A unit test at the client layer does not replace a browser retest, and a browser retest does not replace a backend check.&lt;/p&gt;

&lt;p&gt;Evidence should be proportional and safe: a date, environment, build reference, command or short sanitized capture is enough. Customer names, phone numbers, addresses, order references, tokens and raw payloads do not belong in a public write-up.&lt;/p&gt;

&lt;p&gt;Test counts need care. A suite total is a snapshot, not coverage of a requirement. If I cite a count, I date it and say what it covered.&lt;/p&gt;

&lt;h2&gt;
  
  
  Closing: what good test cases help us understand
&lt;/h2&gt;

&lt;p&gt;Good test cases do not prove that a feature is perfect. They make its assumptions visible.&lt;/p&gt;

&lt;p&gt;The checkout example showed that a conditional requirement is a set of questions about presence, meaning, feedback and server authority. The Cart example showed that client tests, browser observations and live backend checks answer different questions. Neither needed a bug story; the work was in the questions.&lt;/p&gt;

&lt;p&gt;When I turn a feature into test cases, I ask five things:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Who is the actor, and what state are they in?&lt;/li&gt;
&lt;li&gt;What condition changes the expected behaviour?&lt;/li&gt;
&lt;li&gt;What observable outcome would make the requirement false?&lt;/li&gt;
&lt;li&gt;Which layer can actually prove that outcome?&lt;/li&gt;
&lt;li&gt;What is the execution status, and where is the evidence?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A requirement becomes testable when someone can disagree with it precisely. That is the standard I aim for, even when the answer is "not run yet".&lt;/p&gt;

</description>
      <category>qa</category>
      <category>testing</category>
      <category>softwareengineering</category>
      <category>testcases</category>
    </item>
    <item>
      <title>Why I Build and Test: My Journey Through Frontend Engineering and QA</title>
      <dc:creator>Christiana Mabel Nyuma</dc:creator>
      <pubDate>Sun, 25 Oct 2026 18:06:03 +0000</pubDate>
      <link>https://dev.to/najbuilds/why-i-build-and-test-my-journey-through-frontend-engineering-and-qa-4cmj</link>
      <guid>https://dev.to/najbuilds/why-i-build-and-test-my-journey-through-frontend-engineering-and-qa-4cmj</guid>
      <description>&lt;p&gt;My professional journey didn't begin with writing code. It began in customer service, where my career started before I moved into frontend development and, later, software quality assurance.&lt;/p&gt;

&lt;p&gt;Today, I approach software from both perspectives. Frontend engineering has taught me to think about how an application is built and how people interact with it. QA has taught me to question assumptions, investigate behavior, and look for evidence that something works as intended.&lt;/p&gt;

&lt;p&gt;Those two perspectives shape how I approach engineering and the philosophy behind Naj Builds:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;BUILD • VALIDATE • SHIP&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  From customer service to building software
&lt;/h2&gt;

&lt;p&gt;I worked in customer service from May 2021 to April 2023. In April 2023, I transitioned into a Junior Frontend Developer role, contributing to frontend development in a Laravel-based application environment.&lt;/p&gt;

&lt;p&gt;That was an important change in my professional responsibilities. I was no longer looking at software only from the perspective of someone interacting with it. I was contributing to the application itself, working within an existing system where implementation decisions needed to fit the surrounding code and requirements.&lt;/p&gt;

&lt;p&gt;In September 2023, I transitioned into software quality assurance as a QA Tester. In November 2024, I progressed to QA Analyst II.&lt;/p&gt;

&lt;p&gt;Each role brought a different responsibility into focus: understanding how people experience software, contributing to how it is built, and investigating whether its behavior meets expectations.&lt;/p&gt;

&lt;p&gt;My learning has also included BlueCrest, the ALX Software Engineering programme, the AltSchool Africa Frontend Engineering programme, HNG internship participation, and further testing and AI-related training.&lt;/p&gt;

&lt;p&gt;Today, my technical interests include React, TypeScript, modern frontend engineering, manual and API testing, and AI-assisted development.&lt;/p&gt;

&lt;p&gt;I don't see frontend engineering and QA as competing directions. They give me different ways to approach the same problem: building software that behaves as intended and being able to explain how I know.&lt;/p&gt;

&lt;h2&gt;
  
  
  QA changed the questions I ask
&lt;/h2&gt;

&lt;p&gt;Working in QA has changed how I examine software.&lt;/p&gt;

&lt;p&gt;When investigating an issue, I reproduce the behavior, compare what happens with what the requirement describes, examine relevant UI states and API responses, and document expected and actual results.&lt;/p&gt;

&lt;p&gt;When a developer implements a fix, I retest the affected behavior. Functional testing helps determine whether requirements are met, while regression testing helps identify whether a change has affected existing functionality.&lt;/p&gt;

&lt;p&gt;One distinction matters especially to me: observing a problem is not the same as knowing its cause.&lt;/p&gt;

&lt;p&gt;A screen may display the wrong value, but that observation alone does not establish whether the issue originates in frontend state, an API response, or somewhere else.&lt;/p&gt;

&lt;p&gt;This is one reason I value clear reproduction steps and evidence. They make an investigation easier to communicate, repeat, and evaluate.&lt;/p&gt;

&lt;p&gt;And yes, sometimes QA feels a little like detective work. The difference is that the clues need to be reproducible.&lt;/p&gt;

&lt;h2&gt;
  
  
  One interaction, two engineering perspectives
&lt;/h2&gt;

&lt;p&gt;Consider a simple shopping-bag interaction.&lt;/p&gt;

&lt;p&gt;This is an illustrative example, not a recorded incident or executed test from my work.&lt;/p&gt;

&lt;p&gt;Suppose a customer changes an item's quantity from one to two. The requirement is that a successful update changes the displayed quantity and line total. If the update fails, the interface should communicate the problem and remain consistent with the saved state.&lt;/p&gt;

&lt;p&gt;From a frontend perspective, I would consider the quantity control, pending state, successful update, error feedback, and the relationship between the interface and saved data.&lt;/p&gt;

&lt;p&gt;From a QA perspective, I would examine the same interaction through expected behavior.&lt;/p&gt;

&lt;p&gt;Does the quantity change correctly? Does the line total reflect the updated quantity? What happens when the update fails? Can the customer understand what happened?&lt;/p&gt;

&lt;p&gt;Both perspectives begin with the same requirement, but they explore different responsibilities.&lt;/p&gt;

&lt;p&gt;Building the interaction is one part of the work. Checking whether the interaction behaves correctly is another.&lt;/p&gt;

&lt;p&gt;For me, that is where frontend engineering and QA become especially valuable together.&lt;/p&gt;

&lt;h2&gt;
  
  
  Bringing those perspectives into Lumé House
&lt;/h2&gt;

&lt;p&gt;Lumé House Web is an ecommerce application where I am the project developer and owner. My responsibilities include frontend engineering, product decisions, QA, and AI-assisted implementation and review.&lt;/p&gt;

&lt;p&gt;The application uses React, TypeScript, Vite, Tailwind CSS, and Supabase.&lt;/p&gt;

&lt;p&gt;My work has included implementation and validation across the product catalogue, authentication, shopping-bag and cart behavior, checkout, and order-related workflows.&lt;/p&gt;

&lt;p&gt;Working on an ecommerce application brings connected interactions into the same project. A customer might browse a product, add it to a bag, sign in, and proceed towards an order. Each interaction has implementation requirements and behavior worth checking.&lt;/p&gt;

&lt;p&gt;As the project owner, I am responsible for defining what the application should do, reviewing the implementation, and evaluating the evidence supporting its behavior.&lt;/p&gt;

&lt;p&gt;The project is available through its &lt;a href="https://github.com/Mabel007/lume-house" rel="noopener noreferrer"&gt;GitHub repository&lt;/a&gt; and &lt;a href="https://lume.najbuilds.com/" rel="noopener noreferrer"&gt;web deployment&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;However, implemented functionality, validation of a particular scope, and full release readiness are not interchangeable. Outstanding staging, infrastructure, and release work remains. This article does not claim that every feature is production-complete or that the current deployment has been independently validated.&lt;/p&gt;

&lt;p&gt;I intend to explore specific implementation decisions and testing evidence in future Lumé House case studies.&lt;/p&gt;

&lt;h2&gt;
  
  
  BUILD • VALIDATE • SHIP
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Build&lt;/strong&gt; means understanding a requirement and making implementation decisions that fit the application.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Validate&lt;/strong&gt; means examining whether the behavior meets expectations, investigating differences, and documenting what the available evidence supports.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Ship&lt;/strong&gt; means making a readiness decision with a clear understanding of what has been checked and what remains unresolved.&lt;/p&gt;

&lt;p&gt;These three words are more than a slogan for Naj Builds. They describe the responsibilities I want to make visible in my engineering work and technical writing.&lt;/p&gt;

&lt;p&gt;I want to explain not only what I built, but also why I approached it that way, what I checked, and what I still need to improve.&lt;/p&gt;

&lt;h2&gt;
  
  
  Working with AI and owning the result
&lt;/h2&gt;

&lt;p&gt;AI-assisted engineering is part of how I work on Lumé House.&lt;/p&gt;

&lt;p&gt;I use AI tools to support implementation, investigation, code review, and testing. But using AI does not transfer responsibility for the result.&lt;/p&gt;

&lt;p&gt;I still need to understand the requirement, evaluate suggestions, review the implementation, and check whether the resulting behavior is appropriate.&lt;/p&gt;

&lt;p&gt;An AI-generated explanation can be useful without being correct. A proposed fix can appear reasonable without addressing the underlying issue.&lt;/p&gt;

&lt;p&gt;That is why I want evidence and review to remain part of the workflow.&lt;/p&gt;

&lt;p&gt;In future articles, I plan to share how AI contributes to particular tasks, which decisions remain mine, and how I evaluate the results.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why Naj Builds, and what comes next
&lt;/h2&gt;

&lt;p&gt;Naj Builds is where I bring these parts of my journey together: frontend engineering, QA, continuous learning, and the projects through which I apply what I learn.&lt;/p&gt;

&lt;p&gt;I want this space to contain more than finished screenshots or lists of technologies.&lt;/p&gt;

&lt;p&gt;I want to write about the decisions behind implementations, the problems I investigate, the tests I perform, and the lessons that come from work that is still progressing.&lt;/p&gt;

&lt;p&gt;That includes frontend architecture, React, mobile development, Supabase authentication, QA practices, AI-assisted workflows, HNG learning, and ecommerce engineering.&lt;/p&gt;

&lt;p&gt;I am still learning, building, and refining how I work. Technical writing gives me a way to document that process and share something useful with others who are navigating similar paths.&lt;/p&gt;

&lt;p&gt;If you build software, test it, or do a little of both, I hope you find something useful here.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is one question testing has taught you to ask before calling a feature done?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>career</category>
      <category>webdev</category>
      <category>testing</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
