Founding Engineer

0to9 Ab; Wrocław; On-site; PLN 180,000 - 260,000; Full time

Job summary

0TO9 is an early-stage bank for entrepreneurship, building a stealth banking product with a small, agile team. You will shape architecture, contribute to product thinking, and work directly with founders to implement an ambitious, AI-driven platform.

Ideal candidates ship real software, thrive in ambiguity, and balance business needs with sound engineering judgment. The role emphasizes pragmatic generalism across the stack and a mindset focused on fast, high-impact delivery.

Qualifications

• Shipping real products and turning ideas into useful software.
• Comfort with ambiguity and iterative problem solving.
• Ability to engage in customer conversations and influence technical choices.
• Pragmatic, cross-stack capabilities across backend, frontend, and DevOps.

Responsibilities

• Prototype ideas quickly and validate with real users.
• Join customer conversations to shape product and business model.
• Make fast, reversible architectural decisions and discard what doesn’t work.
• Define tooling, standards, and workflows for future teammates.

Skills

Builder

AI-native

Ambiguity tolerance

Business-minded

Generalist

Tools

Agentic tools

Claude Code / Cursor

Job description

About 0TO9

0TO9 is a bank for entrepreneurship, built by and for financial innovators. We provide infrastructure for entrepreneurs ready to start and scale the next generation of financial products and platforms. Founded in 2025, we're already 200+ co-workers across Europe, and growing fast. Our name reflects our mission: from zero to success, from idea to impact, from now to what's next.

The Venture

We're early and in stealth, so here's what we can say: it's a new banking business, separate from anything else in the group, aimed at a market we think is badly served today. The company is already led by a CEO. The customer, the product, and the wedge are what you'll help us find.

What we're not doing is a hiring cycle to backfill a team. You're early enough that the first architecture calls, the first engineering culture, and a good share of the product thinking are genuinely yours.

How We Build

This is the part we'd be lying about if we said everyone does it.

We build on .NET and SQL on the backend and TypeScript on the frontend (React and Vue). Prior experience in these helps, but it isn't the bar — what matters is that you want to build in them. Agentic tools make an unfamiliar stack cheap to learn; they don't make an unwilling one work. The fundamentals below are what we can't teach you in the first month:

• Engineering standards loaded as a skill, so agents apply them automatically.
• A git-backed knowledge base that agents read and extend.
• Agent workflows that take a change from branch to reviewed PR.
• An automated reviewer in CI that counts as an approving review on a pull request. In a team of one, that last one matters.

We're not looking for someone curious about whether this works. We're looking for someone who already builds this way - and will push it further than we have.

What You Will Actually Do

1. Compress the distance between idea and working software: prototype, put it in front of real people, and let what you learn kill or grow it. Implementation is the fast part of this job; deciding what deserves to exist is the hard part.
2. Sit close to the problem, not the backlog: you'll be in customer conversations and in the room where the business model gets argued about. We expect that to change your technical choices, not just inform them.
3. Make fast, reversible decisions: simple, boring architecture that can be thrown away. We don't have scale yet, and pretending otherwise is the most expensive mistake available to us right now.
4. Set how engineering works here: tooling, workflow, standards, guardrails — for whoever joins after you.

Technical Requirements

Agentic tools help you pick up anything unfamiliar fast - but these fundamentals should already be there:

Stack

• Backend: .NET and SQL.
• Frontend: TypeScript — React and Vue.

Cloud & Infrastructure

• AWS-native: ECS/Fargate, S3, least-privilege IAM.
• Container fluency: build, ship, and debug in production.
• Security by default: WAF, encryption at rest and in transit.
• EU data residency: aware of why region matters (eu-north-1).

Architecture

• Microservices & DDD: boundaries by domain, not layer.
• API/event-driven: no shared databases.
• Resilience patterns: retries, backoff, idempotency.
• Clean, SOLID code: safe for a human — or an agent — to extend.

Delivery & Quality

• CI/CD fluency: GitHub Actions or equivalent.
• Test-driven habits: 80%+ coverage, no exceptions.
• Reviewable PRs: small diffs, no self-merges.
• Supply-chain hygiene: dependency & SCA scanning before ship.

Observability & Security

• Structured logging & tracing: CloudWatch, Datadog, or equivalent.
• Zero hardcoded secrets: Secrets Manager or equivalent, always.
• Encryption everywhere: KMS at rest, TLS in transit.

Nice to Have

• .NET / TypeScript experience:you'll ramp faster. Coming from another ecosystem is fine if you're genuinely happy writing C#.
• Fintech / regulated-industry background: you'll ramp faster.
• Agentic tools as your daily driver: Claude Code, Cursor, or similar.

Who You Are

• Builder, not just coder: you've shipped real products (side projects count) and know the difference between “working” and “done.”
• AI-native: you already lean on LLMs and agentic tools daily and are curious how far that can go — you see them as leverage, not a shortcut.
• Comfortable with ambiguity: you don't need a fully specified problem to start making progress.
• Business-minded: you can hold a conversation about unit economics, customer needs, or go-to-market — and let that shape your technical choices.
• Pragmatic generalist: deep specialization matters less than range and judgment; you can move across the stack as needed.

What Success Looks Like

• Within weeks, not months, you've helped ship a working prototype we can put in front of real users.
• You've established a lightweight, AI-augmented way of building that lets a tiny team punch far above its weight.
• The founders trust you as a thinking partner, not just a pair of hands.
• Whoever we hire next inherits a codebase and a way of working that's simple, fast, and easy to build on.