business

Verdict

Submitted 5/13/2026, 9:52:40 AM · Completed 5/13/2026, 9:54:39 AM

6.5
pivot
The idea

Using a separate table to split records to fields in Power Query

Pain point
Manually splitting large, unstructured text records into structured fields in Power Query is time-consuming and inefficient.
Who has this problem
Excel users working with large datasets of unstructured text records
Contradiction (TRIZ)
Need to process large datasets efficiently but lack automated tools for structured splitting
Ideal final result
Automated splitting of unstructured text records into structured fields without manual intervention
Suggested solution
Use Power Query with a custom function that leverages the field position table to automatically split records based on field lengths
Show original source text →
Hello there! I have multiple big, big text files containing ten-thousands of records, and more than hundred fields per records where the fields are not separated by anything and are varying length. (I mean varying from one field to the next. They are consistent from one record to another. Otherwise I wouldn't even bother.) Like so: `13051980011120...` `11091991101021...` `...` And I also have a nice table that contains the name of each field and how long each field is which I can easily expand to contain what position each fields starts at as well. Like so: `DeptId, 4` `DoB, 8` `TitleId, 2` `...` Is there a way to use this table to tell Power Query to split up my long records accordingly? Neither Split Columns nor Text.Range is much fun if you have to manually repeat it more than hundred times. I know I could technically put the table in the first row of a spreadsheet, transposed, and I could paste the big records in the first column and use Mid() to split it up, then import that into Power Query but this is a lot of formulas and also I was hoping to bypass copying/pasting by creating a query from folder. Thanks a bunch in advance, even if it's a fool's errand.
TRIZ inventive level: 3/5· Principles: parameter changes
Synthesis verdict
**Pivot**. The idea of automating fixed-width text file parsing using a schema table in Power Query addresses a real pain point with clear ROI for automation. However, the lack of a clear monetization strategy and defined customer segment limits the venture's scalability and profitability. The technical solution is feasible, but the business model needs refinement. The market demand is substantial, particularly in industries like finance, healthcare, and logistics, but the venture must develop a robust and dynamic Power Query script to mitigate platform limitations and attract paying customers.

Strengths

  • - Addresses a real, painful, and common problem in data processing
  • - Clear, documented schema (field names + lengths) and large volume of records
  • - Technically feasible solution using Power Query or scripting language
  • - Substantial market demand in various industries
  • - Scalable and reusable solution reducing manual effort

Weaknesses

  • - Lack of clear monetization strategy and defined customer segment
  • - Platform risk due to Power Query's limitations in dynamically handling over 100 fields
  • - Potential churn if field structure changes frequently
  • - No-budget customers might opt for manual parsing or basic scripting solutions
  • - Need for a custom M script in Power Query, which may require higher technical skill

Best angle

Develop a scalable, dynamic Power Query script and refine the business model to target enterprises with legacy data systems, offering a subscription-based or freemium pricing strategy.

Panel verdicts

Competition

no model

This agent failed to return a verdict (executor exception: 'NoneType' object has no attribute 'strip'). The synthesis ran with the remaining agents.

Viability

meta/llama-4-maverick-17b-128e-instruct

8.0

“The availability of a schema table containing field names and lengths makes it feasible to automate the parsing process.”

The task involves parsing large text files with unstructured data using a provided schema. The schema contains field names and their corresponding lengths, which can be used to split the records into structured data. A solo or 2-person team can build a solution to automate this process using Power Query or a scripting language like Python. The main challenge lies in handling the varying field lengths and creating a robust parsing logic. However, the availability of the schema table simplifies the task. The team can create a script or query that reads the schema table and uses it to split the records accordingly. The time-to-build estimate is around 8-10 weeks for a robust solution, considering the need to handle large files and potential edge cases. The required talent includes proficiency in Power Query or a scripting language, as well as data processing and parsing expertise.

Monetization

mistralai/mistral-medium-3.5-128b

3.0

“A technical solution without a monetization strategy is not a viable business.”

The idea lacks a clear monetization path. While the technical problem (parsing fixed-width text files) is solvable and has utility, the venture as described does not outline a revenue model, pricing strategy, or target market. The value proposition is limited to a niche use case (automating fixed-width file parsing in Power Query), which may not justify a standalone business. Without a defined customer segment (e.g., enterprises with legacy data systems), pricing (e.g., one-time fee, subscription, or freemium), or distribution channel (e.g., Power Query add-on, SaaS tool), the venture's scalability and profitability are uncertain. The cost-to-serve (e.g., development, support) could outweigh revenue unless demand is high and concentrated. The idea scores low because it fails to address how it captures value beyond solving a technical pain point.

Risk

nvidia/llama-3.3-nemotron-super-49b-v1

8.0

“Success hinges on developing a scalable, dynamic Power Query script to mitigate platform limitations and attract customers willing to pay for automation.”

The proposed solution leverages existing tools (Power Query, Excel) with a clear input (field length table) and output (parsed records). However, the venture's viability is threatened by **platform risk** due to Power Query's limitations in dynamically handling over 100 fields without manual intervention. While a script could theoretically automate the process, **churn** might occur if the field structure changes frequently, requiring repeated script adjustments. Additionally, **no-budget customers** might opt for manual parsing or basic scripting solutions due to cost sensitivity, limiting the venture's market.

Market

mistralai/mistral-small-4-119b-2603(fallback #2)

9.0

“Fixed-width data parsing is a widespread pain point with clear ROI for automation, making this a high-value niche for data professionals and tools like Power Query.”

This idea addresses a real, painful, and common problem in data processing: parsing fixed-width text files where fields are not delimited and vary in length. The user has a clear, documented schema (field names + lengths) and a large volume of records (tens of thousands), which indicates a non-trivial data volume that would benefit from automation. The pain point - manually repeating split operations 100+ times in Power Query - is highly relatable for anyone working with legacy systems, mainframe exports, or poorly formatted data dumps. The proposed solution (using a metadata table to dynamically split fields) is technically feasible and aligns with Power Query's capabilities, particularly with custom functions or advanced transformations. The audience is well-defined: data analysts, ETL developers, or business users who inherit unstructured text data and lack engineering resources to preprocess it. The willingness to pay is high because this problem often blocks downstream analytics, reporting, or integration workflows. The market size is substantial: industries like finance (transaction logs), healthcare (HL7 messages), logistics (EDI feeds), and government (archival records) frequently deal with fixed-width data. These organizations have budgets for data tools (e.g., Power BI, Alteryx, Talend) and consultants to solve such parsing challenges. The user's approach - leveraging a schema table to automate splitting - is scalable and reusable, reducing manual effort from hours to minutes. The only minor friction is the need for a custom M script in Power Query, but this is a one-time setup. Competitive alternatives (e.g., Python scripts, specialized ETL tools) exist but require higher technical skill or licensing costs, leaving a gap for a low-code solution. Thus, the demand is real, the audience is sizable, and the budget exists within organizations that prioritize data usability.

Synthesized by meta/llama-3.3-70b-instruct · 6.8s