Joseph Quiñones ·QA Automation Engineer&AI & Workflow Automation Developer

A layered Playwright + TypeScript suite that runs 35+ real betting journeys across multiple brands and environments in parallel, and reports straight into Teams.

• ✓Four-layer architecture: page objects → reusable flows → business test cases → spec suites. Each layer has a strict contract: pages hold no assertions, flows throw, test cases record.
• ✓Continue-on-failure step runner: one broken step never hides the rest. Failed bets are cleaned up in-app and the page is reloaded only if still dirty. A dead tab aborts the run at once instead of timing out on every step.
• ✓One Playwright project per brand, generated from config: brands run side by side locally with a single login each. CI runs on a self-hosted runner.
• ✓Custom reporters: timestamped, auto-pruned, zipped HTML reports, plus a plain-English run summary (“timed out waiting for the betslip”) posted to Teams as an Adaptive Card.
• ✓Flakiness guardrails written from real incidents: prove every action landed, read only settled state, locate by content not position, each test owns its start state.

The problem

A betting site with dozens of critical flows (bets, cash-out, live scores) across several brands and environments. Far too many to click through by hand before every release.

What I built

An automated regression suite that plays through 35+ real user journeys per brand, in parallel, and posts a pass/fail summary to the team chat.

The result

Every release gets a full check, and failures arrive as readable sentences instead of stack traces, so the right person can act right away.

• 35+ scenarios
• 4-layer architecture
• Parallel per brand
• 3 environments
• 170+ commits

export async function runStep(name: string, results: StepResult[], fn: () => Promise<void>) {
  try {
    await fn();
    results.push({ name, ok: true });
  } catch (err) {
    if (isSkip(err)) throw err; // genuine skips stay skips
    results.push({ name, ok: false, error: firstLine(err) });
  }
}

export function assertAllPassed(results: StepResult[]) {
  const failed = results.filter((r) => !r.ok);
  if (!failed.length) return;
  throw new Error(`${failed.length} step(s) failed:\n` +
    failed.map((f) => `  ✗ ${f.name}\n    ${f.error}`).join('\n'));
}

Set up the test repo so an AI agent can write, review and fix tests safely, following the same rules as the team.

• ✓Project CLAUDE.md with hard rules, a workflow routing table and an architecture doc the agent must read before touching tests.
• ✓Four custom Skills: QA ticket → correctly layered test case; senior-QE code reviewer backed by a Python anti-pattern scanner; wait/timeout optimization; behavior-preserving refactoring.
• ✓Hooks enforce the rules mechanically: no direct pushes to main, secrets never printed, blocked shells rerouted.
• ✓Self-improvement loop: every fixed failure becomes a written guardrail with the incident recorded, then the codebase is swept for the same class of bug.
• ✓Every change lands through a PR, after a verification run and a review pass.

The problem

AI coding tools are fast but careless. They guess, skip reviews and can leak secrets.

What I built

Rules, skills and guard hooks that make the AI follow the team’s process: verify before commit, review before merge, never touch secrets.

The result

Tests get written faster, reviewed the same way every time, and the same bug doesn’t happen twice. I bring this approach to every client build.

• 4 custom skills
• Hook-enforced rules
• Review before every merge
• Incident-driven guardrails

// PreToolUse hook: exit code 2 blocks the command and tells the agent why
const cmd = JSON.parse(stdin).tool_input?.command ?? '';
const block = (why) => { console.error(`Blocked: ${why}`); process.exit(2); };

if (/git\s+push\b.*\bmain\b/.test(cmd)) block('main takes no direct pushes. Open a PR.');
if (/\.env(?!\.example)\b/.test(cmd))      block('secrets stay out of output.');
process.exit(0);

The QA team triggers test runs from a Microsoft Teams message and gets results back as Adaptive Cards.

• ✓Cloudflare Worker receives Teams requests via Power Automate and dispatches GitHub Actions workflows.
• ✓Results are posted back to the channel as Adaptive Cards: pass/fail, duration, report link.
• ✓No one needs repo access or the Actions UI to run a suite.

The problem

Running a job meant opening another tool, finding the right button and waiting around for the result.

What I built

A chat command that starts the job and posts the result back into the same chat.

The result

Anyone on the team can run it and see the outcome without leaving the app they already use.

• Serverless
• Zero new logins for the team
• Results in-channel

Inbound website leads get followed up on WhatsApp automatically at 24 hours, 3 days and a few weeks later.

• ✓Python + Playwright bot drives WhatsApp Web with human-like per-character typing across multiple instances.
• ✓Google Sheets as a lightweight CRM: scheduled follow-ups, spaced sends, automatic STOP opt-out.
• ✓Runs headless on a Linux VPS. Alternative Evolution API + n8n (Docker) architecture designed for scale.

The problem

Real estate leads went cold because nobody had time to follow up, and the ones who did forgot.

What I built

A bot that messages every new lead on WhatsApp and follows up on a schedule, tracked in a simple Google Sheet.

The result

Every lead gets followed up on time without anyone remembering to. People who reply STOP are removed automatically.

• 3 follow-up stages
• Auto STOP opt-out
• Google Sheets CRM
• 2 budget tiers