Agent 原生云:300万用户、每周10万注册、数据中心与死亡 PR——Railway 的 Jake Cooper
Railway 的核心押注是,未来10年,agents 将成为软件构建的主导“物种”,因此 agent-native 基础设施会成为一种长期平台迁移,即便今天的热潮最终撞上推理瓶颈。 Jake Cooper 沿着从 assembly 到 C、C++、JavaScript,再到“文字”的抽象阶梯展开分析;终点是数千个 agents 并发工作,此时协调、安全干预和算力效率的重要性将不亚于代码生成。
这条增长曲线是6年扩张、痛苦收缩,以及有意修复糟糕单位经济性的结果。 Railway 曾每月烧掉约50万美元,而月收入可能只有5万美元、银行余额为2000万美元;免费用户又吸引了 bots 和 crypto miners。公司一度限制免费使用,重建业务,如今只有35名员工,却每周新增约10万用户。讨论中同时出现了200万和300万用户两个数字。Cooper 不认同理想化的持续向上曲线:“你其实不希望图表长成那样。”
裸金属既是 Railway 的利润引擎,也是支撑大规模并行 agents 的经济缓冲。 Cooper 表示,购买硬件相较于租用等量云容量约3个月即可回本,尽管硬件按4年折旧;metal workloads 的毛利率约为70%。Railway 称如今绝大多数 workloads 已运行在自有数据中心,只有突发需求才使用 hyperscalers。其运营原则是绝对的:“你永远、永远、永远不该再等算力。你永远应该等的是 intelligence。”
Railway 的架构护城河,在于它能控制网络、算力、存储和编排,并把这些能力推到传统抽象可能失效的 workload 规模。 Agents 需要许多与人类相同的基础设施——版本控制、feature flags、logs、traces、files、snapshots——但速度要快“1000倍”;Cooper 预计传统 CI/CD 会“融化”,认为 Git 之外可能会出现新的东西,并希望每个组件都能在 super-exponential workload 暴露下一个瓶颈时被随时拆除。
Agent interface 颠倒了传统产品设计:复杂度变成有用的输入,而图形化画布则成为审批和上下文界面。 人类可能讨厌一个带40个 arguments、600个 flags 的 CLI,但 agent 看到的是“这么多抓手”;Railway 衡量 agents 在哪里偏离 happy path,再增加抓手来闭环。因此,画布从输入端转向输出端,成为“风暴中的港口”:人类在这里理解变化、保留共享上下文,并批准或拒绝 agents 的操作。
没有廉价的生产级分叉、渐进式交付和可逆状态,自主修复就不安全。 Cooper 仍不相信可以把 AI SRE 直接放进生产环境:如果没有 copy-on-write volumes、只读生产数据、PII 转换、可观测性和受限 blast radius,“这不是它会不会炸掉数据库的问题,而是它什么时候会炸掉数据库的问题”。Railway 的答案是让 agents 克隆服务和状态,在接近生产的环境中验证假设,再合并或丢弃结果。
Railway 每月约30万美元的 coding-agent 支出,押注的是工程产出,而不是节省 token。 Cooper 个人每月使用约2.5万美元,并对这家35人的公司说:“如果你还在手写代码,那你就做错了。”工程师应当审查并整合生成的代码,而架构判断的重要性比以往更高。他提出的 ROI 指标,是最终进入生产环境的 token 占比;最优秀的操作者应被视为值得驾驶“300万美元赛车”的 F1 车手。
竞争重点与技术野心同样重要:Railway 不想只成为“新的 Heroku”,目前也暂不提供 GPUs。 Cooper 认为 Heroku 停滞的原因,是它在 Salesforce 核心业务之外处于边缘位置;Railway 则希望掌控完整的构建与部署闭环,但不照搬 hyperscalers 的架构。他明确表示 Railway 现在不会提供 GPUs,但未来“100%会提供”,因为垂直整合的基础设施最终需要 FLOPs——这更像是对发展顺序的清晰说明,而不是拒绝扩张范围。
1. Railway 想给应用演进做版本控制,而不只是部署代码
Cooper 对产品的简洁定义是“交付任何东西的最简单方式”:使用画布或直接和 Claude 对话,要求一个 Postgres 实例、一个 GitHub repository,或者运行任意代码,随后无需自行拼装底层云基础设施,就能完成部署。
更大的目标,是停止通过 Docker、Kubernetes、Ansible scripts 以及彼此独立维护的环境,不断“在熵上叠加熵”。Railway 想给整个软件系统做版本控制,让用户可以克隆环境、分叉出一个“平行宇宙”、复制生产数据和服务、验证变化,再把成功的分支合并回来。
这意味着部署只是第一步。真正持久的闭环是应用演进:创建基础设施、观察它、修改它、测试修改后的宇宙,并在不重新搭建一套日益分叉的 staging stack 的情况下完成合并。
2. 产品体验一次次把 Cooper 拉向更深的技术栈
Cooper 从前端工作一路走到 Bloomberg 和 Uber,并不是因为早早规划好了一条基础设施履历,而是出于好奇。在 Uber,让 JUMP bikes 的体验变得无摩擦,最终把他带进了构建在 Cadence 之上的分布式系统;Cadence 后来成为 Temporal 的前身。
他的工作原则是:“游到泳池底部,把体验做好。”因此,Railway 从易于上手的部署界面一路下潜到裸金属数据中心、自研编排、存储、eBPF,甚至 Linux kernel patch。
这些 kernel 工作针对的是 Railway 面向 agentic workloads 的存储层,目前还不是准备提交到 upstream 的 patch。Cooper 更大的判断是:“任何东西都能想办法解决。”深度不是产品本身,但只要某个深度阻碍了目标体验,就没有哪一层不能进入。
3. 6年增长曲线中包含一段代价高昂的经营周期
Railway 最初的100名用户是在“上天无路、入地无门”的情况下获得的。它的 support link 直接通往 Discord,Cooper 把频道开在第二块屏幕上;每来一个用户都十分稀少,因此他可以立刻打招呼,同时试图弄清楚是什么让他们愿意回来。
早期需求催生出一座“咨询工厂”:用户提出彼此无关的功能要求,迫使 Railway 区分出一个连贯的产品,而不是一堆定制服务。Cooper 将这个过程描述为扩张与收缩交替进行:先增加能力、测试不同 use cases;再进入 compaction,移除干扰,让选定的体验显著变好。
2022—2023年的免费 tier 带来了注册量,也吸引了 Reddit bots、crypto miners 和互联网滥用。那段时间,Railway 每月亏损约50万美元,银行里约有2000万美元,而月收入可能只有5万美元;公司一度限制免费使用,并围绕可持续业务重建。
如今 Railway 有35名员工,每周新增约10万用户。讨论中同时出现了200万和300万用户两个数字;工作日 activation,以及暑假或冬季假期期间明显的低谷,越来越反映出公司的 B2B 结构。
4. Agents 是类似 dot-com 的长期押注,不是6个月的功能周期
Railway 早期把 agents 当作 top-of-funnel 机会,随后在过去6个月里深入将其定位为构建与部署机制。Cooper 的判断是绝对的:软件抽象已经从 assembly 经过 C、C++ 和 JavaScript,走到了“文字”。
他保留了 dot-com 类比中的风险:狂热可能撞上物理、经济学或 inference bottleneck,就像互联网公司曾经集体回归现实。但互联网仍然改变了生活,因此长期决策仍然是为它建设;他认为 agents 也属于同一类机会。
数千个并行 agents 带来两个不同问题。Inference 和算力必须变得便宜得多,但协调同样没有解决:agents 需要安全地对变化做版本控制、彼此协作,并知道何时“举手”,同时又不能把人工监督变成“一个疯狂的 interrupt factory”。
5. 裸金属带来3个月回本期,也抬高了产品上限
Railway 想直接控制网络、算力、存储和编排,包括 Kubernetes 没有暴露、但 Railway 所需控制粒度下的 workload placement。内存复用和精确放置都很重要,因为低效运行数千个 agents 会“让你的成本结构大幅、大幅膨胀”。
建设一个站点的起点很朴素:从 Equinix 这样的 colocation provider 租电力和机柜,放入机架与服务器,再接入互联网。Cooper 表示,Railway 在其他每个区域都有两个数据中心,而 Singapore 计划在 Q3 获得第二个站点。
Cooper 估算,购买 metal 与租用云容量相比约3个月回本,尽管硬件按4年折旧。Railway 的服务器甚至在融资后升值,因为 RAM 价格上涨;他将这种稀缺性与 hyperscalers 在被引用年份约800亿美元的资本开支作对比。
一位主持人对 space-data-center 的质疑暴露了 Cooper 的认知边界。他认为这个想法或许能解决,但尚未看到有人证明如何在真空中以那种规模散热;主持人追问热力学约束,而 Cooper 认为一个项目究竟是“骗局”还是可行但疯狂的方案,投资上的判断只能像抛硬币,数年后才会揭晓。
6. 混合 bursting 让增长不再受制于采购周期
Railway 起步于 public clouds,后来为自有 metal 搭建迁移能力,如今必要时反向使用这套流程:突发性地转移到 AWS、GCP 或其他 provider,等空间、电力和硬件到位后,再把 workloads “compact”回自有服务器。
当上游 provider 无法及时提供 quota、现有硬件速度又更慢时,这种灵活性变得至关重要。一次紧急事件中,Cooper 花了一个周末重建 Railway 的 network overlay,让系统跨越5个环境运行:Oracle、AWS、GCP、Railway 自有基础设施,以及另一家 cloud;过度紧密的资源打包也曾加剧可靠性问题。
约70%的 metal margins 可以补贴昂贵的 bursts,避免公司因为短期需求而拒绝业务。因此,只要 Railway 能让构建与部署闭环保持简单,并以足够的运营纪律配置资本,收入就可以大致跟随算力部署速度增长。
7. 硬件债务与 venture equity 解决的是不同问题
Railway 的容量规划结合了自有 metal、云端溢出、现金、硬件抵押债务和 venture capital。Cooper 称这是真正有意思的运营问题:应该购买多少容量、安装需要多快,以及每项资产应对应哪一种融资工具。
其服务器融资以硬件作为抵押,利率约为 prime 加上利差,并可随着未偿债务下降而再融资。Cooper 不接受脱离上下文的“venture debt bad”标签:这是“data-center debt”,对应具体的生产性资产,而不是泛泛替代 equity。
由于 venture capital 是最昂贵的融资方式,创始人应该问自己,每一次稀释能买到什么“unfair advantage”。Railway 在不同阶段选择投资人时,分别看重创始人指导、产品自主权、运营扩张和企业客户渠道,目标是让董事会围绕“我们如何赢?”达成一致,而不是争论基础战略。
8. Agent 规模保留基础设施原语,却会打破它们的实现方式
Agents 仍然需要 feature flags、版本控制、可观测性、files、snapshots、网络、算力和存储。区别在于速度与并发:“我们只是快了1000倍”,因此现有工具必须变得强大得多,即使概念层面的需求没有变化。
Cooper 预计 CI/CD 会“融化”,并认为编排可能需要超越 Kubernetes,网络可能需要超越 Envoy。新的并行化突破随时可能把瓶颈推向别处,因此每一层都必须可替换,不能被当成永久架构。
他提出一个挑衅性的框架:GitHub 的“原罪”是一堆断裂的 pointers。Cloning 把项目与 upstream 分离,而 merging 把变化当作离散事件处理。他设想一种按百分比或非确定性版本控制的方式,让更新在不同人群中渐进式流动。
这一过程应该从影响较小的用户开始,例如“Johnny Vibe Coder”,而 JPMorgan 这样的机构则排在 patch line 的最后。必须有人吸收现实世界的熵,但 blast radius 应该按照失败成本明确排序。
9. 面向 agents 的 CLI,恰恰受益于会劝退人类的复杂度
如果给人类一个拥有40个 arguments、600个 flags 的 CLI,人类会拒绝学习;agent 的反应却是:“这太棒了。”每个 argument 都是一个额外抓手,用于查询动态状态、采取行动,并闭合 build-observe-correct loop。
Railway 会对这些闭环做 instrumentation。如果 telemetry 显示,有12%的 journeys 在某条 command 上偏离 happy path,那么加入缺失的 argument,把这一比例降到2%,就能显著提高整个用户群的成功完成率。
Cooper 将产品旅程定义为:用户听说 Railway,完成第一次绿色构建、获得 endpoint 或有用的 log,然后进入无尽迭代。目标是摧毁所有算力等待:“你永远应该等 intelligence”,因为任何持续存在的算力瓶颈,最终都会让用户去寻找另一套工作流。
他预计 push-pull-rebuild 式部署本身会消失。生产环境中的一个小变化,应当在基础设施与 copy-on-write 数据上完成版本控制,与线上系统一起测试,然后瞬间合并进生产环境。
10. 画布变成输出界面与共享记忆
主持人认为 Railway 著名的视觉画布原本是为人类设计的,而 CLI 如今对 agents 更重要。Cooper 同意这个方向:画布正从输入设备转向输出界面,用来展示基础设施和 agents 做了什么变化。
它对人类的任务,变成呈现足够信息,让人批准或拒绝某个控制请求。Cooper 称其为“上下文的锚点”和“风暴中的港口”:这是一套可以从项目逐层深入服务、函数、代码、基础设施以及任意嵌套上下文的层级结构。
共享表示很重要,因为当一个 microservice 只存在于某个人的脑子里,组织就会变慢。Cooper 认为,足够结构化的上下文可以支撑规模大于今天协调系统所能容纳的“hyperstructures”;相比之下,Slack 和 Discord 仍然反复进行“消息传递与 interrupts”。
Railway 内部的 Central Station 会把支持对话和反馈汇总成动态 clusters,识别正在酝酿的 incidents,衡量受影响用户,并把讨论导向最接近相关 subsystem 或 commits 的人。讨论还提到,公司如今大约是2023年相关工作时期的10倍规模,但没有明确说明“规模”具体指哪个指标。
11. 渐进式发布与充分披露,都是可靠性原语
最近一次 incident 影响范围约为3000名用户,起因是某个上游 provider 的行为与其自身 RFC 文档不一致,导致 cache-invalidation failures。Central Station 发现了最初报告,Railway 随即禁用 rollout,之后进一步加固了受影响系统。
Cooper 的披露政策是,宁可冒着说得太多的风险,也不让用户觉得 provider 在对他们进行 gaslighting。Railway 把这一选择根植于“honor”价值观:通知所有可能受影响的人,正视失败,并解释将如何降低复发概率。
Railway 通过 incremental rollout 限制 blast radius。Cooper 以 Meta 同时运行多个生产版本为例,认为 agents 也需要 shadow traffic 和安全的行为变体;Railway 的大客户只有在低影响 cohort 充分验证变化后,才应获得高度稳定的版本。
他设想的版本流可能从0.1%走到1%,再经过 early adopters,最终覆盖全部用户。多数成熟公司都会在内部建设这套 machinery,这也为把它整合进平台基础设施留下机会。
12. AI SRE 需要生产级分叉,之后才有资格获得写入权限
Cooper 承认,observability agent 提出的修复中,大概80%看起来会合理。危险在于剩下的长尾:一个看似合理的修复如果直接写入生产环境,可能制造 incident,除非平台限制其影响,并把回滚做成结构性能力。
传统 staging 不够用,因为它会与生产环境逐渐漂移。Railway 希望 agent 能克隆任何受影响的服务,挂载生产数据的只读或 copy-on-write 版本,在必要时转换 PII,运行自己的假设,并呈现一个供人类审批的新基础设施状态。
Cooper 把这个 agent 想象成一个在代表画布的透明板下移动的人:它识别需要的服务,只复制系统中相关的那一片,在接近生产的环境里运行实验,然后合并经过验证的分支,或者将其丢弃。
他对 AI 的看法变化是有边界的。直到2024年,他总体上对 AI 持怀疑态度;2025年,他说自己可以信任它;冬歇期后,他表示 AI 已经变成“用错它反而比用对它更难”。但在没有安全的存储与部署原语之前,他仍然拒绝自主 AI SRE。
13. Specs、代码与测试,让模糊智能与离散系统彼此校准
Cooper 并不主张用模糊逻辑取代确定性软件。Skills 应当调用具有静态结构的代码或应用;agent 可以提炼流程,但执行仍然需要传统约束。
他正在形成的三部分系统是清晰的 specification、代码和 tests——本质上是把熟悉的 RFC、实现和验证 artifacts 放在一起。如果 spec 与 tests 一致但代码失败,agent 就修正代码;如果另外一对出现分歧,它就处理三角形中对应的一边。
他把没人真正实现的复杂“software factory”图表斥为“architectural astronomy”,但认为 reconciliation loop 本身就是 agentic development 最终会落脚的地方。
Railway 已经可以承载一种递归版本:把 Railway CLI 安装在运行于 Railway 上的 agent 内,让它认证自己的环境,允许它 provision Postgres 或其他服务,再调用
railway deploy重新部署自己。安全、廉价、可丢弃的副本,让自我修改从噱头变成迭代式生产工作流。
14. 下一代 serverless 模型应当无限期运行、有状态且完整使用 Linux
Cooper 认为 Railway 位于 static servers 与传统 serverless 之间:workloads 可以有状态、长期运行,但用户只应为实际消耗的资源付费,而不是无限期预留一台闲置机器。
原子部署单元必须瞬间启动、运行任意时长、提供完整的 Linux 环境,并且能够低成本消失。这延续了 Railway 6年来的坚持:用户需要“一台会说 Linux 的 box”,以及灵活的网络、算力和存储。
当1000个 agents 都复制4个 vCPUs 和16 GB RAM 这样的静态 allocation 时,成本会变得不可承受。Resource sharing、snapshots、lazy loading 和更紧密的 scheduling,必须在不复制固定实例经济学的前提下保留通用计算能力。
15. Heroku 的衰落,是战略邻接关系的警示
Cooper 对知名公司要求 Railway 将 workloads 从 Heroku 迁出的现象并不意外。他的解释是组织层面的,而非技术层面的:Salesforce 的业务是 CRM,而被收购的计算基础设施只是一个旁支,必须在预算、人才、注意力和使命上与内部其他方向竞争。
主持人指出,Heroku 的公开沟通庆祝了一段“不可思议的旅程”,却没有明确宣布关闭;Cooper 则说,据称私下给客户的指导是,在服务逐步弃用时关闭账户。这一集保留了两者的区别,没有把公开声明当成一份干净利落的终止通知。
Heroku 奠定了 Cooper 自己对部署的早期理解,但 Railway 不想背负“新的 Heroku”这一受限身份。它想成为软件构建、部署以及最终变现的方式;熟悉的游戏循环可以迁移过来,但 Heroku Pipelines 等功能目前只能大致映射到 Railway environments。
这种野心并不意味着要立刻向邻近领域扩张。Cooper 表示,尽管其他公司正蜂拥进入,Railway 现在不会提供 GPUs,但未来“100%会提供”,因为垂直整合的平台最终需要 FLOPs。
16. Temporal 是一台喷气发动机,Railpack 体现了相同的抽象检验
Cadence 曾驱动 Uber 的长时 trip workflows:不断附加 events 和 charges,直到一次 ride 结束;Temporal 延续了这一强大理念。一位主持人把它描述为从上到下、用一个 function 编程完整的用户旅程,这种模式很适合必须完成或暂停持久任务的 agents。
Cooper 对 Temporal 长达10年的批评是,开发者必须把完整的 workflow journey 装进脑中。确定性 history replay 可能在一次无辜的改动后暴露 nondeterminism,而 signals、queues、activities、pre-commit hooks 和 worker-slot tuning,则把 Railway 的部署 pipeline 变成一台庞大的 state machine。
他的比喻是一台“喷气发动机”:正确操作时非凡强大,但交给不了解完整系统上下文的人就很危险。Railway 未来或许会围绕自有抽象构建一套更窄的 workflow engine;Cooper 也认为 Restate 正在做有意思的工作。
Railpack 遵循了类似的经验。Railway 取代了 Nixpacks;后者基于 Nix 的 versioned binaries stack 原本承诺 reproducibility,却在不同机器上造成 image bloat 和 scaling pain。Railway 不想把用户拆进受限 runtime,而是在推进 content-addressable file systems,让数据按需加载并分页进内存。
17. 30万美元 token 账单,说明瓶颈在部署而非生成
Railway 预计在被引用的月份为 coding agents 支出约30万美元,Cooper 个人约2.5万美元,而公司只有35名员工。他对内部的指令很直接:“如果你还在手写代码,那你就做错了。”
这并不意味着放弃工程能力。架构模式“比以往任何时候都更重要”;工程师应当要求 agent 生成已知工作,审查结果,并持续 reconciliation,直到它看起来像工程师自己会写出的代码。
Agents 让 Railway 可以原型化 block storage、低成本编写数千个 tests,并“speedrun your roadmap”。过去预计需要数年的项目,有时可以压缩到数月,因为公司可以在现有架构旁边验证未来架构,并跳过中间实现。
在纯技术限制消失之前,支出会先接受 CFO 审查,inference 价格也仍需下降。Cooper 用 F1 作类比,按用户能力分层:最优秀的操作者值得驾驶300万美元的赛车;而天真的企业指标关注的是“最终进入生产环境的 token 占比”,而不是消耗了多少 token。
18. 云的重建,最终落在 prompts、flags、snapshots 与聚焦上
一位主持人预测,pull request 会变成“prompt request”;只有当 specs、tests、rollout controls 和 observability 承担起安全职责后,传统 code review 才会收缩。Railway 已经看到更多 pull requests 等待合并,说明代码生产速度可能超过部署容量。
在1000倍并发下,feature flags 会成为基础设施的底座。Cooper 曾经没能把一个更简单的 LaunchDarkly 商业化,因为小公司不在意,而大公司要求巨大的规模;agentic development 让这种过去只属于企业的控制能力,对所有人都变得必要,从 shadow traffic 到明确的 blast radius 都包括在内。
Railway 内部已经有一套 flagging engine,但在它能跨多个 services 和 environments 稳定工作之前,公司不会对外开放。交付一个残缺体验会制造割裂的概念和 support load;公司的产品节奏仍然是先扩张,再 compaction 与打磨。
Cooper 甚至挑战“cattle, not pets”这句话:只要有 cloning machine,pets 也可以安全。对每一个 filesystem state 做 snapshot,按需恢复,再合并经过验证的 filesystem change;许多 Dockerfile 和 Ansible 的繁琐流程,原本都是为了保护不可替代的 state,而普遍可用的 cloning 可能会移除这一前提。
作为创始人,Cooper 通过对整个技术栈的痴迷,同时处理技术与商业工作;但他也警告,两个没有明确分工、也没有 CEO 拍板权的联合创始人,可能陷入僵局。他个人的节奏是周一至周五从日出工作到日落,周六断开连接,周日下午写作与规划——不过“多数建议都应该消化掉,然后扔出窗外”。
Railway 最终的 thesis,是在不抄 hyperscalers 作业的情况下重建一朵新云。访谈后面提到,绝大多数 workloads 已经运行在自有 metal 上;这一比例曾达到100%,但快速增长又把它推回90%区间。目标是让思考与部署现实之间“没有摩擦”,即便这最终意味着下潜到每一层软件,甚至一路追溯到 energy 本身。
Jay Cooper
If you are writing code by hand, you are doing this wrong, right? The tools are good enough at this point that you can move extremely, extremely quickly. Yes, there are issues and pain points and all these other things, but you should be reviewing the code that you are writing instead of trying to write it by hand. All of those architectural patterns, all of those other things—you’re not just going to throw them in the garbage or whatever. Actually, they matter more now than at any other time.
But you just shouldn’t spend your time generating code that you would write. If you know how to go in and write it, just ask the agent to go in and write it, and then reconcile it until it looks like you would have written it.
Shawn Wang
Hey, hey. Today we’re in the studio with Jay Cooper of Railway.
Jay Cooper
Conductor of Railway.
Shawn Wang
Conductor at Railway. Yeah. Choo-choo.
Jay Cooper
I don’t have a business card. We’re not that big yet. At some point I will. I got handed a nice business card from the Supermicro folks, and I was like, “Damn, that’s actually pretty official.”
Business cards.
Jay Cooper
Yeah, they’re cool. They’re hip. They’re jiggy. But the whole conductor thing: we call some of our volunteer moderators conductors. We’re trying to figure out what we want to call each other internally, and there are varying levels of thought. Some people are like, “Oh, it’s super cringe. You don’t need a name for people internally,” and some people are like, “Oh yeah, we want to call each other this thing or whatever.” We still don’t have a really good one. We’ve got new rail recruits, we’ve got Trainiacs, but nothing’s really—
For those who don’t know what Railway is, let’s give people a crisp definition up front.
Jay Cooper
Railway is the easiest way to ship anything. You just go to the Canvas or talk with Claude and say, “Deploy a Postgres instance,” “Deploy my GitHub repository,” “Run this code,” et cetera, and you’ll be up and away to the races.
Yeah, you have a nice animation on the landing page.
Jay Cooper
None of my work, by the way. They don’t let me touch any of the design stuff anymore. But we want to make it really easy not just to deploy things, but for you to almost evolve applications over time. We believe that most of the tooling right now is stacked up like you’re stacking entropy on top of entropy on top of entropy.
You have Docker and Kubernetes, then Ansible scripts and all of these other things. If we can version all of your software for you and keep track of all the changes, then we can make it trivial for you to clone environments, fork into a parallel universe, get copies of production data, get copies of any of your services, make those changes, validate those changes, and collapse it in without having to reproduce everything across a staging environment or all of those other things.
One thing I was looking at in your background: Bloomberg, Uber. There’s nothing immediately that stands out to me as, “Okay, this guy’s going to found the next great platform as a service.” What prepared you for Railway? It’s almost like a curiosity—just to ever go deeper, right?
You started out on front-end stuff, working on Wolfram webMathematica and porting it over there, then briefly moving to Bloomberg, and then moving toward Uber and distributed systems, taking all of the JUMP Bikes’ systems and moving them over to a distributed system built on top of Cadence—the pre-Temporal Temporal.
Shawn Wang
By the way, I’m happy to talk about the pros and cons.
Yeah, I think it’s like—let’s do the Railway story.
Jay Cooper
It’s just been a continual step of: I want this experience, whether it is walking up to a bike and unlocking it and having it be frictionless to work, or necessitating the depth required to go in and make that happen. A lot of the work that I do and a lot of the team does is all in service of that experience.
We fundamentally don’t care how deep we have to go. We will swim to the bottom of the swimming pool to get the experience right. I think that’s what a lot of the trajectory was. It’s not like I have a physics PhD or whatever. I did an EECS degree. It’s just always been about trying to figure out that next step of how we get there.
That’s what’s led to starting Railway for that experience and then moving all the way to bare-metal data centers. I was adding patches to the Linux kernel this week just to get the experience there, because I see how much better it can be.
Yeah, patches to the Linux kernel this week.
Jay Cooper
Yeah. Well, not upstream.
Railpack? No, this is different. This is the OS on top of Railpack.
Jay Cooper
Yeah, no, this is the actual kernel. It’s always literally just, “What do we have to do to get that experience?” You figure it out, right? Anything is figure-outable. You’ll just figure it out.
Would you send the patch upstream?
Jay Cooper
We have to work out the experience for us in general. It has a lot to do with the storage layer that we’re building for some of the agentic stuff. Maybe it’ll be useful to people upstream, but it’s deeply useful for us internally.
Shawn Wang
You mentioned open source before, so I’m curious how you think about starting from open source and then letting coding agents do a lot more from forks of it.
Jay Cooper
I think the funny thing is that GitHub’s original sin is that it’s almost a series of broken pointers. You have essentially this thing, and then you clone it, and then, okay, great—I’ve just lost that whole upstream, right? How do we make it trivial for people to modify really, really small pieces of it?
You think of Git as almost this discrete sense of, “I’ve either made a change and I’ve merged upstream, or I haven’t.” What would it look like if it were percentage-based or a little bit more nondeterministic? More like a stream of changes that you traversed as a user, or more as a percentage of this being rolled out in general and then rolled all the way up.
We have the open-source kickback program and allow you to deploy those templates because we want to make it trivial for people to version these shards over time. It solves a really, really large problem in terms of authentication, authorization, and security. npm has that thing where you can almost define, “Hey, don’t take any new packages,” or whatever.
The ideal end state is actually that you should roll out progressively to the users who have the minimum impact zone for any of these things and just continually roll up. JPMorgan or something else like that should probably be the last one on the patch line for that, for all of our sakes, because we have all of our money and all of those things. It’s okay if Johnny Vibe Coder gets a broken patch or something else like that, because ultimately there’s so much entropy in the system that you do have to roll. Rubber has to meet the road at some point; you have to test at varying levels.
I just wanted to pull up this glorious chart, which is basically your usage, or number of daily signups, I think. Daily signups. You started 6 years ago, and it was a slow grind. Now, obviously, you’re on a rocket ship. You say, “Don’t doubt your vibe and don’t quit.” Maybe you want to pick out certain points that were key inflections of the company. That might be fun.
Jay Cooper
Oh, yeah. Yeah, yeah. Well, at the start, it’s basically: How do you get your first 100 users? Hell or high water, right? We had a website and a support link, and the support link was the Discord channel. You just showed up there, and I had notifications on.
I had 2 monitors: the monitor I was working on and then the other monitor. If anybody came in, I was like, “Oh, hey, how’s it going?” It was super rare. We were trying to get those initial 100 users to actually come back to it.
And that’s, I think, where you can really see it—in between January 2021 and 2022, probably around the middle there, right? That’s the start. Then you ultimately end up building a consultancy factory because users wanted all of these things in general. You have to go back to the drawing board a little bit and be like, “What is the actual product offering that I want to build on top of these?”
Incidentally, it’s funny: I think VCs really want charts that always look like this, right? But in reality, you actually don’t want charts that look like that. Most companies—or at least for us—have had periods of expansion, where we’re going to add these features to test these use cases, and periods of compaction, where we’re saying, “If the experience we have is really, really good, how do we make it significantly better?”
Maybe we’re even stripping out features that don’t fit our ICP anymore. Throughout this whole chart, you can see a lot of those things. The boom from 2022 to 2023 is when we had a free tier, and everybody under the sun was using it, and all those other things.
Shawn Wang
A lot of Reddit bots and stuff.
Jay Cooper
And I think there’s a thing that’s really, really tough to teach people or tell people: when you build an open product on the internet where anybody can sign up, the internet is a horrible place that has so many things like—
Shawn Wang
I told you about my PC.
Jay Cooper
Yeah, like crypto miners. You have all these other things, right? So you kind of go through these periods of, “How do I reach as many people as possible?” and then, “How do I fit exactly the use case for the people who are really, really going to matter and be really, really excited about specifically this thing?”
We go back and forth internally. And then there’s a 2-year period of making the actual business work in general—the free-tier era.
Shawn Wang
We were losing, I think, half a million dollars a month on, like, a $20 million bank account.
Jay Cooper
Yeah, yeah. Like a $20 million bank account with maybe $50,000 a month in revenue or something. I was like, “That is horrible business.” But you have to go through and be like, “Cool, we have an experience that people love in general, but the business has to work,” right?
I think there are, I guess, 2 schools of thought: you can continually run the horrible business all the way up in general and have bad margins, or you can actually go back and make it work, right? For us, we’ve always really wanted to have a super lean team.
Shawn Wang
You’re 35 people right now.
We’re 35 people right now. It’s very, very small. We have, like, 3 million—
Shawn Wang
2 million. Yeah, yeah.
Because we’re adding, like, 100,000 users a week right now, right? So it’s growing really fast, right? But we’ve always wanted to have a really, really lean team. We don’t want to just add headcount for the sake of headcount or throw bodies at these problems. We want to build systems, right?
It’s really, really hard to build systems when you’re in that expansion phase because you’re just adding stuff to the system in general because people are asking for it or things are breaking in general, right? We basically were like, “All right, we’re going to cut it for now. We just can’t support these free users.”
We want to reach as many people as possible because we believe that software is this really, really important thing where, if you can create something, it’s become really difficult to create things in the physical world. So it’s really important to make it really easy for people to build things in a virtual world so that people have access to creation, right?
And so we want to reach as many people as possible. But there are kind of legs on that journey. We basically had to close off the free users for a little while, rebuild the business, and make sure that it worked in general, right? And I think you can kind of see the building of that in general, right?
Then you see some divots in those charts, right? If you actually follow the period between 2025 and 2026, it’s either summer or winter. That’s basically it, right? Either people go on holiday with their family, or they go on holiday.
Shawn Wang
Oh, it affects it that much?
Yeah, yeah. Well, because it’s kind of B2B in general, right? You have a lot of these users who are shipping constantly, and then they’ll kind of stop or whatever, right?
Maybe for summer, our activation curve is now that we see a lot of people activating on weekdays, because we have a lot more business users in general. So it gets a lot less sheer, so to speak, and it kind of smooths out over time.
Shawn Wang
Is there any point at which you started prioritizing AI developments or agent development?
I think we’ve prioritized agentic as a top-of-funnel thing. Over the last 6 months, we’ve deeply prioritized agentic as a mechanism to build and deploy things, just because we believe fundamentally the curve is so sheer and that is the way people are going to build and deploy software.
It almost fundamentally doesn’t matter if this is dot-com or not, because we’re all on the internet now anyway, right? If agents are going to deploy a bunch of things and we hit an inference wall at some point, then at some point we’ll go in and fix those problems.
That will be the dominant species over the next 10 years. We’ve moved from assembly to C to C++ to JavaScript to now words, right? And you’re going to need to be able to close that loop, right? That’s where it goes.
Shawn Wang
When you say dot-com, do you mean buying the domain?
No, no, no. I mean that there was a bunch of run-up in the dot-com era for companies because they were like, “The internet is really, really important,” and then you hit fundamental bottlenecks—laws of physics, math didn’t work, all those other things—and everybody went back down to earth.
But at the end of the day, it didn’t matter, because the internet is so impactful for our lives that, if you operate on a long enough time horizon, you should just build these things anyway. You can see where that’s going, right? That’s where I fundamentally believe a lot of the agent stuff is.
You’re going to get to a point where you’re running thousands of these agents in parallel, right? First, what’s the inference cost for that? What’s the compute cost? How do you make that efficient? All of those other things.
Second, how do you coordinate all this stuff? We have issues coordinating humans in general, right? We don’t even have good tooling for that. Now we’re starting to figure it out: How do you get agents to coordinate? How do you get them to safely version changes, or know when to put their hand up to get somebody to intervene, right?
Otherwise, it just becomes an interrupt factory that’s crazy.
Well, so maybe we’ll go right to the technical side of things. What are the core infrastructure or architectural beliefs of Railway that allow you to do what you do?
Yeah, I think the primitives matter a lot for us—like, a lot, a lot. We need to be able to do network, compute, storage, and orchestration all kind of around it. You need control over a lot of those things.
We’ve talked a lot about how we don’t really use Kubernetes because we want the higher order of control to be able to place workloads in very, very specific places, right? The reason for that is the thing we talked about previously: you have to be very, very efficient with these agents—memory reuse and all of those other things—or you’re going to massively blow up your cost structure, right?
Incidentally, being able to rack and stack your own servers and build your own metal unlocks a level of performance, one, but also cost, where you can say, “Those experiences that you want to offer, where you’re running 1,000 agents in parallel, are not massively cost-prohibitive,” right?
If you look at token use right now or compute use or anything else, those things are blowing up massively. Over time, those things are going to have to get a lot more efficient. You can get a lot of almost back-of-the-napkin balance-sheet margin, whatever you want to call it, to make those experiences solid by building your own metal, right?
And so, kind of to the earlier point, we’ve always tried to go a little bit deeper every time to make that experience.
It’s all in the service of offering that differentiated experience to as many people as humanly possible.
Shawn Wang
Yeah. You have a data center in Singapore.
Yeah. We have 2 in every other region now. Singapore—we’re adding a second one in Q3.
Shawn Wang
So, what’s it like? I’ve never built a data center.
We’ll have to go to one or whatever.
Shawn Wang
Go to Equinix and say, “Hey, I want some.”
Yeah. I mean, I can Equinix. Equinix.
Shawn Wang
I mean, you can put a data center in the steam room and get nice and hot or whatever.
Yeah. You basically just go and say, “Hey, listen. I want power and I want a cage,” and they’re like, “Great. Here’s what it’s going to be.” Then you rent the cage for a period of time, fill the cage with racks of servers, and hook up internet to it. That’s realistically it.
Shawn Wang
And then they handle everything else, right?
Yeah, you just handle everything else, right?
Shawn Wang
What’s the math versus, obviously, the clouds?
Our payback period when we go to metal—if we rent it in the cloud, our payback period is about 3 months.
It goes crazy.
It’s nuts. That’s 4 years’ worth of depreciated hardware, right? I think you’re going to see a lot of this compute crunch, so to speak, because a lot of the hyperscalers are buying up a lot of stuff. We’re working directly with OEMs and retail resellers, and directly with people who are building these machines, like Supermicro, Dell, and all those other companies, to get these things working.
Upstream, there’s a bunch of supply issues. It was funny because when we raised our last round, in between deploying the capital for the servers and actually—I think even now—the amount of money that we’ve raised is less than the amount of money that we have in the bank plus the value of the servers. The servers have actually appreciated in value because RAM has gone up in general.
It’s kind of nuts, just in terms of how valuable hardware and all of this stuff is. If you look at a lot of the hyperscalers, they deployed, like, $80 billion of capital expenditures this year, and into next year it’s going to be more in general. There are these massive-scale infrastructure builds, and you can look at that and think, “Wow, that’s crazy that they’re spending way more than the Manhattan Project.”
But again, if you go back to every person running dozens or hundreds or whatever of agents in parallel—
You should spend more than you have. You have no conceptual idea of how much compute is required to go in and make that experience happen. Even if you’re deeply efficient, even if you’re sharing resources, even if you’re doing all of these things correctly, that doesn’t even count inference.
Shawn Wang
How do you plan out the buildout? The growth chart is so vertical. Are you usually at 100% utilization as soon as you’re live with these racks, or how far ahead are you?
We still maintain a cloud presence for bursting, essentially. We work with AWS, GCP, and a few of those other clouds. We can just rent capacity, and the moment we get space or power or whatever, we almost just compact those instances off the cloud.
We started on the clouds, and then we built a system to allow us to migrate to our own metal. There’s nothing that says you can’t just continually do that again, which is exactly what we do right now. We never want to be in a spot where we’re compute-constrained.
At the start of the year, we actually got to a point where we were compute-constrained because the one upstream provider we were working with wasn’t able to give us quota at the rate that we needed, and the hardware was slower. We had to do a bunch of different things. I spent a weekend rebuilding our entire network overlay, essentially, so that we could straddle 5 different clouds.
Right.
Yeah. Oracle, AWS, ourselves, GCP, and 1 other one. We can do more than that now, but we got into a spot where we were just trying to pack instances tightly because we couldn’t get the amount of compute that we needed.
It was really unfortunate because, as a result, we had a few reliability issues, which are now behind us. But it was all a result of this. I made a tweet where I got in trouble because I was trying to point it out, but I accidentally caught the Supabase folks in the crossfire.
The tweet was about how it’s really, really difficult, and it’s going to become more and more difficult, to acquire compute at the rate that these models need to acquire compute. We got bitten by it, which is fair and reasonable in the karma scheme of me trying to point it out.
Shawn Wang
How do you think about pricing, knowing that you might not have your own metal available at all times? Are you pricing assuming that you’ll need to pay yourself extra margins if you end up having to go into the cloud?
Because we’ve built out our metal data centers, our margins on metal are quite high—around 70%. We can deeply subsidize the cloud business if we want to scale at a reasonable rate.
We have a few different levers on how we can scale it. You have the metal, which actually makes your margins. You have cloud bursting. You have debt that you can use to buy servers in general. It’s a very interesting operational problem to say, “Okay, we have this much cash. How much money should we raise? How quickly can we deploy it?”
Then, obviously, you have venture capital that you can raise on top of it. We can scale revenue as quickly as we can scale compute, provided we continue to make it trivially easy for people to build and deploy.
The faster you can close this loop, and the more operationally excellent you are with the capital, the faster your business can grow. It’s basically a straight-line deployment rate on some of that stuff.
Shawn Wang
I think infrastructure startups raising debt is a tool that people don’t utilize enough or know enough about. What can you tell us about that?
Yeah, I mean, is it secured against your CPUs or what?
Yeah, it’s secured against our hardware.
Shawn Wang
What rates do you get? From whom?
We just pay prime, whatever it is, plus some amount. We can refinance any of the debt as it goes down. The terms are pretty good from that perspective.
The unfortunate thing is that Twitter has no nuance. They’re like, “Venture debt: bad,” or whatever. It’s like, well, no. As with all things—
It’s not venture debt.
Yeah. Or data center debt.
Shawn Wang
Yeah. It’s data center debt, right?
There are specific tools in specific areas where you can be very deliberate about not just using 1 specific tool as a hammer—venture capital as a hammer for everything. You just have to go out and explore it and figure out how it works.
Shawn Wang
VC is the most expensive financing you can get.
Yeah. Incidentally, I think people also think about VC completely wrong from a raising-capital perspective.
Okay. Tell us how VC is wrong.
Most people are like, “Okay, how do I raise as much money as possible from whoever is probably the best that I can get at that point in time?” I think that’s close to right, but I think what you should be doing—or at least what we’ve tried to do—is figure out what unfair advantage you can buy with that equity.
It’s the most expensive equity you’re going to give away at that point in time, assuming your company is going to get better and better and better. How do you use that to work with somebody who is stellar and who’s going to complement you?
Shawn Wang
Yeah, like serious—
Lucky. Yeah, yeah, right. Great. I’ve never started a company. Race race Milwaukee. He’s got good advice. I can text him all the time. He’s really fast. Awesome.
Then you move on and work with John and Jordan at Unusual. They were like, “Yeah, you roughly know what you’re doing in building a product. We’re just going to mostly leave you alone and be totally available for advice.”
Amazing. Awesome. You get to Series A, and the business is a total operational tier because we just don’t know how to scale a business. Go and work with Erica and Jordan over at Redpoint. It’s a bonus—we get to work with them continually.
Now, moving into the enterprise, we raised from TQ and FPV, and we’re moving into the enterprise now and feeding into that. Every step of the way, we’ve moved toward asking, “Who can we partner with at this specific time who’s going to help us unlock that next section of the journey?”
Because I don’t know enterprise sales. I can roughly eyeball it and say, “Yeah, as an engineer, I think these are the kinds of features that we’re roughly going to need.” We have some wonderful people who are going to help us internally, but you really want to work with those people at the boardroom-dynamic level. They’re going to be like, “Oh, yeah, we’re all aligned, and that’s obviously what we want to go and do.”
Then we can spend our time saying, “How do we win this?” versus bickering about strategy, right?
Shawn Wang
Uh, no.
I just had to pull up some beautiful data center charts.
I feel like you've done others. I couldn't find them.
Shawn Wang
Well, these are good. They all kind of look the same—the servers in a rack.
Yeah, exactly. This is our box. Do you want to see more racks? It's like, "Oh, yeah." You know—
Shawn Wang
The J. Cooper signature edition.
Yeah, yeah. It's a—
We have plans internally. Yeah, so it'll be fun. We've got a few different promos that we're going to do, and stunts for the year, so those will be fun.
Shawn Wang
Yeah. You had a tweet about data centers in space just before we wrapped this section.
Yes.
Shawn Wang
Why no data centers in space? Why do you hate them so much?
So it's not "no data centers in space," because my hot take is that I think this is solvable. I've just never seen anybody solve it, right? Because you need to—
Shawn Wang
No, no, no. Well, you said, "How are you going to dissipate that much heat in a vacuum?" You're making a physics claim.
Yeah, yeah, yeah. Because I haven't seen anybody prove how you're going to dissipate that much heat in a vacuum, right? It doesn't mean that it's not possible. It just means that nobody's put it up.
Shawn Wang
Pardon?
Astrophage.
Shawn Wang
The Martian thing. Okay, you're very loyal.
Yeah, that's fair. But, yeah, I don't know. It could work in general, right? But I think a lot of people—and I think, incidentally, this is probably what you have to do—are putting the cart before the horse. It's like, "Oh, yeah, we're going to put data centers in space." It's like, "Okay, but how?" It's like, "Well, we have some period of time to basically figure it out," right?
In The Martian, they're like, "Oh, how are we going to intercept with—"
Shawn Wang
Oh, okay, right.
It's like, "How are we going to do that?" It's like, "Well, we'll figure it out. We have however long to go and figure that out," you know, so—
Shawn Wang
Yeah, yeah. Making a bet on human invention is weird because you just have to blindly trust that it can be solved.
100%, right.
Shawn Wang
I feel like there are some first-principles bounds that you can put on it, maybe not—
Yeah, I know, right.
Shawn Wang
Maybe you're asking to violate travel time here, or break some fundamental thermodynamic law.
Yeah, and I don't know how VCs do this, incidentally, too, because how do you know what's basically not possible and is a grift versus what is possible but sounds completely insane, right? You're like, "Oh, cool. We're going to put data centers in space." It's like—
Shawn Wang
Okay, coin flip as to whether that's one or the other. You just don't know, I guess. And I guess you'll know in 10 years.
Yeah.
Shawn Wang
Cool. That's one cycle.
Okay, okay.
Shawn Wang
Yeah. Moving back to agents. I think the branching that you do—the fast spin-up and orchestration—is kind of the pre-work that happened to be exactly what agents want.
Yeah.
Shawn Wang
What do agents want differently than humans?
What do agents want differently than humans? I think they want the ability to version things. It's not actually that different; there are just almost slight deviations in terms of how it materializes, right? Agents want a way to be able to test changes incrementally, right?
We have feature flags as engineers, right? Is there any reason why they can't just use feature flags? I don't think so. I think there are ways that you can just go in and do that, right? They want version control. Is there a way we can use Git or not Git? I think that one is realistically completely up in the air, right? I do think something outside Git will ultimately emerge in terms of how we're going to version a lot of these things over time.
They need observability. You need to be able to query what happened at what point in time, which steps failed—traces, logs, metrics, all those other things. They need network, compute, and storage. They need the ability to write files, save files, iterate on files, snapshots, file systems—all of those other things, right?
I think a lot of the stuff that we needed is very much in line with a lot of the stuff that agents also need, right? The branching and forking stuff isn't different. We're just moving 1,000 times quicker than we used to. Some of these things look like you really need something massively different, but you need something massively better than what currently existed, right?
You need orchestration. You need something massively better than Kubernetes, right? You need networking. You need something probably better than Envoy, right? It just goes all the way down the stack, essentially. If the workload profile doesn't change so much as it gets massively compressed because you need to do thousands of these things, what assumptions change? CI/CD is going to melt, right? You need to replace it with something.
I think you can go all the way down the stack and basically say, "Okay, that part has to change, and that part has to change, and that part has to change." The interesting thing about the super-exponential curve is that you have to build your systems in such a way that you can rip out those parts at any point in time, because a new bottleneck might emerge.
You start getting really, really good at parallel agents, and then that's where the new bottleneck is, right? That breaks a different part of your system. I think it's very much similar stuff to what humans have needed; you just need it at a 1,000x scale. How do you do code review in the age of agents, I guess, is more of a question.
Shawn Wang
More agents who don't.
Kurt Mackey
Yeah, right. But then who reviews things for CVEs and all those other things?
Shawn Wang
Yeah, right.
Kurt Mackey
Okay. And then that's how we hit the inference wall at some point, right? You can continually throw agents and agents and agents at that problem, but I think there's a limit to the number of agents you can throw at a problem.
Shawn Wang
You started, though. You already had a CLI before it was cool. How has—
Kurt Mackey
CLIs have always been cool, by the way. But, yeah—
Shawn Wang
How has the shape of what you're exposing changed, if at all?
Kurt Mackey
I think the CLI changes because the way that we think about this is: how do you give Claude, Codex, ChatGPT, or whatever—any of these models—almost like a handhold?
A CLI is a single command when you think about it, right? It's like, "Okay, well, you're going to do a deploy," or whatever, right? "You're going to get logs," whatever. Things that were prohibitively annoying to humans are not actually prohibitively annoying to agents. They're really, really nice, right?
If I wanted to hand you a CLI and I said, "Hey, guess what? The CLI has 40 arguments and 600 flags," you'd be like, "Wow, that's crazy. I'm never going to use all those things," right? But if you hand it to an agent and you say, "Hey, there are 40 arguments and 600 flags," it's like, "Oh, yeah, this is excellent. I have so many handles that I can work with here," right?
If you're going to try to expose things for agents over that mechanism, you want to basically have as many handles as possible where they can get information, query additional dynamic information, and then see how they can close that loop as quickly as possible.
Most of the problems right now are just: how do you close the loop as quickly as possible? Where does the agent get stuck, and how can you remove that? That's why telemetry is very, very important, because if you can tell where the agent gets stuck from the CLI and say, "Hey, listen, 12% of people are actually getting diverted from the happy path because of this thing," and then add this argument and drive that down to 2%, you've massively increased the rate of the loop closing for a lot of people in general, right?
That's the way we think about not just the CLI, but every point in the dashboard, right? It is a user journey from, "I hear about Railway," to, "I go and get something deployed." I get my first green build, whatever—an aha moment. I see an endpoint. I see some logs. I see whatever. Then I go and iterate, right?
The iteration loop is indefinite and infinite until the end of time. It's basically, "The user wants to deploy a new thing. The user wants to deploy a new Postgres instance. The user wants to change their code. The user wants to iterate," all over time, right?
If you focus on a lot of those iteration loops and figuring out what's blocking that loop from closing as quickly as possible, one of the things we talk about internally is that you never, ever, ever want to be waiting on compute anymore. You always want to be waiting on intelligence, right? If you're waiting on compute, there's a bottleneck that needs to be destroyed, because at some point that bottleneck will be so large that some other workflow will emerge to change a lot of that stuff.
And I think, incidentally, we’ve built a really, really awesome product where you can push code, and then you build the code and all those other things, right? But that push-pull-whatever kind of loop, I just fundamentally believe it’s going to go away, right? We’re going to get to a point where you make a small change in production, and that change is versioned across your entire infrastructure.
You’re working alongside copy-on-write versions of your database, all of your infrastructure, and then you merge it in and instantaneously it’s live, right? Because that’s the holy grail of loops. But that push-pull-rebuild thing is a point of friction that we are removing entirely from our loops.
Shawn Wang
Yeah, it’s incredibly fast. So, if anyone hasn’t tried it—
Kurt Mackey
Yes.
Shawn Wang
Yeah. That fast feedback is great. You know, my hot take is that Railway was kind of famous for its canvas, which sort of visualizes your infrastructure and lets you manipulate it visually, but that was for humans.
Kurt Mackey
Yeah.
Shawn Wang
And actually, now for the next phase in growth, the CLI is more important than the canvas, which is what you were famous for.
Kurt Mackey
Yeah. So, I think the canvas is funny because it’s actually just a mechanism to show you changes over time, but I think you’re totally right in the sense that we previously used it a lot as an input, and its goal moving forward is actually a lot more like an output.
What I mean by that is, you would go to the canvas and make some changes and all these other things, right? And you’d see them, and your agents or your infrastructure would evolve over time, right? Now you just have a bunch of agents that have access to the CLI, and they can go and make those changes.
And so the canvas, instead of becoming this input thing where you’re like, “Oh, cool. How do I go in and make this happen?” is actually just more of an output thing. It basically says, “What information—”
Shawn Wang
Yeah. What information does the human need at this point in time to make suitable decisions about control requests? Do I approve this? Do I not approve this, right?
Kurt Mackey
That’s realistically all the canvas becomes at that point. And I think this is important, and I think it’s lost on a lot of people who are building some of these canvas experiences: It has to be almost like an anchor for your context. It has to be like a port in the storm.
You have to think about it basically as layers, and almost like a file system, to get to the next spot, right? You have all your infrastructure, and this is why the canvas starts as just a project, right? And then you have a drill-down chart. It’s like, I’m breaking down into these services or this section that is just a function or code or anything else like that.
You want to actually be able to represent the entire thing not just in your head but in this canvas, so that other people can also get that representation, so that they can think on the same wavelength as you and move as quickly. I think a lot of organizations, especially as they scale, get in trouble because all that context lives in somebody’s head, basically. It’s like, “How does this microservice work?” “I have no idea. Go ask this specific person,” right?
And then you have entire categories and classes of products that are built around how you do context discovery in all these things. I think a lot of that stuff just gets melted in terms of, if you can have a really, really solid hierarchy and you can infinitely nest services, infinitely nest code, infinitely nest context, infinitely nest all these things all the way down, that’s what allows you to build these structures up over time.
I think it’s also what’s going to allow us to build—I’ve written about this—these hyperstructures: things that are way, way bigger. You look at the Golden Gate Bridge and you’re like, “How did we build that?” There’s that whole meme of, “How did we build this? We lost the technology, or we don’t know how anymore,” right?
Well, to some extent, yes, because a lot of the coordination that built those things has evolved and changed, right? We’ve lost almost some of the art of building that structure as we’ve just jammed everything into Slack. Everything happens through Slack, and it’s—
Shawn Wang
But you don’t have anything in Discord.
Kurt Mackey
Yeah, that’s the same point. It doesn’t really matter. It’s just message passing and interrupts. Message passing and interrupts. Message passing and interrupts, right?
Shawn Wang
So you’re arguing that there should be something better, more structured than Slack.
Kurt Mackey
Yeah. Oh, for sure. I think Slack is awful. Incidentally, I think Discord’s awful, too.
Shawn Wang
This is the equivalent of my mom test, right? What have you done to solve this?
Kurt Mackey
So, internally, we’ve built a tool called Central Station that allows us to aggregate all the context from all of our users. Every piece of feedback, every piece of customer support, every single thing like that gets aggregated into what we call clusters.
If you have an incident brewing or anything else like that, now we can determine how many users are affected, all those other things, et cetera. And then we can actually break off a discussion based on that.
I think a lot of that is a lot more helpful and more correct than having these long-running channels where you’re like, “Which channel should I put this thing in?” If you can dynamically aggregate that information and dynamically route it to the right person based on the context, right?
We know internally these 4 people are pretty close on networking, right? And so if we see, “Okay, we’ve got a networking thing,” you can roughly drill it down to those 4 people, right? And if you’re saying, “Oh, okay, cool. It’s actually with this part,” you can just go and look at the commits, right?
This is no longer a manual process internally. This is the whole point of why we built this thing. If you go to station or help.railway.com, the whole reason we built it is because we wanted to figure out how we’re going to scale with a massive, massive, massive amount of leverage to aggregate all this feedback.
Shawn Wang
This is built in-house.
Kurt Mackey
Yeah.
Shawn Wang
Okay. So, and then I remember helping out on this one with Angelo—
Kurt Mackey
In 2023.
Shawn Wang
Yeah. You scaled a lot with a very small team.
Kurt Mackey
Yeah. Yeah. Yeah. So, we’re like 10 times bigger now.
Shawn Wang
Oh my God. You have your full developer account here?
Andrew Farah
Yeah.
Shawn Wang
Okay. All right.
Andrew Farah
Oh, if you go to—
Shawn Wang
I can just clone this.
Andrew Farah
You don’t even have to clone it. We expose this as a pub-subable thing. Go to railway.com/stats.
Shawn Wang
Oh, there you go. Yeah, that’s your—
Andrew Farah
So, it’s all real-time metrics for all of this stuff. There’s a way to get this as JSON somewhere, too, if you care or anything else like that.
Shawn Wang
Look it up.
Andrew Farah
Yeah. We’re big on trying to build everything in public and talk about a lot of the stuff we’re working on. We’ve had some issues in the past, and we’re like, “Hey, cool. Here’s how we’re fixing these things.”
We’ve gotten both compliments and some flak for our incident reports, and we’re always trying to make them better over time just to talk with people.
Shawn Wang
Yeah. Anyhow, you had a big one recently. I like that it was only scoped to 3,000. You presumably used Central Station. Can you talk through what happened, and I guess how do you address it internally as a team?
Andrew Farah
Yeah. Internally, we’ve deemed this one really, really sucked. It was to do with an upstream provider that didn’t exhibit the behavior that they said they were documenting, which is unfortunate given that they wrote the RFC on how the behavior should work.
We rolled those things out, and then Central Station caught that initially. We had a couple of users being like, “Oh, the caches aren’t invalidating for some of this stuff,” right? So, we turned it off immediately, et cetera.
But when you roll out to that large user base of 3 million people, you have a lot of different disparate behaviors that can come up, right? Try as we will, we tested those things in staging. We have tests for them, all this other stuff, and unfortunately we hit an edge case there, right?
We’ve gone and hardened a lot of those systems, and now we can make a lot of that stuff better. But, yeah, it was a tough one, unfortunately.
Shawn Wang
Yeah. I always wonder how the private disclosures are supposed to work if people find an issue. Are they supposed to contact you first? When you run a platform, these things are going to happen. What channels should people pursue to quietly resolve it before it becomes a much bigger incident?
Andrew Farah
Yeah.
Andrew Farah
I think there's responsible disclosure. We kind of err on the side of over-disclosing and knowing that something is wrong versus having your provider almost gaslight you. We've erred on the side of sharing those things more publicly, even if they impact a small subset of users. That's just a decision that we've made internally.
We have 4 values. One of them is honor. What's the honorable thing to do? You notify people to the widest degree at which they may have been affected, if there was an issue or whatever, and then you confront that head-on: Why did that happen? What can we do better in the future? All of those things.
Shawn Wang
Yeah, not the whole user base.
Andrew Farah
No.
Shawn Wang
And that's because of incremental rollouts and—
Andrew Farah
Progressive rollouts and stuff like that, right?
Shawn Wang
Interesting. Yeah, yeah. I feel like that should just be the norm at all large platforms, right?
Andrew Farah
Oh, it totally should. And a variety of companies, it totally is, right? There's a whole quote that Meta runs 10,000 versions—different versions of Meta—in general. To our earlier point about agents, they need the same thing. They need to be able to shadow traffic. We need to build all these other things.
I think we've built so much ceremony around production being sacred, all of these other things, that we need to get to a point where it's trivially easy to test different behaviors in a safe environment. Then you can make those mistakes in an environment that's safe in general.
Shawn Wang
You mentioned somebody brought it up. Do you see a world in which these things get automatically caught, not necessarily by your agent but by your customer agent? You know what I mean? The cache invalidation thing seems like a pretty easy thing to track if you know to look for it.
Andrew Farah
It's hard, because for us to determine it, we'd almost need to hook into your observability infrastructure in general. This is why we almost have the template loop on the platform: to be able to roll those things out progressively. You can say, “Hey, listen, I can roll this out to Johnny Vive Coder initially,” or I can push a shard and you can consume that at your own leisure and say, “Oh, okay, I'm going to update to this specific version.”
You can have this kind of rollout over a period of weeks, where you're pushing a new version and then it goes to 0.1% of people, 1% of people, early adopters, whatever, and then rolls out all the way. That's the kind of nondeterministic version control that we've talked about earlier.
So, yeah, 100%. I do believe that's where most things should go, because ultimately most companies end up building that staged rollout system in-house. It's just the same thing built again and again and again at every single one of these different companies. There's a massive opportunity. You need to consolidate a lot of that for developers.
Shawn Wang
You should have a free tier, like the model providers give you free tokens if you let them use the data. We'll give you free compute if you're the number-one shard that goes out and you let us plug into your observability.
Andrew Farah
Yeah. Incidentally, we do that, right? We talked about the impact of that on 3,000 people or whatever. We start with the lower-impact people, like the larger companies on the platform. They're the last who should ultimately receive those kinds of rollouts, so that they have a version of the platform that's deeply, deeply stable.
Shawn Wang
I have 3 services, so I'm sure I get the first rollout. You can nuke my thing at any time, man. I guess my other question is, there are all these AI agent companies, and the observability people also want to have agents that fix your upstream problems. How do you see that playing out? You have your own agent in the Canvas now that you can try with. How do you see that playing out?
Andrew Farah
It's almost like the stacking-entropy thing in general, right? I think if you don't have the primitives to make iterating in production safe, it becomes very, very difficult. If you're an observability provider and you're like, “Oh, here's this fix to this error,” assume that 80% of those are probably actually good. They're going to make sense, et cetera.
But then the last 20% of that long tail of complex issues—ultimately, if you roll those changes out and just let somebody say, “Oh, cool, this looks good,” and stamp it, there's an opportunity for you to have an issue or an incident or anything else like that. I think that's why it's really, really important to have those kinds of forked environments in general.
People have staging, et cetera, but it always ends up deviating from production. You need the primitives, workflows, and experience built in as a first-party thing on the platform, in our mind, so you can fork any service at any point in time.
I consider the Canvas almost like a little sheet of transparency paper, and the agent is this little guy that you push up. It should be able to pop up in the Canvas and say, “Cool, I need to copy that service. I need to copy that service so I can test these 2 things.” That's my hypothesis as an agent.
Ideally, I get a read-only copy of production. Anything that's PII is marked as a transform when we automatically clone that database, go for a copy-on-write version of it, or read from it. Then it just makes those changes and says, “Does this actually work?” as close to production as possible. Ultimately, that's how close you have to be, or you just have a massive amount of drift.
I've changed this thing, and then it gets out of sorts. The system gets a lot more unstable. That's what you see with a lot of these massive systems that companies built on top of Docker for local, Kubernetes for production, and this specific thing for whatever. All of that complexity ends up getting to a point where it slows down the developers, but it also gets so unstable at scale that it becomes hard for people to iterate and make those changes.
We want to compress a lot of that stuff way down and just say, “As close to production as you could possibly be.” That's where we want to be.
Shawn Wang
I was texting Erica for questions, and she says you were originally not a believer in AI SRE.
Andrew Farah
Oh, yeah. Yeah. I mean, I've kind of—
Shawn Wang
Have you come around on it?
Andrew Farah
Yeah, well, I flipped. I'm actually still not a believer in AI SRE, because I believe that you need the primitives to make those things safe. If you just unleash an AI SRE on your production infrastructure and you don't have safe primitives for copying volumes and making sure that everything is fine, it's going to nuke your production database.
It's not a matter of if; it's a matter of when it's going to nuke that database, right? I'm a big believer in making those kinds of loops safe in general. I think I was a pretty deep—almost, I don't want to say—AI skeptic until 2024. Then I was like, “Okay, maybe I can make this thing roughly do it.” In 2025, I was like, “Okay, now I can trust this.”
Over the whole winter break, everybody came back and was like, “Oh, my God, it's almost impossible to use it wrong.”
Shawn Wang
Seriously? On the Claude docs?
Andrew Farah
But it's gotten to a point where it's almost harder to use it wrong than it is to use it right. There's that scene in Avengers or whatever where Vision says, “It's terribly well balanced,” when he picks up Thor's hammer. This thing just self-balances and works quite well from that perspective.
So, yeah, I'm a deep believer at this point that this will be the dominant species, right? Again, you know, Assembly, C, C++, JavaScript—words, right?
Shawn Wang
Yeah, it feels like a big jump.
Andrew Farah
Yeah, it feels like a big jump, and it is, too. It's not like you abandon CPU-based discrete logic in general and move straight to fuzzy logic. You need both, right?
Your skills should call code or applications or whatever, some sort of static structure, and you can use the skills to distill what the procedure should be or how the code should act. I'm coming to this thesis that you need 3 points, essentially: a clear spec of what defines the system, the code, and the tests.
When you say this thesis out loud, if you've been in engineering for any amount of time, you're like, “Well, no. Of course. That's an RFC, those are tests, and that's your code.” But they all matter a lot, and having them all actually together means they can reinforce each other.
The spec and the tests match, but the code doesn't. Let me reconcile them. Now the tests and the spec match; let me reconcile this other thing. You can move through that period of basically saying, “Well, this is fuzzy, and these 2 are either discrete in the case of tests or slightly fuzzy, slightly discrete in the case of code.” That's your iteration loop.
I think that’s also, incidentally, why you’re seeing a lot of people talk about software factories: “I want to write this doc, and how do I reconcile all this other stuff?” I think that’s a bit of architectural astronomy, if you don’t actually go in and implement it. But I do think that, generally, this loop is where most things are ultimately going to end up.
Yeah. For listeners, we’ve been talking about this on the podcast for 3 years: the holy trinity of specs and tests. Adamar Freeman from Kodo is the reference if people want to look it up.
One thing I do want to mention, just on the OpenClaw thing, is the idea that you can self-modify, which is kind of interesting. I don’t know how exactly Railway would support it, but I do have my OpenClaw, and I just tell it that it has the Railway CLI. You can do whatever. In theory, whatever capabilities or new infrastructure you need, you can just call the Railway CLI, provision it, and add it to itself. So the agent can modify its own infrastructure, which I think is—
Yeah, it’s nuts. We have a loop that I’ve kind of set up, which is: you put the Railway CLI on top of something that runs on top of Railway, right? So you’re essentially authenticated as whatever the current box is, in general, and you can make any sort of changes to it. Then you just call Railway deploy, and it deploys itself.
Right. It’s just like, “Oh, cool. I need to go and spin up this instance of this environment. I already exist in this environment. Excellent, I’ve got access to a PostgreSQL instance now.”
This is kind of where we want to go with a lot of the agentic, almost self-replicating infrastructure. That’s your loop: you iterate in production. That’s your loop, right? You’re going to continue to make some sort of change, and either it will work and you’re going to want to merge it and say, “Cool, that’s great. Put it into our upstream,” or it will not work and you can just throw it away, et cetera, right?
How do you make those throwaway copies as trivial as possible to spin up and run super cheap? I think the era of “I have an AWS instance and I’m going to get 4 vCPU and 16 GB of RAM” is going to get completely destroyed, right? Because if you do that for agents or anything else like that, you now need 1,000 of those machines. It’s so prohibitively expensive.
We spent a ton of time trying to figure out how to make these deploys—whatever you want to call them. Cloudflare has isolates; everybody calls it a sandbox, whatever—that atomic unit of deploy: only pay for what you use, spin up instantaneously, and close the loop as quickly as possible, right?
Because if the system can self-replicate and it can do so safely, it can say, “This is my environment. I’m making these changes,” et cetera. It can come back with, “Hey, does this look good? This is a new state of infrastructure given this prompt. I think I’ve solved this problem.” Then you can go back to the agent and it actually looks a little bit different.
It goes and does the loop again, and you’re like, “Cool, excellent, apply.” Yeah. I think that’s retroactively obvious—kind of the most useful kind. I don’t know if you have any other comments on agent deployment on Railway.
No, I mean, it’s getting better every day. I’m on X, or Twitter, or whatever you want to call it, and you can always yell at me about the experience not working as well as it should, because there are plenty of things that should work way, way better.
I was going to say, I think at this stage, when people want massively or embarrassingly parallel compute, they usually talk about serverless, and I feel like there’s no new serverless that has emerged compared to the previous 5 years of serverless. You’re kind of in that new bucket. I don’t know if you have comparisons or philosophical differences that you want to call out.
No, I think, as you mentioned, it’s somewhere in between, right? It’s the ability to run stateful, long-running—you want to call them workflows, executions, whatever.
Vercel has Fluid Compute, and then Cloudflare has some container thing. Google has always had App Runner.
App Runner and the new one. Yeah, I forget a bunch of them.
I think that’s kind of where everything roughly is, and this is why we’ve been working on it for the last 6 years. We just believe you need access to a computer—you need a box that speaks Linux—so that you can deploy the things that you want to deploy on it. Other things are going to change the surface area of what you can build, but for us, we’re always like, “No, users need a computer, and they need to be able to deploy anything that they truly want.”
That’s why we focused for a long time on those primitives: network, compute, and storage. If we can give you those things, expose them to you, and allow you to run these things indefinitely, that’s where we believe it’s going to go in general.
You’re seeing right now, again, the whole Twitter-has-no-nuance thing: it’s servers, it’s serverless. It’s like, no, it’s always somewhere in the middle. You want to run it for a long time, but you don’t want to provision this resource statically or pay for things that you’re not using. That’s always been our thesis from day 1: pay only for what you use, run it indefinitely. It’s just full Linux, basically.
Yeah. I think that’s why I like the Vercel naming of Fluid, because it’s fluid and flexible. Another milestone—and then I wanted to ask one more technical question—is Heroku’s official deprecation. You are one of the presumptive new Herokus. “New Heroku” has been a category for as long as I’ve been in developer tooling.
It’s finally happening. What was that like? Is there any behind-the-scenes insight into why Salesforce let Heroku just stagnate?
Yeah. I mean, you just have so many people who are like, “You were running stuff on Heroku?” You as this company—it’s crazy that whatever name you would know is running this thing, and then you’re coming to us saying, “Yeah, we kind of want to move a lot of this stuff off,” or whatever. Okay, cool. But it’s kind of nuts.
Any behind-the-scenes insight into why Salesforce let Heroku stagnate?
Well, I mean, I can only guess. I think it’s just hard when it’s not your business. The business of Salesforce is to build a really, really good CRM, right? That’s their focus. They should be really, really focused on building a really, really great CRM.
Then you acquire this business as a compute business that’s kind of an offshoot of your business in general, right? I think a lot of the early Meta folks have talked a lot about focus. Boz has a whole write-up that he’s done, basically, where he talks about how, in the early days of Meta, they had no money and were forced to get focused.
Then they turned on the money tree. This is me paraphrasing or whatever. They turned on the money tree, and then they had no reason not to have focus because they just had infinite money, where they could split all of their focus, right? But that ends up diluting your product. It ends up making these offshoots where you’re just like, “Is that the focus of the business?” And it ultimately ends up not being if it’s not the core of your business, right?
So, to me, it’s kind of no wonder that it languished in general, because it just wasn’t the core focus of the business. I think a lot of companies get in trouble with this when they split out their focus in general, because it means that you’re almost fighting a multi-fronted war, trying to compete with all these things—not just compete with them externally, but compete with them internally for alignment: Where are we going? What are we doing? What is our purpose here?
If you’re really, really Salesforce-built, and you’re like, “Hey, listen, I love Salesforce. I really want to work on all those things,” and you’re mission-driven—which is the aspiration for a company in general, of why people work on things, right?—it’s like they want to work on something interesting. Heroku is off to the side. It’s not the core of the business.
To get those resources—budget, focus, alignment, or whatever—internally, it’s just pushed away. So it was literally just a matter of time for it to happen, in our mind.
Right. Yeah, I think kudos to them for actually calling it out instead of just letting it be unknown.
Yeah. Well, their whole release was a little bit odd because they kind of called it out as “Our Incredible Journey.”
Yeah.
They didn’t say they were shutting it down, but they were like, “Yeah.”
Yeah. Yeah.
So, yeah. Behind the scenes, I think they issued some stuff to people, being like, “Hey, yeah, you should close these accounts down. We are going to go in and deprecate this and remove it every time.”
It’s crazy because some of my first deployment experiences were on Heroku. It’s a foundational thing where—
I had a freaking alias in my bash for Heroku deployments.
Yeah, right. You start with dragging stuff into an FTP server, and then you move on to trying to get a deploy working: “How do I go and make this happen?” And it’s Heroku, right?
Shawn Wang
Did you know about Heroku hacks?
Jake Gollub
Yeah, exactly. You learn about all this, and it was the on-ramp for us. The wheel turns regardless. There’s new stuff emerging, and we’re very happy to continue to carry the torch for a lot of that stuff.
But we don’t want to be the new Heroku. We want to be the way in which people are building and deploying software, and ultimately the way that people monetize software over time.
Shawn Wang
I mean, it’s a big crown to be a new Heroku. There are like 50 companies that fought for this.
Jake Gollub
Oh, yeah. Everybody’s kind of holding some portion of this, being like, “Ah.” But for us, we’re just happy to support people and companies. The platform works a bit differently, so it’s obviously almost the same kind of game loop.
We’ve been quite dogmatic in terms of where we believe these things are going to go: the primitives, the agents fanning out into all of those other things. Some things will fit, and for some things, you have to change a few of the workloads. We don’t have—what’s that feature that people really love?
Shawn Wang
Pipelines.
Jake Gollub
Heroku.
Shawn Wang
Yeah, right.
Jake Gollub
We have some approximation of it with the environment system in general. So, yeah, it’s been super exciting. We’ve got a ton of people that we’re able to support, and it’s growing a lot.
Shawn Wang
Yeah. Any other technical infrastructure? I have one more beef: Temporal. Okay, so Temporal—I have sold my shares.
Jake Gollub
You’re a power user. You’re one of our earliest customers. I think I met you through Temporal or something. You’re a big Temporal user; you build on Temporal and have complaints. I think this is the most neutral, most informed conversation that anyone will ever hear about Temporal without someone working at the company.
Shawn Wang
Yeah, that’s fair. It’s the two of us.
Jake Gollub
Yeah, yeah. No, I think that’s fair.
I have used Temporal for almost 10 years now, because of Cadence and all those other things.
Shawn Wang
Just give people a sense of what Cadence is at Uber. People don’t know.
Jake Gollub
Cadence was the precursor to Temporal, and it powers all of the trip actions: the rides, when you rent a JUMP bike or scooter, or a car. Anything like that—you’re running these workflows for a period of time and basically saying, “This ride will run for an indefinite period until it finishes,” right?
You can attach information, whether it’s, “Oh, you paused it in this zone, so you need to add this dollar charge to the bill,” or anything else like that. Then, when you end the trip, your workflow is done. That whole experience behind the scenes—I don’t know about today, in general, but it was powered by Cadence at that point in time.
Shawn Wang
I used to say it’s like, imagine if you could program the entire user journey top-down as one function.
Jake Gollub
Yeah, right.
Shawn Wang
Yeah. Yeah.
Jake Gollub
It’s such a powerful idea, and it’s so important. It’s also incidentally so important for the next phase of the agentic journey, where you want an agent to do a specific task, and then you want it to be complete or incomplete on that task and move on to the next thing, right? You need a way to manage these workflows dynamically.
For me, Temporal was always really, really great in theory, and it was really, really great when you got it working the way that you wanted to in production. It’s just that it required you to model that entire journey in your head. If you didn’t have the entire journey in your head, you could put yourself in a spot where you caused issues, where replaying the state of the entire workflow caused a nondeterminism issue.
Shawn Wang
Because it works on deterministic workflow history.
Jake Gollub
Yeah, exactly. The way that I would describe it is: it’s a jet engine, right? If you know how to operate it, if you know how to run it, all of those other things, it works really well. But you can’t hand it to people who are trying to build things that end up being complicated but don’t have that whole state in their head.
For example, we run our whole deployment pipeline on top of it. That’s a reasonably complicated workflow. There are pre-commit hooks, signaling, queuing, and all of this other stuff in general.
As you try to express this large workflow, as you mentioned, going all the way down gets more and more complicated. There are more and more states in the state machine that you have to map back to the right thing.
Shawn Wang
Yeah, exactly.
Jake Gollub
At Uber, we built a system for doing the state machine and testing the state machine and all that other stuff. We’ve started to build some of those things here because it’s grown quite heavily.
It’s not exactly a love-hate relationship, because that’s too broad. When it works really, really well, it works super, super well. But then you run into a situation where somebody who hasn’t interacted with the system or doesn’t have the full context goes and puts something in the system that invalidates some of the state, causes a nondeterminism issue, spins off a ton of activities, or anything else like that.
Then you have to keep track of all these underlying knobs, like, “Oh, we have the number of activity slots in this thing.” These should just scale with memory, vCPU, and all of those other things in general. It ends up becoming a bit of a bear to scale out.
Shawn Wang
Yeah, so you need a very capable sysadmin running things behind the scenes for you.
Jake Gollub
Yeah, yeah.
Shawn Wang
If you were to move off, what would you do?
Jake Gollub
I think we would build our own workflow system. We have a few internally that we’ve worked on.
Shawn Wang
This is one of those things where you typically wouldn’t vibe-code it, but I’m wondering if—
Jake Gollub
Well, I don’t think you should vibe-code it still. You still want to run type tests and stuff like that to make sure that you—
Shawn Wang
I mean, you know, it’s not like Temporal had to invent that from scratch either, right? There are libraries for those things.
Jake Gollub
Yeah, that you can run. On top of that, it’s just a state machine that you really have to map out. Ultimately, you define the abstractions that you want, run it through a state machine, and that’s it.
Shawn Wang
Yeah, it’s very doable.
Jake Gollub
So, yeah, I think the workflow stuff is very interesting. There are a few really cool companies; I think Restate is doing some neat stuff here.
Shawn Wang
So you’re very tied into JavaScript. You’re like a JavaScript maxi?
Jake Gollub
Internally, we have TypeScript, Rust, and Go. Those are the 3 languages, right? We don’t add any more stuff. Actually, that’s not true. We have a little bit of C because we write eBPF code and its hooks and stuff like that.
But those are the languages we use. We use TypeScript a lot because it powers the dashboard, but we’re going to move a lot of the workflow stuff off of the dashboard stack and into the infrastructure stack.
Shawn Wang
Yeah. Don’t power things on the front end, guys, even though it’s free compute.
Jake Gollub
Yep.
Shawn Wang
Yeah. Yeah. Cool. Any other technical infrastructure cool stuff? Railpack. I don’t know if that’s still—
Jake Gollub
Yeah.
Jake Gollub
Yeah, we built that engine for determining dependencies based on your source code, which is super cool. It’s called Railpack. We built the first version, called Nixpacks, on top of Nix, and then we moved on.
Shawn Wang
People have been trying to get me to adopt Nix and NixOS for 4 years.
Jake Gollub
Yeah.
Shawn Wang
Is it ever going to be a thing?
Jake Gollub
I don’t know. We were super excited about it in general, but it has a bunch of pain points. If you think of it, it’s a stack of versioned binaries at specific slices in time, right? If you want version X and version Y, you end up bloating a lot of your package space, which blows up the size of your images and makes it really difficult for real-world workloads.
Shawn Wang
But you content-address it and cache it. There are a lot of optimizations that, in theory, you should be able to do.
Jake Gollub
In theory, yes. What happens ultimately is that you have a large enough user base and a disparate enough set of machines that you run into the problem described in a paper that Meta released, XFAAS, its internal serverless system. It becomes very difficult to do that at scale unless you break out specific runtimes, which we did not want to do because we wanted to truly allow you to deploy anything.
That was our initial thing with Nix, but we’ve moved toward some interesting stuff that I think we’ll be able to talk about a little later. We’ve built content-addressable file systems that can lazy-load anything from any point and then just page that into memory.
Shawn Wang
Amazing. Okay. Yeah, it’s going to be fun. The whole future is very bright. It’s crazy. It’s going to be nuts. Okay, founder journey stuff.
Yeah. And your cloud usage—you tweeted you’re going to spend $300K this month.
Jake Gollub
I think we got 2 coding agents across the company.
You only have 35 people, so I’m sure they’re not all spending $10K a month. What’s the distribution?
Jake Gollub
I think I’m at about $25K in general, and then we have some power users all the way down. We came back from winter break, and I was basically like, “If you are writing code by hand, you are doing this wrong,” right? The tools are good enough at this point that you can move extremely quickly.
Yes, there are issues and pain points and all these other things, but you should be reviewing the code that you’re writing instead of trying to write it by hand. All of those architectural patterns and all of those other things matter more now than at any other time. But you shouldn’t spend your time generating code that you would write.
If you know how to write it, just ask the agent to write it and then reconcile it until it looks like you would have written it yourself, right? Incidentally, people misconstrue my propensity to push people toward agents as, “Hey, we’re growing really fast and we’ve had some bumps in reliability.” They’re not necessarily related.
But I think people should really understand that the tools are good enough for you to move extremely quickly and build things way larger than you could have possibly built before. To our point way earlier about how you cool data centers in space, it’s like, well, I don’t know, actually, right?
But you’re at a point now with software where you can be like, “How would I build block storage from scratch? How would I go in and do these things?” I have ideas because I’ve got history. I’ve read all these papers in general. Let me work them out, and let me build massive test benches with thousands of tests, because they’re free to author right now, to make sure that this system can be built.
I think that if you’re not using these AI systems to almost speedrun your roadmap—to figure out where you need to be and reconcile your existing system onto the future—then you’re missing a large part of what’s happening right now. You can just template out anything and validate it on the side for free, right?
What’s the path to spending $3M a month? Is it bound by ideas and things that customers can absorb?
For most companies, I think it’s actually bound by deployment at this point in time. That’s why we’ve seen a massive boom in companies—from Fortune 50s and below—trying to figure out how to get their developers to move quicker.
You’re probably going to hit your CFO before you hit any of these limits, because they’re going to look at this and be like, “There’s an eye-watering amount of money being spent on these tokens.” I think—I don’t know which one—I think it was Uber’s Claude token budget for the entire year or whatever.
Inference costs have to come down, but we’re also inference-constrained at this point in time. You’re going to almost get this price discovery of what makes sense for an organization to adopt. I think what you’re going to end up with is almost the F1 driver concept.
If you have somebody who’s really adept at these things, it makes sense to put them into a $3M car or whatever, right? But if you’re not, then it probably doesn’t make sense for you to do that. We’re going to take a few of these people and say, “You drive the F1 car. We need to go in this general direction. Figure out if this works,” and almost prototype it.
We’ve done a few of those things where we’ve vastly accelerated our roadmap. We thought we were going to be able to ship something in the next few years, but actually we can probably ship it in the next few months now. We validated it, it works, and we don’t even have to build it incrementally. We can skip steps and just move toward where our vision is for a lot of this stuff.
Yeah, I think a lot of people are realizing the roadmap doesn’t always have a business impact. It’s like, “Oh, it’s too expensive to run these tokens,” but if your roadmap was actually built to make more money, by the time you built the whole thing, you would have some sort of token pricing for it.
It’s the same way you do with sales. You would spend $1B in sales if you knew you would get $2B of revenue out of it.
Exactly. The really naive way to measure this is almost your percentage of tokens that end up in production, right? If you can measure that you’re getting this level of impact because those tokens are ending up in production, that’s awesome.
But I think the burden of proof is now going to arise. You see it internally on our stuff, too. We have a growing number of pull requests that haven’t yet been merged, and you’re just like, “Okay, how do you get this into production?”
It’s really about how quickly you can build and deploy that software, which is exciting because we build and deploy software. The SDLC is changing, and it’s something that both of us are super interested in exploring as well.
Shawn Wang
One of my theses—or it’s not my thesis; it’s that the pull request is dying.
Right. It’s going to be the prompt request.
Shawn Wang
And beyond that, code review is also kind of dying, because do you really need it if you have all the other systems in place? What else is changing about the SDLC?
What else is different? Well, I think the AI SRE is one of those things where it’s a pie-in-the-sky aspiration. What does it take to get an AI SRE?
By the way, you should expose your tooling to your customers at some point, right?
Yeah. Which tooling?
Shawn Wang
The central command center.
Oh, Central Station. We have it for template maintainers, so template maintainers can deploy and maintain templates, and they get feedback on a lot of that stuff. We’re 100% going to expose those things incrementally.
Shawn Wang
Yeah, but clustering around incidents—everyone has a version of that, but I don’t think anyone has solved it.
Yeah. Right. I don’t want to say we’ve solved it internally, but it’s gotten so good that now we can see those incidents forming pretty quickly.
Shawn Wang
Yeah. Real time.
Yeah. So at some point, those will be things that either somebody else goes and builds or we go in and build. But we've always built stuff that was purpose-built for us, and if it made sense and there was a way to make it useful for users or monetize it, or make sure that that loop becomes a profit center instead of a cost center, we want to do that at some point, right? So, yeah, SaaS is definitely dying.
Shawn Wang
Do you do first-party feature flagging and incremental rollout-type stuff as well?
So we have a feature-flagging engine that we built internally that, at some point, we will roll—
Shawn Wang
Because I don't see it as a user.
Yeah. Yeah. Yeah.
Shawn Wang
So, like, that would be—that's good, right? How come you didn't give us what you have?
Well, because we have to beta-test it. We actually care a lot, a lot, a lot about the quality of the things. There's plenty of stuff that we've used internally and then gotten to a point where it doesn't make its way entirely through the journey because it fails, right? It holds for one service, but it doesn't hold for multiple services, right?
We'd have to build these things for multiple services to make this work, right? And we know for a fact that if we release this thing, we'd have to rebuild it again and again and again. Some things are worth doing that for, but a lot of them are basic like that. That also kind of informs our roadmap: for us to make that actually a bit easier, we can do a few of these things first, and then we get to that experience, right?
We don't want to dilute the experience by basically saying, “Oh, yeah, this works, but only for this service,” right? Unless it's a very, very core initiative, which is, “Over the next few months, we're going to roll out a few things where it works for a single service, then it works for multiple services, and then it works for multiple services across the environment.” But you have to be very, very deliberate about those things. Otherwise, you end up with a bunch of broken, disparate experiences, which ultimately create a ton of support load because people are like, “How do I use this feature? How do I go in and do this other stuff?”
It's kind of the thing we talked about earlier: you expand your company in general to get those features, and then you almost compact it and smooth out those things so the experience is really, really stellar. We were talking in the hallway earlier, where you're like, “Oh my God, it's gotten so much better,” and I'm like, “Oh man, internally, we're like, ‘Damn, this part really sucks. We have to make this significantly, significantly better.’”
Shawn Wang
No, I can attest. Over the last 3 years that I've watched you build Railway, the importance of feature flagging is a very big part of Uber culture. So much so that they have too many feature flags, and then they have another thing to remove feature flags.
Yep. 100%.
Shawn Wang
What was it? There's a paper about this.
Flipr. And there's been another one.
Shawn Wang
Facebook has Gatekeeper. Yeah, so they're really important.
And agents are going to need this. That's the fundamental thing behind incremental rollouts.
Shawn Wang
OpenAI acquired Statsig. Yep. And basically, GPT-5 is just routing and flagging through different models.
And it's super important, right? Because if you assume the software development life cycle is 100% going to change, it's going to change because we're trying to do things 1,000 times faster and 1,000 times more concurrently than we currently do them, right? And so, routing.
Shawn Wang
Yeah. Right.
What ends up becoming important at scale? Before I even started Railway, I actually built a feature-flagging product and tried to sell it to people, right? I was like, “Oh, it's an easier version of LaunchDarkly or whatever,” right?
I ran into this situation where anybody who's small enough to adopt your technology doesn't care about feature flags, right? And anybody who's large enough to actually need feature flags needs so much scale that you have to build out all the existing infrastructure. So I ended up scrapping that.
But what is old is new again, because now companies are trying to move really, really quickly. You can't just YOLO this vibecoded thing straight into production. You need to say, “Hey, here's my blast radius. Here's my impact. Here's my whatever. I want to shadow it for these users,” right? Feature flags, right?
You're going to need those tools that ultimately those larger companies ended up having to build to maintain their structures. Everything's just going to get compressed by 1,000× so that everybody can do that and everybody can build those structures really, really quickly, right? That's exactly where we're at right now: you're compressing the software development life cycle, and then we're going to expand it and add way more new things to it.
Shawn Wang
Yeah. The other term that comes to mind when this kind of discussion happens, for newer developers who haven't heard it, is “cattle, not pets.” Your prod has a name like a baby; you have to keep it alive. But when it's cattle, you can just mass-farm, roll out, portion out parts of them, and kill them or whatever.
Yeah. Exactly. I actually think that maybe that's the hot take, but I think that's actually going to change. I think you can move toward having pets so long as you have a—and this is going to be a jump—so long as you have a cloning machine for your pets.
Shawn Wang
Uh-huh. Yeah. Yeah. If you can snapshot every single thing at every frame, then it actually doesn't matter if it got obliterated because you have some sort of snapshot of it, right?
All of the things that we've built right now are essentially to block out any sort of changes or alterations or whatever from that hermetically sealed DevOps pipeline. It's like, “Okay, well, you have to write a Dockerfile because I only need this specific instance—only this specific cut of the file system, et cetera,” right? What if you just had the whole file system? What if you just snapshot it and lazily load the entirety of the file system? Then you can get around this problem entirely.
You don't need the ceremony of having a Dockerfile or an Ansible script or all of these other things. You can just iterate on that loop and then snapshot it. Is this the right loop? Is this the right thing at this point in time? Okay, cool. Now I'm going to merge it into production—go merge the file system.
Shawn Wang
Yeah, why not?
It's going to be really fun.
Shawn Wang
Yeah, this is a whole other can of worms, but I think the number of things that are stateful in a VM—I think if you just catalog them and develop dedicated solutions for solving each of them, you can cut this problem down a lot. It's surprising that people weren't really trying until now.
Yeah. Well, it's surprising. It's always been surprising to me because these are the things that we work on. I'm like, it's so obvious.
Shawn Wang
First principles: you need them. Everyone, in theory, needs them. And then the big clouds don't do them, so you're like, “It's impossible or something.” I don't know.
Yeah. Exactly. You're like, “Oh, well, they—you know, Meta has all the people who write eBPF code, and they're doing something with them.” But you need that kind of stuff to solve these problems, right?
And like we talked about earlier, whatever is required, however deep we have to go to solve those problems—all the way down to the kernel TCP/IP stack—we're going to figure that out. Is there something that we need to modify to make that work for the mental model that we have for the universe moving forward? Yeah, 100% we're going to do it. We'll just keep going.
Shawn Wang
Sounds fun.
It's super fun. It's so much fun. I have to literally peel myself away from the fun, interesting problems that we have to make sure that we can scale the company in a way that works.
There are so many different fun, interesting problems, whether it's how you get the information from the customer to support to the person who built the thing internally, right? Or it's like, how do you get iteration, or how do you get context from the dashboard to users, or how do you drill down all the way to the infrastructure layer? How do you manage orchestration as a real-time operating system versus a feedback control system, right? It's just so fun, you know?
Shawn Wang
Yeah. I mean, speaking of that, maybe talk about the founder side. You're famously, like, the YC/SF consensus is: you go to YC, you get a co-founder, you do all these things. You've done none of that.
No, I’ve done a lot of different things in general, right?
Shawn Wang
In the elevator, you were like, “Actually, co-founder—it kind of makes sense if one person is the tech person and the other is the bizdev person.” Yep. But you have to contain all those multitudes yourself. How do you do it?
Okay, I was going to ask: is there a question in there or what?
Shawn Wang
Yeah. The question is, what the hell—how do you do it? The question is, how are you alive right now?
Yeah. Well, just try to get 8 hours of sleep.
Shawn Wang
Is there a balance that you ideally like—50/50, 30/70? What’s the mental model that you use as a balance?
You just have to think about all these things and be obsessed with all of them, whether it’s being obsessed with how people think about your product from a go-to-market perspective, or being obsessed with, “Well, if I can make this change at the kernel level, then I can make it so that the user’s SSH connection never drops.” That’s what I want. I want a universe in which I can snapshot all these things and it looks exactly like you would just iterate on a VM, right?
I think you just have to be obsessed with all those things at every layer of the stack. I think that’s what makes it easier for me.
I think some people are obsessed with different portions of the journey, the company, whatever, right? And I think that’s when you can get really, really good cohesion by segmenting out these things. In the elevator, I was talking about how you have a technical person, et cetera, and then you have the customer person in general.
I think if you can segment those lines out really, really well and be very, very clear about what your areas of ownership are for yourself, your company, or just where you’re going to operate, you’re going to have a good time. If you can’t be clear about those things, this is why I was saying 2 is the worst number of co-founders: you have no tiebreaker. You basically are like, “Well, I disagree on this thing, and I disagree on this thing.” How do you resolve that?
Shawn Wang
Well, you say someone’s CEO, right?
Right, exactly. Then you’re like, “Okay, you have the tiebreaker.”
Yeah, totally. I mean, listen, it’s hard. It’s hard every single way you cut it, right? It’s hard if you get help. It’s hard if you do it yourself. It’s just hard to run things, roughly speaking, right? But it’s so rewarding. It’s so fun.
Shawn Wang
What have you found useful? A coach? Any advice that has been really helpful?
I like to write a lot. I get in trouble a lot for my Twitter. I think there’s a pattern.
Shawn Wang
Who do you get in trouble with?
The people on Twitter, you know.
I was talking about it and I was like, “Hey, if you’re working weekends, you’re kind of messing up your planning,” roughly speaking. I’ve gone kind of back and forth on that, right? I think actually right now we’re at an exigent time in general where it makes sense to work more, because the goals are pretty clear in my mind.
If you have the vision and you know where you’re going, you should work a little bit harder to distill that vision and go do those things. But if you’re like, “I think we should be going on this journey, but I’m not 100% certain and I want to get a little bit of clarity,” what you need to do is disconnect and take your weekends very, very seriously.
You need to write about where you are, what you want to do, where you want to go, what problems you’re trying to solve, and think about a lot of these things. Writing is important. Sitting down—I don’t like the word “meditation” or whatever—but whatever gets you into the state of mental clarity, that’s the thing that’s really, really important when you’re trying to go on these journeys of saying, “We’re here, and we really need to be here,” in general, or, “We’re here, and I think we need to be roughly in this kind of space for this to work.”
Disconnect, hang out with the people you love, and work super, super hard when you’re working. I try and work from sunup to sundown Monday to Friday, all out, in general. Then I try and disconnect on Saturday, and I come back to work on Sunday afternoon. I do my writing plan for the week, all those other things, and it works really, really well for me.
Another hot take is that most advice is to be digested and thrown out the window. If it’s helpful, it’ll come back. If it’s helpful, you’ll have learned it over time through experience or anything else like that.
You mentioned the standard YC advice and all of those other things. We’ve made failure as a society very, very expensive, and it makes it difficult for people to trod off the paths.
Shawn Wang
Yeah, makes sense. Any other hot takes you want to get on—anything that you haven’t tweeted and gotten in trouble with that you want to preview to the world?
No. I think the agent stuff is crazy. It’s going to be the dominant way in which people are doing pretty much everything, provided we, of course, get the amount of inference required for that to happen.
Over the next 10 years, you just see a fundamental shift in terms of how people are thinking about even just authoring the logic that’s in their head.
Shawn Wang
Yeah. Maybe one way of phrasing this is: if all birds can become a GPU provider, so can Railway.
Yeah. I think there’s a lot of horror in us actually not becoming a GPU provider. I think you’re defined almost more by the things that you don’t do than the things that you do, because it’s really, really easy for you to just say yes to a bunch of different things.
I think it’s going to be very, very interesting to watch. Anthropic is an amazing company—super, super stellar—and they’re moving into a variety of different zones. They’re moving into the Figma kind of stuff that they’re after, right?
Shawn Wang
Yeah. Bret Taylor was on Figma’s board, and then they removed him on Monday, and then they launched this today.
Yeah. Things move very, very fast right now. It’s just going to be the way in which people are—
Shawn Wang
Okay, so your answer is focus. No GPUs for now.
Yeah. Focus. Never say never.
Shawn Wang
Yeah, right.
I can tell you for a fact that we will not be doing GPUs now, but we 100% will be doing GPUs at some point in the future. That’s not me leaking our roadmap, because we don’t have plans to go and do GPUs. It’s just a function of the fact that, at some point, you need FLOPs.
At some point, if you’re fully vertically integrated and you want to make it really, really trivial for people to go and iterate, build, and deploy things, you need access to this core piece of fundamental logic.
Shawn Wang
At some point, presumably, your own data center traffic is a minority of your workload right now, but is there a majority, or do you just completely turn it off?
Avi Press
Oh, at some point we got to 100% data center—our own data centers. It’s right now the vast majority of the stuff that exists on our bare-metal data centers, right?
Shawn Wang
So you’re already there—vast majority?
Avi Press
Yeah. I didn’t know the extent of the transition. It was completed at some point, and then we grew so fast that we had to basically scale back on that.
Shawn Wang
Take us back—sorry, Google Cloud.
Avi Press
Yeah, it was funny. We got to—on the Datadog dashboard, it got to 100%, and then it dipped back down into the 90s or whatever because we were—
Shawn Wang
Adding capacity.
Avi Press
Yeah.
Shawn Wang
Yeah. It’s interesting. You’re literally building a new cloud, and that’s independent. People assume that could never happen post-AWS.
Avi Press
Yeah, and it’s hard, right? We’re going to figure out a bunch of different things to make sure that the platform is deeply, deeply reliable. You have to break ground on a lot of new things when you decide you’re going to build a cloud from scratch but not copy the hyperscalers.
We’ve been very, very deliberate to invent our own infrastructure from scratch, based on reading a ton of papers in general, but almost promising to ourselves that we wouldn’t copy somebody else’s homework. We were saying, “Hey, listen, if we copy somebody else, we lose. You’re just going to become them over time.”
You have to have a core thesis about why this business needs to exist at this point in time. For us, it’s always been about the activation energy to get something deployed in production at any of the hyperscalers. As of right now, it’s far too high, and we believe that it should be instantaneous.
We believe there should be no friction between what your thought is and the reality that comes out, that you can share with your friends, right? That's what we're building toward at every layer of the stack. If we have to go down to energy, we'll go down to energy at some point, right? It matters a lot to us from the experience of giving people access to this tooling.
It's gated behind multiple layers. It's not even just gated for regular citizen developers who are now vibe coding. You have the citizen developer, the front-end developer, the back-end developer, a DevOps person—all of these layers, right? They all need to disappear so people can just ship like that.
Shawn Wang
Amazing. All right, that's the future of cloud.
Avi Press
Thank you for having me. It's been wonderful.