A group opening (? must be followed by a recognised modifier. Only specific characters are valid after the ? and anything outside that set makes the group type unrecognisable.
After < inside a group, only = for a positive look-behind and ! for a negative look-behind are valid. Any other character makes the group type unknown. Use (?<=...) or (?<!...).
After the opening ?, only : for a non-capturing group, = for a positive lookahead, and ! for a negative lookahead are recognised. Any other character is not a valid modifier.
Misplaced quantifiers and anchors
A quantifier must always follow a character, set, or group. It cannot appear at the start of a pattern or right after another quantifier. Anchors are only valid at the top level of a pattern, in a fixed position.
*a also +a, ?a
A quantifier at the start of a pattern has no preceding element to apply to. Move it after the character or group it should repeat — a*, a+, a?.
a**
Two quantifiers in a row, the second one has nothing new to apply to. One quantifier per element is enough.
a$b
The $ anchor marks the end of the input, so no characters can follow it at the top level. Anything written after $ cannot be matched, making the pattern contradictory.
a^ and ^^a
The ^ anchor is only valid at the very start of the top-level pattern. Once any term has been parsed, a ^ mid-expression has no valid meaning. In ^^a, the first ^ is consumed normally, leaving the second one stranded.
(^a) and (a$)
Anchors inside parentheses are not supported. Even if ^ appears at the start of the group content or $ at the end, they are still inside a nested context. Anchors must stay at the top level of the pattern.
Nested quantifiers
Unlike the cases above, nested quantifiers are not a structural error, the pattern is syntactically valid and the parser can read it. The problem is performance. When a respondent enters input that does not match, the engine has to explore an exponentially growing number of combinations before it can confirm the failure. On a long input string, this can freeze the browser entirely. Zoho Forms detects this category of pattern when you save and blocks it before it can affect your respondents.
(a+)+
A group with a quantifier, containing another quantifier inside it. For valid input like aaa this works fine, but for input that does not match, say aaab, the engine has to explore every possible way the two quantifiers could divide the characters between them. The number of combinations grows rapidly with input length.
(a*)*
The same structure using *. Since * also allows zero repetitions, the engine has even more combinations to try on a non-matching input. This is one of the most common forms of the problem.
([a-z]+)*
A character class with a quantifier, wrapped in a group with another quantifier. The nesting does not have to involve a single character, any repeating element inside a repeating group creates the same risk.
To avoid this, use a bounded range like {n} or {min,max} on the inner element rather than stacking open-ended quantifiers on top of each other.