Latest Interviews

How To Convert Customers With Cold Emails | Startup School

Aaron Epstein

This event details a data-driven outreach framework where founders must personally execute high-volume email campaigns using warm introductions or targeted cold strategies to secure B2B customers. The speaker outlines a specific funnel architecture that requires sending dozens of daily messages while applying seven principles of effective copy, such as humanized tone, deep personalization, and clear calls to action, to maximize response rates. By analyzing case studies of both failed and successful campaigns, the presentation emphasizes that manual, founder-led execution is essential for building initial traction before any automation is introduced.

How To Keep Your Users | Startup School

David Lieb

YC Group Partner David Leib leverages his experience scaling Bump and Google Photos to argue that high cohort retention is the definitive quantitative signal of product-market fit. He details precise methodologies for defining user actions, selecting appropriate measurement intervals, and interpreting retention curve shapes to distinguish sustainable growth from a churn-heavy treadmill. By avoiding common analytical pitfalls and applying strategies like user acquisition targeting and onboarding optimization, founders can transform cohort data into a actionable roadmap for building scalable, long-term businesses.

OCaml's New Proposed "include functor" Syntax | OCaml Unboxed

Goldfirere

Jane Street is developing an "include functor" feature for the OCaml compiler that allows modules to directly include functor results based on their own preceding definitions. This innovation eliminates the need for cumbersome intermediate wrapper modules and manual reordering, streamlining the implementation of repetitive patterns like reverse array iteration. A working compiler version supporting this syntax is currently available for testing, with plans to upstream the feature to the mainstream OCaml distribution.

Down to the wires: Africa’s digital lag

Rosie Bloor, Jason Palmer, Ore Ogunbiyi, Sophie Pedder, John Bleasdale

The event analyzes Africa's critical digital infrastructure deficit, highlighting how energy shortages and regulatory barriers threaten to exclude the continent from $16 trillion in potential AI-driven economic growth. It further examines the Paris Olympics' environmental contradictions, where a billion-euro cleanup of the Seine failed to prevent bacterial contamination during the triathlon despite the river's vital role in global logistics. Finally, the discussion retrospectively evaluates the enduring success of the *Blair Witch Project*, detailing its record-breaking $250 million return on a $35,000 budget through innovative viral marketing and psychological storytelling techniques.

How To Price For B2B | Startup School

Tom Blomfield

Founders are advised to anchor pricing in a collaborative value equation that quantifies customer ROI, setting rates between 25% and 50% of that value to ensure healthy margins while retaining two-thirds of the benefit for the client. The strategy explicitly discourages cost-plus or predatory price wars, instead urging a shift toward recurring revenue models and short, metric-driven pilots to mitigate revenue volatility. By treating cloud credits as real costs and avoiding public price transparency for enterprise deals, this framework enables startups to secure sustainable growth without triggering a race to the bottom.

When you’re pre-product market fit, sales is a job for the founders.

The event asserts that early-stage B2B founders possess the unique capability to sell their products before achieving product-market fit, rendering external sales hires premature and ineffective. Success in this phase requires founders to leverage their vision for high-volume experimentation and establish tight feedback loops between sales efforts and product development. This distinction highlights pre-PMF sales as an exclusively entrepreneurial role, fundamentally different from the specialized functions assumed after a company validates its market.

Enterprise Sales | Startup School

Pete Koomen, Pete Kuhman

Optimizely co-founder Pete Kuhman outlines a rigorous enterprise sales framework for technical founders, emphasizing that selling before product-market fit requires experimentation with targeted prospecting and personalized outreach. The strategy prioritizes deep discovery during initial calls, uses product-specific narratives to demonstrate value during demos, and treats pricing as a signal of problem severity rather than a fixed metric. By actively managing implementation roadmaps to ensure customer adoption and navigating procurement hurdles with internal champions, founders can transform sales skills into a transferable superpower for fundraising and hiring.

Programming with OCaml's Local Mode | OCaml Unboxed

Jane Street Doe Camel

A Jane Street team member demonstrates practical limitations of the OCaml "Locals" region-based memory management system while optimizing the `best_of_prime_widgets` function to avoid heap allocation. To resolve type mismatches where local lists must escape their regions, the implementation employs a custom zero-overhead `global` wrapper type alongside a recursive map function annotated with `exclave` constraints. Although the solution successfully maintains local allocation for list structures while treating elements as global, the speaker identifies these manual workarounds as sharp corners requiring future improvements through mode polymorphism.

Regions with OCaml's Local Types | OCaml Unboxed

Jane Street researchers introduce a `regional` variant within the OCaml compiler's `locals` feature that treats function parameters as variables permitted to escape their enclosing region exactly once. This mechanism enforces strict type constraints on return values while enabling critical stack allocation optimizations in recursive tail calls and loop iterations. By defining regions around function and loop bodies, the system prevents $O(N)$ space complexity for local data without compromising the language's type safety guarantees.

Exploring the Hidden Secrets within OCaml’s Local Function Types | OCaml Unboxed

Jane Street's OCaml compiler branch enforces strict region safety by automatically inferring hidden `local` annotations on partial applications of functions with local arguments, preventing closures from escaping their intended stack scope. This mechanism triggers compilation errors when such intermediate closures are passed to standard functions like `List.map`, as they attempt to store local data in global heap structures, though these issues can be resolved by fully applying the function or utilizing explicit type expansions. Consequently, the team is considering syntax modifications to function definitions to make these constraints more explicit and prevent accidental region escapes during currying.

Probably not.

Founders of free consumer apps are advised to avoid paid user acquisition because it typically generates only temporary metric spikes while failing to address underlying growth limitations. Sustainable scaling instead relies on discovering non-obvious, low-cost distribution channels that bypass the need for expensive marketing campaigns. Paid spending is reserved exclusively for strictly bounded experiments with predefined learning objectives, serving as a tool for insight rather than a strategy for long-term revenue generation.

Pitfalls with Tail Calls and Locals in OCaml | OCaml Unboxed

Goldfirere

Jane Street researchers developed a "local mode" for their OCaml compiler to optimize memory allocation on the stack, but discovered that standard tail call optimization causes "local value escapes" errors when recursive closures capture variables from a region that ends immediately before the call. To address this, the team introduced a "regional" sub-mode that permits specific values to escape one region boundary, allowing tail-recursive functions to maintain $O(1)$ stack space without explicit `non-tail` annotations, though passing these values through intermediate functions can strip this status and force $O(n)$ allocations. The developers acknowledge that current workarounds like explicit annotations or variable indirection are cumbersome for practical use, prompting a push for better compiler heuristics to automate safe tail calls in future upstream releases.

Stack Allocation with Locals in OCaml | OCaml Unboxed

I

Jane Street is developing an open-source "local mode" branch for the OCaml compiler that reallocates data onto a specialized local stack to eliminate mark-and-sweep garbage collection pauses. By enforcing strict regional scoping where values cannot escape their lifecycle, this architecture enables constant-time deallocation and prevents the cache invalidation and stop-the-world latency inherent in standard heap allocation. The initiative aims to significantly boost low-latency performance by removing the overhead of garbage collection while maintaining memory safety through a novel mechanism called "exclaves."

OCaml Locals Save Allocations | OCaml Unboxed

goldfirere

Jane Street demonstrates how a specialized OCaml compiler reduces memory allocation by introducing the `local` keyword, which restricts value lifetimes to specific function and loop regions. This approach requires replacing standard library functions like `list.iter` with custom implementations that explicitly label arguments as `local` to prevent value escapes, achieving a 50% reduction in word allocations in benchmark tests. Further refinements with the `exclave` keyword and strict type inference drive allocation overhead to near-zero, thereby minimizing garbage collection latency for the experimental feature planned for future upstream integration.

Inferring Locality in OCaml | OCaml Unboxed

The OCaml compiler utilizes an internal allocation discipline that infers local versus global modes for variables and parameters to enable stack-based memory usage and reduce garbage collection overhead. This system prioritizes local inference for arguments while defaulting return values to global to ensure maximum compatibility, with integers serving as a special case that can safely cross mode boundaries under specific annotations. Although this framework enhances performance, current limitations such as standard library functions lacking locality awareness and the need for explicit type signatures to trigger safety checks continue to shape its practical application.