A goal for enterprise applications has been to provide “exactly once” execution regardless of system failures. This has classically required “stateless” applications that manage their states explicitly via transactional resource managers. Support for “stateful” applications requires the system to do more to manage state, which has been considered too difficult and costly. The Phoenix/App system manages application state transparently by logging interactions between components to guarantee “exactly once” execution. But logging for availability and scalability requires that the log be accessible by multiple processors. For middle tier session-oriented components, interactions need not be logged in order for them to be recoverable. Because there is no logging, performance of failure-free execution is excellent and no log need be moved to relocate the application on a different processor. Functionality has been restricted however to only idempotent interactions with backend servers. Here we show how such logless components can execute non-idempotent reads and yet be recoverable, by exploiting “faithless replay” where the original execution path might not be re-executed. The result is highly capable recoverable session-oriented components that are easily redeployed within an enterprise application system that requires high availability and scalability.