Supporting Financial Integrity with Automated Testing

Contributed to automation coverage on core financial and inventory flows, helping the team catch critical calculation bugs before deployment using Playwright.

View GitHub Repoopen_in_new Skip to Codearrow_downward Download Documentdownload

assignment_lateKey Challenges & How I Contributed

Challenge

Complex Financial Logic

Testing dynamic business formulas for Stok Akhir and Profit/Loss required a deep understanding of the app structure.

How I Contributed

Learned the business logic and wrote automated test scripts to validate stock calculations and profit/loss formulas, directly verifying the numbers.

Challenge

Tight 1-Month Timeline

The fast-paced MVP deadline barely left time for comprehensive test plans.

How I Contributed

Focused aggressively on automating critical user flows first, ensuring the most important features were covered before relying on manual testing.

Challenge

Zero Tolerance for Integrity Issues

Small mistakes could skew massive financial records, frustrating early customers.

How I Contributed

Collaborated with the backend developer to understand edge cases and added test scenarios specifically for negative stock prevention and date constraint validation.

Challenge

Audit Trail Compliance

Tracking every CRUD operation safely required extensive repetitive testing.

How I Contributed

Wrote tests to verify that audit logs were created for every data change, strictly following the test patterns established by the broader team.

My First Experience with Financial Application Testing

When I joined the Freshtoria Dashboard project, I was excited but also nervous. This was my first experience testing a financial application where every number mattered—one wrong calculation could make the business think they were profitable when they were actually losing money.

The team was small: one Frontend, one Backend, and me as the Junior QA Automation team member. We had one short month to deliver a working MVP.

What made this project practically challenging for me:

I had to rapidly understand complex business formulas (Stok Akhir = Stok Sebelumnya + Stok Masuk − Stok Keluar)
I needed to learn how to use Playwright effectively as a primary automation driver in a real-world setting
I had to communicate clearly and professionally with developers about the bugs I found

"Our junior QA showed great initiative in learning the business logic and writing reliable automated tests. She caught several calculation errors that would have been embarrassing to fix after launch."— Backend Developer

By the end of the project, I had written automated tests for the most critical user flows, helped catch bugs early, and gained immense confidence in testing complex financial applications.

Learning to Test with an Automation-First Mindset

As a junior, I focused heavily on deeply understanding the testing approach established by the team and contributing where I could add the greatest immediate value.

route A. Critical User Flows I Automated

I focused on automating the most important user journeys first:

Inventory In/OutVerified stock updates correctly after adding or removing consecutive items in succession.
Cash Flow EntryEnsured sold quantity strictly doesn't exceed the recorded production quantity.
Profit/Loss WidgetChecked that dashboard aggregated numbers directly matched manual fallback calculations.
User ManagementAutomated assertions checking that Staff users couldn't see Admin-only components.

rule B. Business Rules Validated

Wrote test scripts to enforce core project brief rules:

Negative Stock Prevention: Validated system absolutely rejects stock removal when removing more than available.
Date Validation: Expired date must logically be after or equal to entry date.
Status Automation:Allowed tests to verify automated status changes when stock dropped (< 2 items).

history C. Audit Trail Verification

Helped ensure every data change was visibly logged by writing tests that:

Verified audit logs were automatically created post-CRUD.
Checked logs carefully included accurate user names and timestamps.
Confirmed login attempts (both success and failure) securely recorded.

Team Decisions I Learned From

As a junior, I didn't make architectural decisions, but I learned a massive amount from how the experienced team set up our testing stack.

rocket Playwright Automation

Experiencing its native capabilities vastly improved my workflow.

Learned how auto-waiting makes tests dramatically more stable than manual waits.
Understood why testing across multiple browsers matters for diverse users.
Used the Trace Viewer extensively for deep debugging of my failed tests.

code_blocks TypeScript for Test Code

Transitioning from loose languages, TS was an eye-opener.

Learned how type safety prevents silly mistakes before runtime (passing string instead of number).
Understood exactly why sharing types between the backend and frontend/tester is highly efficient.

layers Page Object Model

My introduction to proper code organization.

Learned to organize test code cleanly by creating reusable modular page objects.
Learned how to set up authenticated session fixtures once and reuse them across runs seamlessly.

sync CI/CD Integration

Witnessed how modern pipelines accelerate delivery.

Learned how GitHub Actions automatically validates code on every single Pull Request.
Understood practically why tests must absolutely be structurally independent to run in parallel.

Testing Strategy Implementation

How I explicitly approached daily test execution as a junior team member.

Test Coverage I Contributed To

Module	Tests I Wrote	What I Validated
Inventory Management	12	Stock calculations, negative stock prevention, status updates
Cash Flow & Finance	8	Batch creation, sold vs production limits, loss calculations
User Management	5	Login/logout workflows, role-based access control
Audit Trail	4	Log creation after varied data modifications

Testing Activities Performed

Functional TestingValidated that all main features worked fully according to strict business requirements.
Regression & Integration TestingMaintained tests to run automatically before each minor release to ensure non-breaking changes.
Exploratory TestingAttempted highly unusual scenarios and odd-click behavior that might break the web application.

How I Managed Test Data

Unique Identification ApproachUsed timestamps aggressively to create unique SKUs so asynchronous tests wouldn't collide.
Database SeedingLearned practically the importance of resetting identical database states before every test run.
Advanced Factory PatternsPracticed using Faker.js logic extensively to mock realistic dynamic test data for varying input forms.

Lessons from My First QA Automation Project

Insight 1: Understanding Business Logic is Crucial

I spent the first week learning formulas and rules, which helped me write meaningful tests rather than just arbitrarily clicking buttons.

Stok Akhir FormulaCaught an unexpected off-by-one edge-case error when physical stock reached exactly zero.

Profit/Loss CalculationVerified the UI dashboard aggregated widget confidently matched manual manual sum checks.

Expired Date LogicSuccessfully documented edge cases surrounding complex same-day expiry handling.

Insight 2: Automation Catches What Manual Testing Misses

Discovered invisible system-level issues:

Race Condition: Paralleled tests running aggressively revealed database deadlocks.
Stale UI States: The automated waiter confirmed values visually never updated dynamically.
Visual Flaws: Playwright image matches caught incorrectly rendered CSS status classes.

Insight 3: TypeScript Prevents Silly Mistakes

Transitioning from loose JS patterns greatly lowered bug incidence code-side.

// Before TS: I would write this
const quantity = "10"; // string error

// After TS: I write this
const quantity: number = 10; // safe

Insight 4: Overcoming Isolation Hurdles

I learned the extremely hard way that tests need absolute context independence:

Data failures: Appended SKU_timestamp for safety.
State bleeds: Hard-reset databases meticulously before every new test sequence.
Cluttered sessions: Shifted entirely to isolated browser contexts overriding each other.

Bugs I Discovered Through Testing

Visual Bugs I Reported:

Status Coloring & Device Views

• Status Color Wrong: Low stock confusingly showed green instead of red. Found via visual check during exploratory testing.
• Mobile Overflow: Table content completely broke mobile layouts. Caught via Responsive tools.
• Profit Misalignment: Safari-specific alignment issues found actively doing cross-browser sweeps.
• Date Formats: Found non-localized Date outputs showing USA format inherently instead of indonesian DD/MM/YYYY.

Interaction Bugs I Reported:

Edge-case Integrity Interactions

Negative Stock Allowed: Users could remove stock beyond logical negative bounds. I scripted strict automation assertions that caught this underlying ruleset.
Form Validation Timing: Errors delayed rendering till final submission, confusing UX. Caught doing manual data-entry sweeps.
Deactivated Users Security Risk: Disabled accounts possessed lingering active session data. Verified extensively using Security Testing principles.
Session Timeouts: App failed entirely to boot invalid tokens after 2-hours. I utilized Time-based session tests.

Key Contributions

Contribution Area	Impact Details
Automated Scripting	Wrote 30+ test scripts for inventory, finance, and user management modules. Enabled very quick regression testing before releases.
Proactive Bug Reporting	Documented 15+ bugs accurately with clear structured steps to reproduce and screenshots/video to help developers close issues faster.
Test Documentation	Created and drafted well-outlined test-case documentation, heavily assisting team transparency on total codebase coverage scenarios.
Exploratory Testing	Spent downtime performing diverse manual UI tests directly complementing logic gaps in our Playwright automation scripts.
Learning & Adapting	Quickly learned modern Playwright architectures and nested TypeScript patterns on the job, becoming highly productive by Week 2.

What We Achieved as a Team

MVP Delivery Success

• 70% Coverage reached on hyper-critical core logic.
• 10+ Crucial Bugs secured and debugged fully prior to integration.
• Regression Speed Catalyst: Reduced 1 day of manual checks to just roughly 2 hours visually.
• MVP shipped comfortably on timeline schedule.

My Personal Growth

Before ProjectNew to E2E Playwright

After ProjectComfortable writing Playwright tests

Basic TypeScript

Confident with type-safe test architectures

Unsure about testing strategies

Understand automated priority triangles

Nervous about bug reporting

Comfortable communicating logic actively

Example Test Scripts I Wrote

Inventory Module UI Interaction Validation

// Test I wrote to verify stock calculation updates
test('Stock updates correctly when adding and removing UI action items', async ({ page }) => {
  // Navigate to inventory page
  await page.goto('/inventory');
  
  // Add 10 items to stock physically
  await page.click('#add-stock');
  await page.fill('#quantity', '10');
  await page.click('#save');
  
  // Assert verify stock shows 10 on UI specifically
  await expect(page.locator('#stock-amount')).toHaveText('10');
  
  // Perform remove 3 items workflow
  await page.click('#remove-stock');
  await page.fill('#quantity', '3');
  await page.click('#save');
  
  // Ensure stock visually recalculates to 7 successfully
  await expect(page.locator('#stock-amount')).toHaveText('7');
});

Finance Core Logic Constraint Verification

// Test I wrote to verify batch creation limits aggressively
test('Cannot sell more than produced quantity securely', async ({ page }) => {
  await page.goto('/finance');
  
  // Create batch with 100 bottles inherently produced globally
  await page.click('#create-batch');
  await page.fill('#produksi', '100');
  await page.fill('#terjual', '120');  // Intentional edge-break testing
  
  await page.click('#save');
  
  // Assert explicit error message behavior exists upon invalid state
  await expect(page.locator('.error-message')).toBeVisible();
  await expect(page.locator('.error-message'))
      .toContainText('Tidak boleh melebihi produksi');
});

Stack Arsenal

Playwright Framework

TypeScript Typings

VS Code

Git Version Control

GitHub / Actions

Jira Tracking

Concluding Lessons & Impact Evidence

Core Skills Gained

Financial Logic Acumen: Learned how to strictly functionally assert complex calculations and edge formulas that define core business viability.
Team Communication: Drastically improved capacity to concisely document system bugs clearly into Jira channels alongside busy developers.
Agile Collaboration: Prioritized testing layers securely within heavily strapped timeline structures safely alongside backend logic developers.

Obstacles Crushed

Learning Playwright Fast: Watched tutorials and read heavy documentation over weekend deep dives to perform at startup output levels.
Writing Reliable Architectures: Adopted Page-wait strategies and assertion isolation to squash inherently flaky system designs easily.
Test Data Handling: Learned heavily on how DB transaction states strictly required unique randomized SKUs.

What's Next For Me

This project firmly taught me that aggressive automation within financial applications specifically requires severe attention to exact details and profound rule-based logic comprehension. I am deeply excited to exponentially grow my Playwright API integration horizons.

Ready to Discuss How I Can Contribute?

If you're looking for a highly eager junior QA Automation engineer who writes reliable code structure and rapidly catches system flows, let's heavily connect.