How I built this site

Behind the Build

Why I built it this way

I wanted a challenge. When I discovered that Claude Code could create designs by placing individual pixels, I saw the perfect opportunity to build something entirely my own, quite literally pixel by pixel. My goal was a portfolio that would be not only memorable but genuinely interactive: a space where visitors engage with information through play and exploration rather than simply reading it. That goal reflects a principle at the heart of my work in testing and instructional design: the most lasting learning comes through experience. We retain what we explore and discover far better than what we passively read.

How I tested it

I ran this portfolio like a test project. I set the requirements, directed an AI assistant (Claude) to build it in JavaScript and React, and tested every version before it went live on Base44, using functional, regression, cross-browser, usability and user acceptance testing.

Start with my testing approach below, then follow the path: each big stone is a milestone in the order it happened, and the seasons change as you go.

My approach

The test cycle

Every change on every page went through the same test cycle, often several times, until it met its acceptance criteria:

  1. 1Define the requirement and its acceptance criteria
  2. 2Build the change
  3. 3Test it against the expected behavior
  4. 4Log any defects with clear steps and screenshots
  5. 5Fix and retest
  6. 6Regression test what already worked
  7. 7Verify it on the live site

…then back to step 1 for the next change.

At a glance

Testing in numbers

118versions built, tested and reviewed across the three main pages
45interactions manually tested across the Home, Projects and About Me pages
8defects logged, fixed and retested (see the defect log)
12looks per scene checked: 4 seasons × 3 times of day

Testing used

  • Manual testing
  • Functional testing
  • Regression testing
  • Exploratory testing
  • Usability testing
  • Accessibility checks
  • Cross-browser testing
  • User acceptance testing (UAT)
  • Installation testing
  • Defect tracking

The milestones, in the order they happened

  1. Milestone 1 · Before the first page · Requirements and compatibility

    Choosing JavaScript and React

    Before building, I set the requirements: a site that is interactive, user-first and runs smoothly for every visitor. The first idea was an animated image for the Home page, but it couldn't respond to visitors.

    We eventually landed on JavaScript and React as the languages necessary for running as smoothly as possible on Base44: React components install directly into Base44, and JavaScript draws the pixel art live, so every scene can respond to the person using it.

  2. Milestone 2 · Home page · Functional and regression testing

    The first cottage

    Manual testing shaped this site from the first version. I set the requirements for an interactive, user-first Home page, then manually tested every interaction against its expected behavior, thinking first about what a visitor would try and whether it would be obvious to them.

    As the page grew, I ran regression testing after each change to confirm that everything that already worked still did. When the whole house was replaced with a new design, every existing interaction was retested before release. Readability testing also led to the greeting's font being reworked three times.

    BeforeBefore: First version
    First version
    AfterAfter: Now
    Now
  3. Milestone 3 · Projects page · Exploratory, visual and installation testing

    A forest for the Projects page

    The Projects page was built through exploratory and visual testing. I compared several directions, a night village and a meadow, before choosing a daytime forest that continues the Home page and keeps the project cards easy to read.

    Testing the published page found defects that previews had missed, such as a missing chicken coop and animals layered in front of trees. Each was logged, fixed and verified on the live site.

    Installation testing found that Base44's builder couldn't install a file this large, so the code was split into a scene file and an art file, compressed, and installed through the Code tab.

    BeforeBefore: First idea: a night village
    First idea: a night village
    BeforeBefore: First forest
    First forest
    AfterAfter: Now
    Now
  4. Milestone 4 · About Me page · Functional testing

    My room for About Me

    About Me became a room where each part of my story lives on an object, so functional testing covered every object: does each one open the right section, show the right label and close cleanly?

    As the room gained new behavior (a character who moves around it, day and night, a door to the Projects page and glow-in-the-dark contact details), each addition was tested on its own and then regression tested with everything else.

    BeforeBefore: First version
    First version
    AfterAfter: Now
    Now
  5. Milestone 5 · All pages · Usability and accessibility testing

    Hover labels everywhere

    Usability testing showed that a playful site needs to tell people what they can do. Every clickable object now shows a short label saying what a click will do, in the same style on every page.

    Accessibility checks added a Key pop-up listing every interaction, buttons for keyboard users and support for the reduced-motion setting. The labels were also tested at the screen edges, after clicks and on touchscreens.

    A hover label on the Home page
    A hover label on the Home page
  6. Milestone 6 · Projects pages · Documentation

    Projects as case studies

    Finally I rewrote every project as a short case study (Problem, My Role, Process and Outcome), the same clear, structured writing I use for test documentation, so a hiring manager can see what I personally did. All the original links and pictures stayed, and this project joined the list.

    A project written as a case study
    A project written as a case study
  7. Milestone 7 · All pages · UAT and cross-browser testing

    User acceptance testing

    I conducted user acceptance testing (UAT). I asked testers for feedback and asked them to run the site on a variety of browsers and try out every feature.

    I implemented their feedback, which ultimately made the site run much smoother.

  8. Results · Quality assurance

    Defect log

    Real defects I found through manual testing of previews and the live site, and how each one was fixed and verified:

    DefectFound duringFixStatus
    The chicken coop was missing from the final Projects scene on the live site.Live-site testingMoved the coop in front of the tree layer, then retested on the live site.Fixed
    Animals appeared in front of trees they should have been behind.Visual testingPut the animals on a layer behind the trees, so they walk behind the trunks.Fixed
    A large gap appeared between the Home and Projects sections, and the scene didn't fit the screen from left to right.Layout testing on the live siteMade the scene fill its section edge to edge on every screen size.Fixed
    Base44's builder couldn't install the Projects file (about 359 KB).Installation testingSplit it into a scene file and an art file, compressed both, and installed them by pasting into the Code tab.Fixed
    The chat preview couldn't find the separate art file.Preview testingMade single-file preview versions just for reviewing.Fixed
    The greeting text ran into the new cottage's roof.Regression testing after the house was replacedRe-centred and resized the text so it lines up with the top window.Fixed
    At night a star sat right above the "a" in "Lauren" and looked like an accent mark.Visual testing in night modeKept stars out from behind the greeting.Fixed
    The preview showed "returnReact is not defined" from compressed code.Preview testingPreviewed from the readable version instead (the live site was not affected).Fixed
  9. Design exploration · Exploratory and visual testing

    Early mockups

    Each page started as a mockup that I tested against its requirements before committing to it. Every mockup below is written up the same way:

    What I testedWhat I foundWhat I decided

    Girl: first sprites mockup
    Girl: first sprites
    Tested
    Her first design on every page.
    Found
    One outfit didn't fit every season's scene.
    Decided
    Kept her as the main character and gave her an outfit for each season.
    Projects: first layout mockup
    Projects: first layout
    Tested
    Whether every project card stays easy to read inside a scene.
    Found
    The busy background competed with the card text.
    Decided
    Calmed the background in the next versions.
    Projects: meadow mockup
    Projects: meadow
    Tested
    The meadow against the forest, side by side.
    Found
    The forest carried on the Home page's world; the meadow didn't.
    Decided
    Chose the forest.
    Cat: first sprite mockup
    Cat: first sprite
    Tested
    Each animation frame, for smooth movement.
    Found
    Frames that needed smoothing before the cat could go live.
    Decided
    Fixed and retested each animation, then added the cat to the pages.
    Build strip: first version mockup
    Build strip: first version
    Tested
    Readability, and whether the link to this page was clear.
    Found
    The strip needed a clearer path to this page.
    Decided
    Redesigned it for clarity.
    Detailed houses mockup
    Detailed houses
    Tested
    A higher level of detail, by day and by night (an A/B comparison).
    Found
    The extra detail didn't fit the rest of the site as well.
    Decided
    Kept the original cottages.
    Girl: sprite sheet mockup
    Girl: sprite sheet
    Tested
    Every pose, frame by frame.
    Found
    Defects such as her hair being cut off in the sitting poses.
    Decided
    Fixed each one and retested.
  10. Reflection

    Looking back

    What I'd do differently

    • Write a test checklist for every interaction on day one, so each release could be checked against the same list.
    • Start cross-browser, phone and live-site testing earlier. Several defects only showed up after publishing.
    • Test installation limits (file size, how each page installs in Base44) before building large scenes.

    What testing with AI taught me about clear requirements

    • Clear acceptance criteria get the right result. The more exactly I described the expected behavior, the fewer rounds a change took.
    • Good defect reports get fixed faster: what happened, what should have happened, and a screenshot.
    • Reference images communicate a requirement faster than any description.
    • Testing with real users finds what I can't. UAT feedback is what made the site run much smoother.