AscentUP
20 bugs found across 7 modules, 6 environment blockers resolved, 2 fixes shipped to production.
- Role
- Software Engineering Intern
- Where
- AscentUP, remote
- When
- Jul to Aug 2026
- Stack
- Next.js, Supabase, PostgreSQL, SQL, Docker, Git
Through AscentUP, I worked on the web app of a partner health startup. It had bugs nobody had mapped and a development environment that kept failing. I ran QA across 7 app modules, checked what the UI showed against a 41-table PostgreSQL database, and fixed the environment blockers that were holding up other fixes.
The problem and constraints
As an AscentUP intern I worked on the web app of a health startup that AscentUP partnered with. The app runs on Next.js and Supabase, backed by a PostgreSQL database of 41 tables. Three kinds of people use it: administrators, regular users, and hosts who post paid programs. Two things were slowing the team when I joined: bugs that had not been found or written down, and a development environment that kept failing.
- An unfamiliar production codebase, with no prior knowledge of the code.
- Seven app modules to cover, each used differently by each kind of account.
- Remote work. Findings and fixes had to be written down for the team.
- Bugs had to be located. A report that a page looks wrong is not enough to fix it. Each report needed the cause.
System architecture and key trade-offs
- Administrators
- Regular users
- Program hosts
- Next.js app7 modules, sign-in by role
- Supabase
- PostgreSQL41 tables
- UI testWhat does the user see?
- Code traceWhich path produced it?
- SQL checkWhat is in the database?
- Bug reportsymptom, cause, severity
- Fix or hand off
Three layers of evidence, instead of UI testing alone. For each module I tested the UI, traced the behaviour through the Next.js code, and ran SQL against the database to check what was stored. UI testing shows that something is wrong. The trace and the query show where. This is slower per bug, and it produces reports someone can act on.
Every module, as every kind of user. I swept all 7 modules and recorded each bug with a severity. A flow that works for an administrator can fail for a program host, so I tested each flow from the account type that uses it. The output was a list of 20 bugs, including one high-severity blocker.
Environment before bug fixes. Fixes were waiting on a development environment that did not work. I resolved 6 blockers across Docker, Supabase and Git by reading the logs. Three dependent bug fixes went ahead after that.
Write every fix down. I documented each environment fix for the team, so the next person to hit the same error has the answer.
Hard metrics and outcomes
| Measure | Result |
|---|---|
| Modules covered | 7 |
| Database tables checked against | 41 |
| Bugs found | 20, including 1 high-severity blocker |
| Environment blockers resolved | 6, in Docker, Supabase and Git |
| Dependent fixes unblocked | 3 |
| Fixes shipped to production | 2 |
Every environment fix is documented for the team.
What broke and lessons learned
Sign-in and role flows took longest. The hardest bugs were in the logic of user sign-in and in how the app responded to input. Each kind of account moves through the app differently, and the flows for administrators, regular users and program hosts were often inconvenient for the person using them. Tracing those meant following one action through the UI, the code and the database, once per account type.
The development environment. The local setup failed in Docker, Supabase and Git, and each failure stopped work that depended on it. I worked through them one at a time from the logs, fixed each, and wrote the fix down before moving on.
Lessons
- Test as each kind of user. A role-based app is several apps sharing one codebase.
- Fix the environment first. Three bug fixes were held up by setup problems, not by the bugs themselves.
- Check the database. What the UI shows and what is stored can differ, and only the query settles which is wrong.
- Document as you go. A fix that lives in one person’s terminal history has to be found again by the next person.