Why do Selenium teams replace @FindBy proxy fields with By constants and driver.findElement at the call site?

## What the proxy keeps to itself `DefaultElementLocator` stores the `By` it built from the annotations in a private field and never exposes it. The proxy in front of it implements `WebElement`, `WrapsElement` and `Locatable`, and none of those returns a locator. So a page-object method that owns a `@FindBy` field owns a thing it can *call*, not a thing it can *describe*. The only route from the field back to the locator is textual and conditional: `LocatingElementHandler` returns `"Proxy element for: "` plus the locator from `toString` **only when the element was not found**, and that is a `String`, not a `By`. `WrapsElement.getWrappedElement()` is the other seam, and it is a narrow one. The handler special-cases it: it runs the lookup and returns the real `WebElement` behind the proxy. That hands you a concrete handle — and from that moment you own its staleness, because the returned element is an ordinary reference with no re-finding behind it. ## Where the missing locator bites - A method cannot hand the field's locator to anything that takes a `By`: a `WebDriverWait` condition built from a locator, a scoped `element.findElement(by)` under a component root, or a log line that names what was searched for. - A method cannot ask whether the element is absent without provoking the failure; a `WebElement` proxy has no "did you find it" question, only calls that throw `NoSuchElementException`. - Using the field as the search context for a child lookup works, but it costs its own `findElement` first, once per child — the parent is re-located every time you scope through it. - The failing frames name a `jdk.proxy` class and `LocatingElementHandler.invoke`, so the trace reads as a page-factory failure rather than as the step that broke. ## The plain-`findElement` shape Moving back means declaring the locator as a value and doing the lookup where the work happens: ```java private static final By PICKUP_WINDOW = By.id("pickup-window"); public String windowLabel() { return driver.findElement(PICKUP_WINDOW).getText(); } ``` The `By` is now an ordinary constant. It can be passed to a condition, composed into a nested search, printed in a message, asserted on in a unit test of the page object, or shared between two methods that need the same region of the laundry pickup scheduler. The lookup happens on the line you wrote, so the stack trace names `windowLabel`. ## What you give up by moving back - The declarative field block that reads as a description of the page — a list of `@FindBy` fields is genuinely good documentation. - The `ByIdOrName` fallback, which lets an unannotated `WebElement` field work by matching the field's own name against `id` or `name`. - `AjaxElementLocatorFactory`'s built-in polling, which arrived free with the proxy and now has to be composed explicitly wherever it was doing real work. - One uniform place where every field's lookup happens, replaced by a lookup at each call site. ## The comparison, side by side | | `@FindBy` proxy field | `By` constant plus `findElement` | |---|---|---| | when the lookup runs | inside the proxy, before every method call | on the line you wrote it | | locator reachable as a value | no | yes | | frame that fails | `LocatingElementHandler.invoke` | your page-object method | | built-in polling | yes, under `AjaxElementLocatorFactory` | no — composed by hand | | unannotated field works | yes, via `ByIdOrName` on the field name | not applicable | | absence check on a single element | only by catching the exception | `findElements(by).isEmpty()` | ## Choose per field, not per suite This is not an all-or-nothing switch, and treating it as one is the usual mistake. 1. Keep proxy fields for the parts of the page a method only ever reads or clicks, where the locator never needs to travel anywhere. 2. Use a `By` constant wherever the locator itself has to be passed on, scoped under a component root, or named in a message. 3. Keep both in the same page object when that is what the page needs; the two mechanisms coexist because `PageFactory.initElements` only replaces fields it recognises and leaves a `private static final By` alone. The judgement is mechanical, not philosophical: ask whether the method needs the locator or only the element.