Testability and Shift-Left Testing Questions

I’d treat this like a reproducibility and isolation problem first, not a test-writing problem.

My steps would be:

1. Re-run the exact CI artifact locally if possible: same commit, same build type, same simulator/emulator image, same locale and device size.
2. Collect evidence: logs, screenshots/video, test order, network activity, and whether failures correlate with timing or a specific screen.
3. Narrow the scope: run the failing test alone, then with nearby tests, then in the full suite to see if there is shared state leakage.
4. Check common mobile causes: animations not disabled, missing synchronization, stale app state, async work still running, resource contention, or dependence on previous tests.
5. Fix the root cause by making the test deterministic: better selectors, explicit waits on app state, hermetic test data, reset between tests, and stable test fixtures.

I would only use retries as a temporary shield, not a fix. If a test is still flaky after that, I’d quarantine it short-term, keep the behavior covered elsewhere, and assign ownership until the underlying issue is resolved.

Situation: On a mobile team I joined, we had a lot of regressions in one feature area because the view models were doing too much and our tests were mostly high-level UI tests.

Task: I wanted to improve both code quality and test quality so bugs were caught earlier, without slowing delivery.

Action: I extracted network and persistence logic behind small protocols, moved parsing into a pure mapper layer, and added focused unit tests around the business rules. I also replaced several brittle UI assertions with a smaller number of end-to-end checks that verified the full flow. To keep the team aligned, I added test-review guidance in PRs: if logic could be tested without UIKit/Android UI, it should be.

Result: The feature became much easier to change, and we started catching bad payload handling and state bugs in unit tests instead of in QA or CI. I knew it helped because flaky UI failures went down, PR reviews got simpler, and the same area produced fewer escaped defects after the refactor.

The main lesson for me was that quality improves fastest when tests match the right layer of the architecture.

Situation & goal (brief)
As a QA Engineer I’d use feature flags to validate new behavior in production safely, enabling iterative rollout and fast rollback while minimizing user impact.

Rollout strategies

• Canary: enable flag for a small set of internal or beta users (e.g., 1–5 hosts or specific user IDs) to validate real traffic patterns.
• Percentage rollout: stepwise increase (1% → 5% → 25% → 100%) with acceptance gates at each step (metrics & QA sign-off).

Dark-launch / testing approach

• Deploy code behind a flag but keep it invisible to users (dark-launch) so QA can exercise flows via internal routes, test accounts, or feature-flag-targeted sessions.
• Use telemetry and server-side logging to compare control vs. candidate behavior without exposing feature to end users.

How QA validates safely

• Create test accounts/IDs targeted by flags and automated end-to-end tests that run against production traffic slices.
• Monitor functional checks, error rates, latency, and business metrics (conversion, API success).
• Pair exploratory sessions with log-level assertions and synthetic transactions to detect regressions early.
• Document acceptance criteria per rollout gate.

Rollback plan

• Predefine a single “kill switch” flag toggle with automation (API/CLI) for immediate global disable.
• Maintain runbooks: who toggles, verification steps, and post-mortem triggers.
• Automate alerting on thresholds (errors/latency) that auto-disable the flag and page on-call.

This ensures controlled validation, measurable gates, and fast, safe rollback if issues arise.

I avoid arbitrary sleeps because they make tests slow and nondeterministic. Instead, I try to control the source of asynchrony.

Patterns I use:

• Expectations or latches: wait for a specific callback or event, with a timeout only as a safety net.
• Fake clocks or test schedulers: for timers, debounce logic, or reactive streams, I advance virtual time manually instead of waiting in real time.
• Injected executors/dispatchers: run work on a test-controlled thread or immediate executor.
• Async/await or promise testing: await the final state rather than polling.
• For streams, subscribe in the test, emit events explicitly, and assert the sequence.

The key is to make the async dependency injectable so the test controls when work happens. That keeps tests fast, repeatable, and easy to debug. If a test still needs a timeout, I keep it short and use it only to fail fast, not to "solve" synchronization. The best async tests are ones where the test owns time and input, not the app.

I’d test accessibility at three levels: semantic checks, interaction checks, and real screen-reader verification.

What I can automate:

• Every interactive element has a meaningful label, hint, or content description.
• Focusable elements are exposed in a sensible order.
• Buttons and controls have the right traits and are large enough to tap.
• State changes are announced or at least reflected in accessible text.
• Accessibility scanners can catch obvious issues like missing labels or low-contrast text.

What still needs manual review:

• Whether VoiceOver or TalkBack reads the screen naturally.
• Whether the focus order matches the visual and task flow.
• Whether dynamic updates, modal dialogs, and errors are announced at the right time.
• Whether the feature is usable with only the screen reader, no sighted assistance.

I’d build the automated checks into CI and include accessibility in the definition of done, but I’d still do at least one manual pass on a real device before release. Automation finds regressions; humans catch usability problems.