资深软件工程师，Golang
Staff Software Engineer, Golang
Block Labs 是一家位于 Web3、人工智能和 iGaming 技术前沿的顶级技术工作室。我们不只是交付功能；我们构建可扩展、生产级的平台，为下一代数字产品提供支持。
我们是一群资深工程师、产品战略家和建造者，对架构从不妥协。无论我们是在设计自主多智能体 AI 系统、构建去中心化金融基础设施，还是架构高频 iGaming 平台，我们的标准都是卓越。
我们行动迅速，但构建的是长期解决方案。如果你希望与一个重视深厚技术专长、深思熟虑的系统设计和产品所有权的团队一起工作，那么 Block Labs 就是你的归属地。
职位描述
我们在加密货币、金融科技和真实金钱游戏领域构建分布式、事务性后端平台。高吞吐量、多租户、实时处理。余额、支付和玩家相关决策都依赖于它们，因此正确性不容妥协，错误会立即显现。这项工作涉及多个产品，并遵循业务优先级，因此你所负责的内容会随时间变化。你将作为独立贡献者，使用 Go 语言构建并负责分布式、事务性后端服务。
在这里，“拥有”有特定含义。你收到的是结果及其约束条件，而不是分解后的待办事项。你识别尚未做出的决策，并收集上下文以做出这些决策。你定义范围和顺序。你做出架构和实现决策。你亲自实现系统，而不是将其委托给他人。其他人会对此进行贡献，而你负责确保他们能够这样做而不影响质量。你负责交付它，并持续负责其在生产环境中的表现。
在这里，代理是正常的生产方式，而不是可选的辅助工具。这并不会减少对工程判断力、测试或运营责任的需求，反而增加了每个工程师需要承担的这部分内容。
你将与产品、工程、基础设施和 QA 团队合作，并且你需要擅长这一点，因为没有人会为你协调这些工作。
你将负责
- 将业务成果和约束转化为可规划、可排序、可交付的工作。
- 设计并实现处理高吞吐量事务负载的分布式 Go 服务，集成支付、供应商和内部平台。
- 明确保证正确性，并对其负责。余额和交易
查看英文原文
About Block Labs
Block Labs is a premier technology studio operating at the bleeding edge of Web3, Artificial Intelligence, and iGaming. We don't just ship features; we engineer high-scale, production-grade platforms that power the next generation of digital products.
We are a collective of senior engineers, product strategists, and builders who refuse to compromise on architecture. Whether we are designing autonomous multi-agent AI systems, building decentralized financial infrastructure, or architecting high-frequency iGaming platforms, our standard is excellence.
We move fast, but we build for the long term. If you are looking to work alongside a team that values deep technical expertise, thoughtful system design, and product ownership, Block Labs is where you belong.
The role
We build distributed, transactional backend platforms across crypto, fintech, and real money gaming. High volume, multi tenant, real time. Balances, payments, and player facing decisions depend on them, so correctness is not negotiable and mistakes are visible immediately. The work spans several products and follows business priorities, so what you own will change over time. You will build and own distributed, transactional backend services in Go, as an individual contributor.
Ownership has a specific meaning here. You receive an outcome and its constraints, not a decomposed backlog. You identify the decisions nobody has made and gather the context to make them. You define scope and sequencing. You make the architectural and implementation decisions. You implement the system rather than delegating it. Others will contribute to it, and you own the conditions that let them do so without degrading it. You ship it, and you remain responsible for how it behaves in production.
Agents are the normal means of production here, not an optional aid. That does not reduce the need for engineering judgement, testing, or operational ownership. It increases how much of each one engineer carries.
You will collaborate with product, engineering, infrastructure, and QA throughout, and you will need to be good at it, because nobody will be coordinating it on your behalf.
What you will do
- Convert business outcomes and constraints into scoped, sequenced, shippable work.
- Design and implement distributed Go services handling high volume transactional workloads, integrating with payments, providers, and internal platforms.
- Make the correctness guarantees explicit and hold them. Balances and transactional behaviour have no margin for approximation.
- Run the agentic system that produces the work: context, decomposition, execution,
verification.
- Set the harness and guardrails others work inside: context, tests, and automated checks that let people contribute to your system without it degrading into debt you inherit.
- Operate what you ship. Know its failure modes, watch it, and fix it.
What we are looking for
- Deep proficiency in Go on high volume, transactional systems. Years matter less than what you have personally taken to production.
- Strong judgement on multi tenancy, event driven architecture, queues, and the failure modes each brings. Cloud native, and serious about reliability, observability, and security.
- A repeatable agentic engineering system you built deliberately. It holds context, decomposes ambiguous work, verifies behaviour rather than diffs, and keeps unverified code out of
production. The system matters, not the tools.
- Evidence of carrying the whole chain yourself, from incomplete objective to a system you
shipped and then owned in production. Having worked on every phase is not the same as
having carried one.
- Judgement under ambiguity. There is rarely a finished specification, but there are objectives, constraints, and people who know things. Make the reversible calls yourself and escalate the rest.
Nice to have
- Background in fintech, real money gaming, or other high traffic consumer products where
money is at stake.
- Experience with rules engines, real time scoring, or decisioning systems.
- Prior experience designing APIs for multi tenant or white label products.
What this role is not
- Not a management or tech lead role. There is no team reporting to you and no plan to create one.
- Not an architecture or advisory role. You will not set direction for others to implement.
- Not a squad role. There is no prioritised backlog and no one assigning you work.
- Not a role where you own one layer of somebody else’s implementation, or where someone else owns verification and production readiness on your behalf.
- Not a role where agents are an optional productivity aid you reach for occasionally.
If what you want is a well defined squad, finished requirements, and shared implementation, this is a role to skip. That is a legitimate way to work and many strong engineers prefer it. It is not this one.
What kind of culture can I expect?
Mature, mission-driven, and low-ego. We value clarity over noise, outcomes over theatrics, and pace without chaos. If you’re one of the smartest minds in your craft and want to build with other experts, you’ll feel at home here.
Originally posted on Himalayas