Build an event filter someone else can take over. Ask a colleague to make the Saturday request finish after the Sunday request, then run it again with a late failure. If the page still shows the right Sunday events and your colleague can reproduce the result from the README and find your change, you have evidence you can deliver a feature independently.
Choose a project to test
Use your own project for the acceptance exercise. If you're still deciding what to work on, see the day-to-day tasks of web developers →.
## Key takeaways
- Scope. Users can find an event by date and category and open the right details page.
- Failure to test. An old response can display stale results, replace the current list with an error, or end a newer request's loading state early.
- Portfolio evidence. Save a controllable set of responses, a record of a failing test that now passes, and a one-page handoff.
Copyable acceptance card
- Feature, commit, and command to run: ____.
- Ask ____ to rerun it from the README before handoff: input ____, expected ____, actual ____.
- If setup fails, I'll fix the environment instructions. If behavior differs, I'll fix it and ask for a rerun. Mark any scenarios we didn't run as untested.
When is an event list ready for someone else to take over?
A junior front-end developer can use an event list to demonstrate delivery. Define how users find events, then write repeatable acceptance checks for recovery, narrow screens, and keyboard navigation.
This exercise uses sample data prepared by the editors. Have a test double return event A, Saturday Photography, and event B, Sunday Reading. Filter by calendar date at the venue and sort by local start time. Selecting Sunday shows only B, and opening the result shows B's details. The page does not handle registration or store personal data. Treat a date-only value as a calendar date. If the API returns timestamps with time zones, agree which zone determines the day and check two examples on either side of midnight. Otherwise, the same screenshot may be hard to reproduce on someone else's computer.
| Trigger | What the user sees | Acceptance check |
|---|---|---|
| Sunday data loads | Only event B | Open B's details from the list |
| Successful request returns an empty list | No matches message with filters preserved | Clear the filters and return to the full list |
| Current request fails | Error message and retry action | Retry uses the current date and category |
| Current request is pending | Loading state matches the current selection | Switch quickly and check which request owns the labels and results |
A single message for emptiness and failure tells users the wrong thing in one of those cases. The test double should return an empty collection and a 503 separately, so another person can trigger both without changing production settings.
How can a late response prove the fix works?
When users switch filters quickly, only the latest request should update the event list. Older requests must leave the current screen alone whether they succeed, fail, or finish waiting.
Reproduce it first. Set Saturday request A1 to 900 milliseconds and Sunday B1 to 100 milliseconds. Send A1 and immediately switch to Sunday. After both finish, check that the Sunday label still goes with the Sunday events. Run it again with a delayed A1 failure and check that the error doesn't replace the loaded Sunday list.
One approach is to assign each request an increasing ID. Before applying a success, failure, or loading-state cleanup, check that its ID still belongs to the latest request. If cancellation is supported, cancel old work as well. Add Saturday A1 → Sunday B1 → Saturday A2 to the retest. A date check alone will accept stale A1 because the date has returned to Saturday. Give A1 an “old” title and A2 a “new” title so the tester can tell what loaded. A2 should also be the request that ends loading. B1 shouldn't clear it early.
Run this minimal Node example to check the decision logic. Responses are released by hand, so the result doesn't depend on machine speed. It checks which request owns the state. The real page still needs a UI test.
const assert = require('node:assert/strict');
async function main() {
let latest = 0, status;
const release = new Map();
async function load(id) {
const ticket = ++latest;
status = 'Waiting: ' + id;
try {
const result = await new Promise((resolve, reject) => {
release.set(id, { resolve, reject });
});
if (ticket === latest) status = result;
} catch {
if (ticket === latest) status = 'Retry: ' + id;
}
}
const first = load('Saturday A1');
const second = load('Sunday B1');
const third = load('Saturday A2');
release.get('Sunday B1').resolve('Sunday old result');
await second;
assert.equal(status, 'Waiting: Saturday A2');
release.get('Saturday A2').resolve('Saturday new result');
await third;
release.get('Saturday A1').reject(new Error('simulated late failure'));
await first;
assert.equal(status, 'Saturday new result');
console.log('2 state checks passed');
}
main().catch(error => {
console.error(error);
process.exitCode = 1;
});Write three user-visible assertions: a late A1 success leaves B1 visible, a late A1 failure also leaves B1 visible, and returning to Saturday displays A2 only. Use a test double that lets you control when responses are released. Use fixed waits only for the initial manual reproduction. Refer to Playwright's advice on testing user-visible behavior and save the actual run output with the tested version. The example gives expected results. Put your own results in your portfolio.
Related reading
If the project also uses generated assets or has design revisions, use version evidence to explain your design decisions →.
What evidence makes accessibility and mobile tests credible?
Show the actual path through the event list. Use the keyboard to filter and open an event, check visible focus, and record the screens and status messages you tested.
- Tab from the filters to the event link. Check visible focus at each step and confirm you can reach Retry after a failure.
- At 390 CSS pixels, check that both filters, the results heading, and the error message are readable. Test reflow separately at a width equivalent to 320 CSS pixels and check the exceptions.
- Use assistive technology to check dynamic announcements for loading completion, no matches, and failure. Record the browser and assistive technology combination.
WCAG 2.2 gives separate success criteria for keyboard access, visible focus, reflow, and status messages. If you ran a subset on one page, state which checks and combinations passed. A screenshot alone can't show keyboard order. A few checked scenarios don't establish compliance for an entire site.
How should you explain what AI drafted and what you decided?
A front-end portfolio should trace a failure to your own change. Show how to reproduce it, where you changed the code, and what happened on the rerun. State what AI, teammates, and you each contributed.
Share a runnable repository. Put setup and test commands at the top of the README. In the interview, show the failing example first and then the same test after the fix. One way to explain it: “AI drafted the cards and request logic. I found that two requests shared the same date key in a three-request test, changed state ownership to use request IDs, and reran three assertions in a named browser.” Replace the details with results you recorded. If teammates handled the back end, design, or deployment, list their roles and contacts separately on the handoff page. For a school project, report what you verified locally or in the test environment.
For a handoff check, give a colleague a computer that hasn't opened the project. Have them use the README alone to start it, reproduce the issue, and find the change within an agreed time. If installation blocks them, fix the environment instructions first. If the project runs but they can't tell what should happen, fix the test description. Mark behaviors you haven't covered as untested.
Frequently asked questions
Can I include a front-end project if AI wrote most of the code?
Yes. Explain where AI contributed and show a decision you can explain and verify, along with the reproduction and evidence of your change. Share team work and third-party assets only as permitted.
Do junior front-end developers have to deploy the project themselves?
A local project can show that you've delivered a specific behavior. State the environment you used. Production deployment also involves approval, access, and teamwork. Describe the responsibilities you actually held.
Can I show manual checks without automated tests?
Record the input, steps, expected result, actual result, and version. Once timing bugs such as stale responses can be reproduced reliably, they're a good candidate for automation.
Explore further
- Clarify work preferences. Decide whether you'd like to spend more time debugging, handing off projects, or building interfaces. Open FermatMind's 94-question career assessment →
- See what web developers do. Compare feature delivery, testing, and maintenance. Read the web developer profile →
- Prepare for interviews. Explain AI's contribution and your decisions separately. Read the AI-assisted portfolio interview guide →
Editorial review and methods
FermatMind Editorial created the event list and response-timing exercise. Technical references are the Playwright documentation and W3C's WCAG 2.2. Case behaviors are acceptance expectations you can verify; report your own actual results. The career assessment helps you explore work preferences.


