There's a joke that a framework is a product with the business logic removed, but all the assumptions left in. In this talk we'll explore an alternative: solving the most common enterprise issues with the *composable* ecosystem of Typelevel libraries, avoiding not-invented-here (NIH) and lock-in. We've been involved in many enterprise projects, and have seen many recurring patterns implemented in an ad-hoc, fragile way. At the same time, and more often than not, any custom libraries rapidly develop "bit-rot", creating a maintenance burden. Instead we can be brave! We can avoid the sunk-cost fallacy by refactoring and retooling using powerful and *composable* abstractions. We can also trust we are reducing our risk because of the high quality of these open source projects. We'll dive deep into how to use the Typelevel stack to handle common tasks like data validation, integration with data sources and sinks, the modeling of actions associated with state machines, and more. We'll be using libraries like cats, cats-effect, refined, and more, to fix and extend existing systems to be more powerful, safer, and ultimately more maintainable.

Programming with hubris brings doom upon us: compiler and runtime errors. Instead, we can leverage humility by precisely declaring "I don't know" which allows us to defer decisions and implementation details until later. Having such a repeatable programming methodology allows us to avoid getting overwhelmed with details. Luckily Scala is excellent for this method: we can use the `???` method to defer implementation decisions, allowing us to focus on higher-level concerns that offer precise declarations of intent, along with a means of composition to build larger units of computation. We'll teach this method in Scala for you to employ anywhere: in "scratch" code, during design sessions, bug fixes, or feature development.