Portrait of Frank Fulcomer

Frank Fulcomer

Software Quality · Systems · Requirements · Automation

Experienced software professional working across software quality, system testing, requirements-based verification, test automation, and regulated healthcare software, now extending that experience into software development and AI-assisted engineering.

How I Work

Understand the problem. Solve it well. Deliver the solution. Learn from the result.

  • Purpose before process

    Understand what actually needs to be solved before deciding how to solve it.

  • Complexity has to earn its keep

    Prefer the simplest approach that does the job well. Add complexity when it provides real value.

  • Rigor should match risk

    Not every problem needs the same level of process, documentation, or testing. Apply rigor where the consequences justify it.

  • Make tradeoffs consciously

    Every solution involves tradeoffs. Understand them, make them deliberately, and be able to explain why.

  • Make the next person's job easier

    Build, test, document, and communicate in ways that leave the work easier to understand and maintain.

  • Learn and improve

    Use what worked — and what didn't — to make the next solution better.

Back to top

AI-Assisted Engineering

Conductor is the name I give my AI-assisted engineering approach — used to build this site.

  1. 01

    Define intent

    Problem, constraints, and acceptance criteria are set before any code is written.

  2. 02

    AI-assisted implementation

    AI drafts code, tests, and documentation within those constraints.

  3. 03

    Engineering review

    Every change is reviewed for correctness, risk, and fit before it's accepted.

  4. 04

    Verification

    Automated and manual testing confirm the result actually meets the stated intent.

Frank remains the conductor — AI accelerates the work; judgment, review, and approval don't move.

Back to top

Featured Work

Four connected projects show how an interview challenge grew into practical software and a repeatable AI-assisted engineering approach. Select a card to read its story.

Workflow TrackerRead story ↓Collapse story ↑The challenge. Show how I would build a QA foundation. I had less than a week to prepare for an interview, and a chance to test how AI could help me build a realistic demonstration around my existing QA experience.Java · Spring Boot · Playwright · REST Assured · JDBC

The situation

During an interview process for a QA role, I wanted to show how I would approach establishing QA practices and automation largely from the ground up. That work is bigger than a handful of test scripts: requirements, coverage, repeatable regression testing, and an approach a team can maintain.

I wanted to demonstrate how I would tackle that work. But a meaningful testing demonstration needs something realistic to test. Building an application, its documentation, and a testing system by hand would take more time than an interview proof of concept justified.

I brought years of experience in software quality, requirements analysis, system testing, and test design. What I didn't bring was extensive hands-on Java/Spring Boot application development experience, and parts of the automation stack were new to me. AI offered a way to bridge that implementation gap without treating unfamiliar syntax as the main problem to solve.

The approach

I used ChatGPT and Claude Code to help create a small workflow application: work items can be assigned to owners, edited, moved through defined statuses, and reviewed through their status history. The application was never the main deliverable. It was a controllable, realistic system against which to demonstrate QA engineering.

I directed the problem-solving, requirements, testing priorities, architectural choices, review, and validation. AI accelerated implementation, investigation, and documentation. The aim was not to automate every possible activity; it was to get useful evidence quickly and know whether to trust it.

The timeline was short. I committed the initial application and Playwright UI suite on September 10, 2026, then separated the black-box tests into their own repository and added CI on September 11. My next interview was less than a week away. I shared the initial proof of concept during the interview process and continued developing the project independently afterward. The capabilities below reflect the current repositories, not necessarily what existed at the time.

Workflow Tracker application showing work items and a detail view with status history
Workflow Tracker in use. The application provides real work-item and status-history behavior for independent UI, API, and database verification. View full-size image

Making the behavior testable

The project grew from a simple application idea into six lightweight user stories with numbered acceptance criteria, shared interface conventions, and explicit scope boundaries. Tests are mapped back to expected behavior, making it possible to discuss coverage in terms of requirements rather than just test counts.

Testing also improved the requirements. Exploring invalid owner identifiers, blank titles, and unassigned work items exposed behaviors that had not been specified. Those gaps became acceptance criteria before corresponding regression tests were added.

Choosing the right kind of testing

The QA system lives in its own repository and treats the application as a black box. Browser tests check user interaction and representative workflows. API tests check business rules and service responses. Read-only SQL checks verify what was actually persisted in the database—even when an application response appears correct.

Manual testing still has a place. An early set of 27 scripted manual cases was refined to six meaningful user workflows. Repetitive, deterministic checks moved to automation; open-ended questions moved to an exploratory testing charter. The goal was less duplicated effort, not less confidence.

Independent regression suite30 automated tests · 3 verification layers
18Browser / UIReal user workflows and interface behavior
6REST APIService contracts and business rules
6SQL / JDBCRead-only verification of persisted state
Each test maps to documented acceptance criteria. The suite runs independently of the application code and is integrated with GitHub Actions. Review test traceability.

Putting regression into the workflow

GitHub Actions builds the application on changes to its main branch. After a successful build, it triggers the separate QA repository with the exact application commit identifier. The test workflow starts that revision of the application, runs the UI, API, and database tests, and saves reports and logs.

That separation matters: the tests don't rely on the application's internal classes, and the regression run is tied to the revision that triggered it—not whichever revision happens to be latest later.

GitHub Actions CI run history for Workflow Tracker tests showing repeated successful executions alongside failures during development
Regression testing in practice. GitHub Actions runs the independent test suite as the project evolves. The history includes successful executions, failures investigated during development, and runs triggered by application changes. Source: GitHub Actions workflow history View full-size image

What the failures taught me

One browser test consistently passed locally and failed in CI. Rather than adding an arbitrary delay or weakening the assertion, I compared execution evidence and traced the problem to closely spaced form submissions and asynchronous handling. The test synchronization was corrected in the shared Page Object; the underlying application risk was recorded separately for future work.

Other findings were deliberately documented rather than immediately fixed, including an API error response that exposed an internal Java type. Not every discovery needs to become an unplanned change to the current scope.

What I took away

AI made it practical to move from an interview problem to a working QA demonstration despite limited familiarity with parts of the development stack. But speed alone was not the measure of success. Requirements still needed scrutiny, test results needed investigation, and the work needed boundaries.

For me, the lasting lesson is that AI can expand implementation capacity while experienced QA judgment determines what to build, what to verify, and when the evidence is good enough.

Where it led

After the interview, I continued developing Workflow Tracker to challenge myself with unfamiliar technologies and AI-assisted engineering. As the testing approach matured, I found a more immediate problem worth solving: managing my own job search more effectively. The next project, Job Search Hub, took those lessons into a practical application I could use.

6Documented product stories
30Automated regression tests
3Independent verification layers

Testing and verification

Categories describe the kinds of checks used or planned; they are not additive test counts. Planned checks are identified explicitly.

UI / E2E

Browser interactions and complete workflows

Playwright automated

API

Endpoints, contracts, and business rules

REST Assured automated

Database

Persistence, integrity, and history

Read-only SQL checks

Manual / Exploratory

Human-led workflows, investigations, and charters

6 workflows and exploratory charter

Open full project page ↗

Job Search HubRead story ↓Collapse story ↑The practical problem. Job applications and recruiter conversations were scattered across spreadsheets and other tools. I began building a system to preserve history and make the information easier to manage.Python · Flask · SQLite · Selenium · Pytest

The situation

My job search had become a project of its own. Applications, recruiter conversations, job descriptions, compensation details, and follow-ups were spread across job boards, email, and increasingly complicated spreadsheets. The spreadsheet was useful, but I was spending more time maintaining the information than I wanted—and it was too easy for important history to disappear behind a single current-status cell.

I had just used Workflow Tracker to challenge myself with AI-assisted development and test automation. This time, instead of inventing a system to test, I already had a real problem. I wanted to see whether I could turn that need into software I would actually use, while applying the same discipline I had spent years bringing to other people's products.

The approach

The tempting version of Job Search Hub would do everything: collect openings, score matches, track recruiters, manage interviews, and automate follow-up. I deliberately did not start there. The first boundary was simpler: once I submit an application, I need to record it accurately and understand what happens afterward.

That choice gave Phase 1 a concrete purpose. It needed to capture the employer, position, application date, original posting, location, compensation, and source; preserve status changes; and make records easy to find again. Prospecting, automated discovery, and AI job evaluation could wait. Deferring them was a product decision, not an admission that the idea lacked ambition.

Job Search Hub applications list populated with five fictional job applications, including company, job title, location, application date, and current status
Applications at a glance. Five fictional records in an isolated demonstration database show how job details and current status can be reviewed together. These are not real job applications. View full-size image

Where development stands

Job Search Hub is still early in development. The initial application-recording workflow, relational data model, and independent browser testing provide a working foundation, not a finished job-search platform. There is considerably more I want it to do.

Recently, I have spent more time getting this portfolio published and building the development infrastructure and AI-assisted workflow that will support the larger Job Search Hub effort. That work has taken priority over adding application features for now. The goal is to return to the project with a clearer way to plan, implement, test, and review changes as its scope grows.

Designing for useful history

One of the first design questions was whether I was simply recreating a spreadsheet in a browser. If each application were just one row with a status field, the new interface would not solve the underlying problem. An application can move from submitted to screening to interviewing and beyond. Those changes have dates, context, and sometimes notes worth preserving.

I used a relational SQLite model to distinguish applications, companies, locations, sources, and status history. Company headquarters is not necessarily the job location. The date I applied is not necessarily the effective date of a later status. Compensation amounts need a basis to mean anything. These distinctions are easy to overlook in a quick prototype; they become important when the information is used for filtering, reporting, or understanding past decisions.

Fictional Northstar Systems status history showing applied, screening, and interviewing events with effective dates and notes
History, not just a status field. This fictional Northstar Systems record preserves the progression from applied to screening to interviewing, including effective dates and notes. The screenshot uses demonstration data. View full-size image

Verifying what actually persisted

The application has its own tests, but I also wanted independent system-level evidence. I created a separate Selenium and Pytest repository that interacts with Job Search Hub through a real Chrome browser. It does not import the application's business logic or reach into its implementation to manufacture a passing result.

Isolation became a particularly important design decision. Each application test starts its own Flask process against a fresh, disposable SQLite database. It never touches my real job-search records. When a test creates an application, it checks the user-visible result and can query that same temporary database read-only to confirm the record and initial status-history entry actually exist. A status-change test checks that the new event was added without losing the old one. A screen that looks correct is not always proof that the underlying data is correct.

One test, independently verifiedIsolated application and data for every test
1 · ACTChrome + SeleniumSubmit an application or change its status through the real interface
2 · RUNDisposable Flask instanceStart the application with a fresh SQLite database
3 · VERIFYUI + read-only SQLConfirm both the visible result and persisted status history
Why it matters: A correct-looking screen is not proof that the right data was saved. Each test uses its own temporary database, never the real job-search records. Inspect the independent test repository.
GitHub Actions history for the Job Search Hub application, including a successful run for isolated database support
Application CI evidence. This captured GitHub Actions history belongs to the application repository, whose CI runs Pytest. It includes the change adding isolated database support. The separate Selenium and read-only SQL suite is documented in the independent test repository; it does not yet have CI. Inspect application CI. View full-size image

Choosing meaningful coverage

The browser suite covers selected workflows such as application creation, status history, and validation. It is not intended to duplicate every lower-level validation test, and it does not yet cover every Phase 1 scenario. Exhaustive filtering, duplicate-warning behavior, and archive/restore remain examples of work that can be added deliberately rather than pretending that a small suite proves everything.

This reflects how I approach QA professionally: choose the right level for each question, make test data trustworthy, and avoid repeating the same assertion through three layers merely to increase a test count. The objective is confidence in behavior, not a large-looking automation report.

What I took away — and where it led

Job Search Hub changed the stakes of my experiment. I was no longer asking only whether AI could help me build unfamiliar software. I was asking whether the result could remain understandable, maintainable, and trustworthy as requirements evolved. That meant paying attention to decisions, test evidence, and the cost of changing direction.

It also exposed a new problem. Coordinating AI assistance across planning, implementation, review, and testing required repeated context handoffs and careful tracking of what had actually been verified. Solving that problem became the next project: Conductor.

2Application and test repositories
1Fresh database per browser test
UI + SQLBehavior and persistence checked

Product and quality evidence

How the application preserves useful information and how its behavior is verified.

Application records

Employer, role, source, compensation, and location

Structured information captured after applying

Status history

Changes preserved instead of overwritten

Effective dates and prior status retained

Browser automation

User workflows exercised in Chrome

Separate Selenium / Pytest repository

Persistence checks

Verify the data behind the screen

Isolated SQLite database and read-only queries

Open full project page ↗

AI Development Workflow / ConductorRead story ↓Collapse story ↑The next bottleneck. AI accelerated development, but coordinating assignments, reviews, evidence, and decisions became its own problem. Conductor grew from making that work repeatable.AI orchestration · Review · Test evidence · Provenance

The situation

Workflow Tracker showed me that AI could help me build a credible demonstration with technologies I did not use every day. Job Search Hub raised the bar: now I had a product with real requirements, persistent data, automated tests, and a reason to keep improving it. The faster implementation became, the more noticeable the coordination work became.

A model could propose a solution, another could implement it, and a third could critique it. But someone still had to carry requirements between them, explain what was authorized, determine which tests actually ran, and preserve the decisions that would matter a week later. Copying conversations between tools was not a sustainable engineering process.

The approach

I started treating AI collaboration less like asking one assistant to do everything and more like coordinating a small team with defined responsibilities. That is where the name Conductor came from. I set the direction, constraints, priorities, and acceptance boundaries. AI assists with analysis, planning, implementation, debugging, and review—but I remain accountable for what is built and what is accepted.

The distinction matters because an AI assistant can sound convincing while being wrong, can make a locally sensible change that violates a requirement, or can describe tests it did not independently execute. Experience in QA has made me particularly reluctant to confuse a plausible explanation with verified behavior.

Conductor workflow diagram showing bounded delegation, independent review, traceability, and human decision points.
A working model of how scoped assignments, implementation, review, and human decisions connect. View full-size image

Separating implementation from verification

The workflow evolved toward an orchestration role that prepares bounded assignments and reviews results, while Claude Code performs delegated implementation or debugging. Codex can inspect the changes, run independent checks, and bring consequential decisions back to me. The roles are useful precisely because they are not interchangeable: the implementer's own success report is not the final evidence of correctness.

One of the principles captured in the project is: scripts establish facts; AI interprets facts; humans grant authority. A script can record the command that ran, its exit status, and the files that changed. AI can help interpret that evidence and identify what still needs scrutiny. Neither a passing test nor an AI recommendation automatically authorizes accepting a risk, changing requirements, committing, or publishing.

Conductor verification case study showing a failed intermediate correction and independent review evidence.
A documented correction cycle: independent checks exposed a problem before acceptance. View full-size image

Making the work traceable

As sessions grew longer, I found that important reasoning could disappear into a transcript. A decision made after comparing alternatives might be forgotten while a polished summary made the work look simpler than it was. Conductor's Python-based bridge therefore records scoped assignments, execution artifacts, source changes, test results, and review material so there is a usable trail behind the outcome.

That record has limits. The bridge can preserve its own delegated runs, but it does not automatically capture every surrounding ChatGPT conversation. Missing source material should be disclosed, not reconstructed as if it were verbatim. Raw transcripts may also contain private context and stay private; the enduring conclusions belong in concise requirements, architecture, test strategy, and decision records.

Keeping authority and scope clear

The process explicitly separates read-only investigation from authorized implementation. It does not allow a requirement to be silently rewritten simply because a test fails. Reviewing a change is not the same as authorizing a commit, and committing is not the same as approving a push or deployment. These are small distinctions until a delegated tool crosses one of them.

At the same time, I do not want a ceremonial framework that consumes more energy than it saves. I use an 'enough' principle: enough structure to preserve intent and verify the result, but no extra tooling or documentation without a clear benefit. The workflow must earn its place through actual use.

Conductor approval matrix distinguishing delegated work from human-controlled acceptance, commits, and publishing.
Approval boundaries distinguish work AI can perform from decisions reserved for the engineer. View full-size image

What I took away

Conductor grew out of practical frustrations rather than a plan to invent an AI methodology. It is still being tested and refined, including through the work of building this portfolio. Some parts are implemented tools; others are operating rules and habits that need continued validation.

The larger lesson connects directly to my QA background. Faster implementation does not remove the need for judgment; it increases the value of knowing what to ask, what evidence to trust, and when to stop.

3Defined responsibility areas
Run recordsChanges and test evidence captured
ApprovalHuman-controlled acceptance

Workflow evidence

The capabilities and safeguards that make delegated work reviewable.

Bounded assignments

Keep implementation work tied to an authorized task

Explicit scope and responsibilities

Independent review

Separate creating changes from evaluating them

Review is a distinct responsibility

Execution records

Preserve what changed and which checks ran

Evidence and decisions kept for follow-up

Human authority

Keep acceptance and publication under engineer control

Approval required for consequential actions

Open full project page ↗

Personal PortfolioRead story ↓Collapse story ↑Making the work visible. GitHub held the technical evidence, but employers needed a clearer way to understand the problems, decisions, and lessons behind the projects.HTML · CSS · GitHub · Cloudflare Pages

The situation

I had started publishing projects on GitHub to demonstrate that my software quality experience was extending into development and modern automation. The repositories contained code, requirements, tests, and engineering notes. But I kept returning to a basic problem: someone considering me for a role might never get far enough into a repository to understand why the work mattered.

A recruiter, business analyst, QA lead, and developer may all look at the same project for different reasons. The recruiter wants to understand my capabilities. The QA lead wants to see how I think about evidence and risk. The developer may want to inspect architecture and code. I needed a place that welcomed all of them without reducing the projects to technology badges.

Before this project, I had never purchased a personal domain or arranged website hosting. Building a professional portfolio meant learning the setup as well as creating the site, and using that unfamiliar technology to deliver something useful while my job search was active.

The approach

That became the central content decision. Each project should begin with a recognizable problem, explain the approach and important choices, and then offer deeper technical detail. The GitHub repositories remain the source of evidence. The portfolio provides the context that makes someone interested enough to open them.

Within hours of deciding I needed a professional portfolio, I had purchased domains, configured DNS and Cloudflare Pages, connected GitHub, and published an initial version. I chose static HTML and CSS because they met the requirements with little infrastructure to maintain. The first release needed to be presentable and informative; it did not need to be a finished product before anyone could see it.

AI accelerated the unfamiliar setup and implementation. I retained responsibility for the architecture, scope, decisions, and acceptance of the work. That made it practical to learn while delivering, without treating a convincing suggestion as a verified result.

Publishing gave me a useful starting point for improving the content, presentation, accessibility, and supporting evidence through review. A successful deployment confirms that a version was published; it does not establish that the site is usable, accessible, or correct. Those qualities still need their own checks.

Choosing the right-sized architecture

I could have built the site with a modern frontend framework, a content management system, or a backend service. None was necessary for the first goal. Static HTML and CSS, versioned in GitHub and deployed through Cloudflare Pages, offered a straightforward way to publish quickly with little infrastructure to maintain.

That choice was not about avoiding engineering. It was about applying engineering judgment to scope. The site still needs responsive behavior, accessible navigation, clear content hierarchy, sensible metadata, secure hosting, and reliable updates. A small technology stack does not excuse poor quality; it simply reduces the number of moving parts.

GitHub check showing Cloudflare Pages successfully deployed portfolio commit 87f9f96
A small publishing pipeline. Cloudflare Pages reported a successful deployment from GitHub. Deployment success is separate from verification of site quality. View full-size image

Designing for different readers

I wanted the visual impression to be mature, approachable, and technically current without looking like a flashy developer template. The design favors light surfaces, readable typography, whitespace, and a recognizable professional photograph. GitHub and LinkedIn are easy to reach, while the project pages let interested readers go deeper.

The same principle shaped the writing. I have years of experience in quality engineering, requirements, regulated software, and cross-functional work. My newer development projects should complement that history, not pretend I have spent decades as a Java or Python application developer. The portfolio needs to be confident about what I know and transparent about what I am learning.

Portfolio homepage with professional portrait, engineering focus, and GitHub, LinkedIn, and email navigation
Professional presentation. The live homepage introduces my background and gives readers direct access to professional profiles. View full-size image

Making quality part of the site

I documented responsive design and mainstream browser support as release expectations, including usable reflow down to 320 CSS pixels. Semantic structure, keyboard navigation, focus visibility, and readable layouts are part of the work, not decorative finishing touches. Those targets need to be checked and refined as the site evolves; a written requirement is not the same as a completed validation result.

The project also provides a practical setting for the Conductor approach. AI can help produce pages and suggest changes, but the content, technical claims, visual acceptance, and decision to publish still need human judgment. The site is public, so inaccurate wording or a broken link is more than an internal development inconvenience.

Desktop and 375-pixel mobile viewport captures showing Featured Work cards and project-story navigation reflowing
Responsive project navigation. Actual desktop and mobile viewport captures show project stories reflowing. Viewport checks supplement physical-device and accessibility testing. View full-size image

What I took away

One of the hardest choices in a personal project is deciding when there is enough. It would be easy to spend weeks refining a page that no employer can yet see. Instead, I chose to put four connected project stories in place and improve them through review. That makes the site useful now while leaving room for real screenshots, diagrams, stronger test evidence, and more detailed case studies later.

The portfolio completes a useful loop: Workflow Tracker tested my abilities, Job Search Hub addressed a real need, Conductor emerged from the challenge of coordinating the work, and this site applies those lessons to communicating the results. The guiding principle is simple: right-sized today, extensible tomorrow.

4Published project stories
4Linked source repositories or project entry points
StaticVersioned, deployable site

Publication and quality evidence

How the site makes the work accessible and verifiable.

Four project stories

Connect problems, decisions, and lessons

Published case studies

Source access

Let technical readers inspect the implementation

GitHub repositories linked

Responsive presentation

Keep stories readable across screen sizes

Layouts designed to reflow

Quality checks

Review content, navigation, and accessibility

Ongoing checks; not a certification

Open full project page ↗

Back to top

Experience

Software quality, systems, requirements, implementation, and automation across healthcare, financial services, and enterprise software.

Software Quality

Testing software across healthcare, financial services, and enterprise environments, including regulated medical devices, from exploratory testing through release verification.

Systems & Requirements

Connecting requirements to system behavior and test coverage across software, hardware, interfaces, and workflows.

Software Implementation

Gathering and clarifying client requirements and helping define software configuration and customization for financial reporting and healthcare reimbursement implementations, including data integration, testing, UAT, training, and go-live support.

Test Automation

Professional experience includes automated verification for medical devices and API performance testing. Recent independent projects extend that experience into UI, API, and database testing using modern automation tools.

Communication

Ensuring the right people have the information they need when they need it — communicating clearly and candidly across organizational levels, adapting the detail to the audience, and raising problems and uncertainty early.

Back to top