AI Custom Forms and Autofill: Define Any Schema, Generate Data, Inject It

You’re testing a property listing app. The “Create Listing” form has 18 fields: property title, description (minimum 50 words), property type (house/apartment/condo/townhouse), number of bedrooms, bathrooms, parking spaces, square footage, year built, listing price, street address, city, state, zip code, HOA monthly fee, pet policy, available date, agent name, and agent phone number.

You need to test this form with 8 different property profiles to cover the edge cases — a studio apartment with no parking, a 5-bedroom house with a long description, a condo with HOA fees, a property with a move-in date in the past to test date validation, and so on.

You open a test data generator. It gives you names, addresses, and phone numbers. It doesn’t give you property descriptions, bedroom counts, HOA fees, or pet policies — because no standard test data tool knows what a property listing looks like. So you start typing. “Beautiful 3-bedroom apartment in downtown…” for the description. “House” for property type. “3” for bedrooms. “2” for bathrooms. “1” for parking.

That’s one listing. You have seven more to create.

For each listing, every field requires you to either invent a value on the spot or copy it from somewhere. Let’s count the actual taps for one listing using copy-paste from a separate generator:

Switch to generator → find name → long-press → Copy → switch to app → tap field → long-press → Paste. That’s 8 taps per field. For the fields your generator doesn’t cover (description, bedrooms, property type, HOA fees, pet policy, square footage, year built, listing price), you’re typing manually. For 18 fields, that’s roughly 90 taps of copy-paste overhead plus manual typing for the domain-specific fields.

Multiply by 8 test listings: 720 taps of data entry overhead. Over an hour of your testing session spent not testing — just entering data.

And every listing you manually compose looks suspiciously similar, because you’re the same person inventing “creative” descriptions under time pressure. “Beautiful apartment…” “Lovely home…” “Charming condo…” Your test data has the diversity of a thesaurus with three entries.

This is the friction that Test Nexus AI Custom Forms + Autofill eliminates entirely.

You define the form once — “property listing with these 18 fields.” Gemini AI generates 8 distinct, realistic listings in seconds. You switch to the property app, tap the first form field, and Android’s Autofill Framework fills every field simultaneously. No copy-paste. No app-switching. No inventing descriptions. One form, filled in one action.

That’s 720 taps replaced by 8.

The Problem No Test Data Tool Solves

Standard test data generators are built around predefined categories: names, addresses, phone numbers, email addresses, credit card numbers. They’re excellent at these categories because the formats are well-defined and universal.

But most real apps have forms that don’t fit neatly into those categories. A recipe app needs ingredients and cooking times. A healthcare app needs medication names and dosages. A job board needs company names, salary ranges, and job descriptions. A travel app needs hotel amenities, check-in times, and room types.

When your form has fields that fall outside “name, address, phone, email, card,” every test data generator leaves you in the same place: typing “test” into fields, copy-pasting lorem ipsum into description boxes, and entering “123” for every numeric field. The result is test data that tells you nothing about how your app handles real content — long descriptions, special characters in amenity names, edge-case numeric values, date ranges that span months.

This is the gap that AI Custom Forms fills. Instead of being limited to predefined data categories, you describe the form, and AI generates data that fits your specific schema — with realistic content that actually exercises your app’s handling of real-world input.

How It Works: Three Steps

Step 1: Define Your Form Schema

In Test Nexus, describe the fields your form contains. You’re telling the system what kind of data you need, not how to generate it.

For the property listing example:

Form: Property Listing

Fields:
- Property title (short text)
- Description (long text, 50-200 words)
- Property type (house / apartment / condo / townhouse)
- Bedrooms (number, 0-10)
- Bathrooms (number, 1-5)
- Parking spaces (number, 0-4)
- Square footage (number, 200-5000)
- Year built (year, 1950-2025)
- Listing price (currency USD, 50000-2000000)
- Street address
- City
- State
- Zip code
- HOA monthly fee (currency USD, 0-1000)
- Pet policy (text: "Allowed" / "Not allowed" / "Case by case")
- Available date (date, future)
- Agent name
- Agent phone

You define this once. It’s saved in Test Nexus and reusable across testing sessions. Like all Test Nexus data, your custom schemas and generated form fills are stored in AES-256 encrypted local databases on your device.

The schema definition is flexible. You can specify:

• Data types — text, number, date, currency, selection from options
• Constraints — min/max values, character limits, date ranges
• Enum values — specific options the field accepts
• Relationships — “zip code should match the city and state”

The more specific your schema, the more realistic the generated data. But even a minimal schema (“property listing with typical fields”) produces usable results — the AI infers field types and appropriate value ranges from context.

Step 2: Generate Data with AI

Tap generate. Gemini AI reads your schema and produces a complete form fill with contextually appropriate values. Not random strings — coherent, realistic data where the fields make sense together.

Here’s what a single generated property listing looks like:

Property title:    "Renovated Craftsman Bungalow Near Laurelhurst Park"
Description:       "Light-filled 1924 Craftsman bungalow with original 
                    hardwood floors, updated kitchen with quartz countertops,
                    and a finished basement converted to a home office. 
                    Large backyard with mature Japanese maple. Walking 
                    distance to Laurelhurst Park and SE Division Street 
                    restaurants. New roof 2021, updated electrical 2019."
Property type:     House
Bedrooms:          3
Bathrooms:         2
Parking:           1 (detached garage)
Square footage:    1,850
Year built:        1924
Listing price:     $625,000
Street address:    3847 SE Ankeny Street
City:              Portland
State:             Oregon
Zip code:          97214
HOA fee:           $0
Pet policy:        Allowed
Available date:    April 1, 2026
Agent:             Rachel Nguyen
Agent phone:       (503) 555-0147

Notice what the AI did: the description references a real Portland neighborhood (Laurelhurst) and a real street (SE Division) known for restaurants. The year built (1924) matches the “Craftsman” architectural style, which was popular in Portland in the 1920s. The zip code (97214) corresponds to the SE Portland area. The price ($625,000) is realistic for a 3-bedroom house in that neighborhood. The HOA fee is $0 because it’s a standalone house, not a condo. The agent has a name consistent with Portland’s demographics.

Every field is internally consistent. That’s not something you get from typing “test property” and “123 Main Street.”

Now generate 7 more, and each one is different — a studio apartment in a downtown high-rise ($1,800/month HOA, no parking), a suburban townhouse with 4 bedrooms, a waterfront condo with a long amenity-focused description. The AI produces variety that you’d never create manually under time pressure.

Step 3: Autofill Into Your Target App

This is where the workflow transforms from “better test data” to “zero data entry.”

Switch to the property listing app you’re testing. Tap on the first form field. Android’s Autofill Framework — the same system that offers to fill passwords and addresses from your phone’s saved data — recognizes the form and offers to fill it with the data Test Nexus generated.

Accept the autofill suggestion. Every field in the form is populated simultaneously.

The entire 18-field form is filled in one action. Not 18 copy-paste operations. Not 8 taps per field. One autofill action.

Switch back to Test Nexus, generate the next property profile, switch to the app, autofill. Eight test listings created in the time it used to take to copy-paste one.

Beyond Property Listings: Any Schema You Need

The property listing was one example. AI Custom Forms works with any form structure you define. Here are schemas that QA teams commonly need but no standard test data generator covers:

Healthcare Patient Intake

Form: Patient Intake

Fields:
- Full name
- Date of birth
- Insurance provider (Aetna / BlueCross / United / Kaiser / Medicare / Uninsured)
- Insurance ID number
- Primary care physician name
- Reason for visit (text, 10-50 words)
- Current medications (list of medication names with dosages)
- Known allergies (list, including "None")
- Emergency contact name
- Emergency contact relationship
- Emergency contact phone

The AI generates medically plausible (but entirely fictional) patient profiles — realistic medication combinations, allergy lists that make clinical sense, and visit reasons that range from routine checkups to specific symptoms.

E-Commerce Product Listing

Form: Product Listing

Fields:
- Product title
- Description (100-300 words, persuasive marketing copy)
- Category (Electronics / Clothing / Home & Garden / Sports / Toys)
- Price (USD, 5-500)
- SKU (alphanumeric, 8 characters)
- Weight (kg, 0.1-30)
- Dimensions (L × W × H in cm)
- Color options (list)
- Stock quantity (number, 0-10000)
- Shipping class (Standard / Express / Freight)

Each generated product has a title that matches its category, a description written in marketing copy style, dimensions that make physical sense for the product type, and a shipping class appropriate for the weight.

Recipe App

Form: Recipe

Fields:
- Recipe name
- Description (1-2 sentences)
- Cuisine (Italian / Mexican / Japanese / Indian / American / Thai)
- Prep time (minutes)
- Cook time (minutes)
- Servings (number, 1-12)
- Difficulty (Easy / Medium / Hard)
- Ingredients (list with quantities and units)
- Instructions (numbered steps)
- Dietary tags (Vegetarian / Vegan / Gluten-free / Dairy-free / None)

The AI generates complete recipes — not nonsense text, but actual coherent recipes with ingredients that go together, instruction steps in logical order, and prep/cook times that make sense for the complexity of the dish. Your recipe app testing uses data that looks like what real users would enter.

Job Board Posting

Form: Job Posting

Fields:
- Job title
- Company name
- Location (city, state)
- Remote policy (On-site / Hybrid / Remote)
- Salary range (min-max USD)
- Job description (200-500 words)
- Required qualifications (list)
- Preferred qualifications (list)
- Benefits (list)
- Application deadline (date)

Each generated posting has a job title that matches the described qualifications, a salary range appropriate for the role and location, and a job description that reads like an actual posting — not placeholder text.

How Autofill Integration Works Technically

Android’s Autofill Framework provides a standard interface for apps to receive fill data from an autofill service. When you set Test Nexus as your device’s autofill provider, it becomes the source of fill data for any form on the device.

Setting Up Autofill

The one-time setup:

1. Go to Settings → Passwords & Accounts → Autofill service (path varies by device manufacturer).
2. Select Test Nexus as your autofill provider.
3. Done.

Field Matching

Test Nexus uses Intelligent Label Matching to map your generated data to form fields. It doesn’t just look for exact matches; it uses normalization strategies to handle variations in field names:

• Exact & Case-Insensitive Match: Matches “Email” to “email” or “EMAIL”.
• Normalized Match: Strips spaces, underscores, and hyphens to match “card_number” to “Card Number” or “CardNumber”.
• Standard Patterns: Automatically recognizes common patterns for standard fields (Name, Mobile, Address) and specialized financial data.

The system includes pre-defined support for:

• Personal Data: First name, last name, email, phone, SSN, CPF.
• Payment Cards: Cardholder name, card number, expiry date, CVV.
• Banking Info: Account holder, bank name, account number, routing number.

For custom fields (like “Property Description” or “Pet Policy”), Test Nexus uses the labels you defined in your schema to find the best match on the screen.

The Autofill Flow

1. You generate data in Test Nexus (via AI Custom Forms or DataHub).
2. You switch to your target app and tap on a form field.
3. Test Nexus identifies the fields using hints, labels, and metadata.
4. You accept the suggestion — all recognized fields are filled simultaneously.

ℹ️ When Autofill Can’t Match
Some apps use custom input widgets that don’t expose labels or metadata to the Android system. In these cases, Test Nexus still generates the data — you can copy individual fields from the generated profile and paste them manually. The data generation value is preserved even when automatic injection isn’t possible.

Custom Forms + DataHub: When to Use Which

Test Nexus has two data generation systems — DataHub and AI Custom Forms. They serve different purposes:

Think of it this way: DataHub is for structured data with known formats (cards, IDs, addresses, phones). AI Custom Forms is for everything else — the domain-specific fields that are unique to the app you’re testing.

They also combine naturally. A form that has both standard fields (name, email, phone) and custom fields (property description, listing price, pet policy) can pull the standard fields from DataHub and the custom fields from AI Custom Forms, giving you the validation guarantees of algorithmic generation for structured data and the contextual realism of AI for everything else.

Token Usage

AI Custom Forms uses tokens because each generation requires a Gemini API call. The token cost scales with the complexity of the form:

• Simple form (5-8 fields, short text) — lower token cost
• Complex form (15+ fields, long descriptions) — higher token cost
• Batch generation (multiple fills of the same form) — cost per fill

The token cost is displayed before you confirm each generation, so there are no surprises. Standard DataHub generation (card numbers, CPFs, addresses) remains free and doesn’t use tokens.

Your account starts with 20,000 free tokens — enough to generate dozens of complex form fills. When you need more, watch a short rewarded video ad to earn 200 tokens. No subscription. No credit card. No forced ads.

💡 Token-Saving Strategy
For repetitive testing of the same form, generate one AI fill to get realistic content, then modify individual fields manually for your specific test cases (e.g., change the listing price to test price validation boundaries, change the date to test date validation). You get the realistic baseline from AI and the specific variations from manual edits.

The Complete Workflow: Property Listing App

Here’s the end-to-end workflow that replaces the 720-tap manual data entry:

1. Define the schema (one-time, ~2 minutes) Open Test Nexus → AI Custom Forms → Create new form → Define “Property Listing” with 18 fields → Save

2. Generate 8 listings (~30 seconds) Tap Generate → Review the first listing → Generate again for each variant → All 8 are saved in Test Nexus

3. Test the app (~10 minutes for all 8 listings) Open the property listing app → Tap “Create Listing” → Tap the first field → Accept Test Nexus autofill → All 18 fields populated → Submit → Repeat for each of the 8 generated listings

Total: ~13 minutes for 8 complete test listings with realistic, varied content.

Compare to manual: ~75 minutes of copy-pasting and typing, producing 8 listings that all sound like the same person wrote them.

The time savings compound across your testing week. If you test 3 different complex forms across 5 apps, each with 8-10 iterations, you’re saving hours — not minutes.

Get Started

1. Set Test Nexus as your Autofill provider (one-time): Settings → Passwords & Accounts → Autofill service → Test Nexus
2. Create a form schema: Test Nexus → AI Custom Forms → New Form → Define your fields
3. Generate data: Tap Generate → Review the output
4. Fill your app: Switch to target app → tap form → accept autofill
5. Repeat: Generate new data for each test iteration

🚀 Stop typing “test” into every form field.
Define your schema once, generate realistic data with AI, and inject it into any app with Autofill.
Download Test Nexus →

What’s Next

• Post #06 — Terminal: full SSH, SFTP, and port forwarding from your Android device
• Post #07 — DataHub Deep Dive: country-specific formats, batch generation, and export options