Senior Backend Engineer — Tokyo

Tokyo has a senior backend engineer problem. Not a talent problem—the Japanese tech scene is full of them—but an alignment problem. On one side, fast-growing FinTech companies that need robust, scalable systems built with modern stacks. On the other, experienced engineers often stuck in legacy organizations where Go and Kubernetes are still buzzwords, not daily tools.

At Abbeal Tokyo, we build critical backend platforms for Japanese FinTech clients. Not PowerPoint consulting. Production code that processes real transactions, with unforgiving SLAs. We're looking for a Senior Backend Engineer who can join a bilingual team (JLPT N2 minimum) and take ownership of systems that matter.

This article details what we concretely expect, why this position exists, and what it really means to work at a senior engineering services company in Tokyo in 2025—without the usual job description bullshit.

Why this position exists

Our Japanese FinTech clients have specific needs that can't be solved with off-the-shelf solutions. They're migrating 10-year-old monolithic Java systems to modern microservices architectures. They're launching new financial products that require real-time APIs with transactional consistency guarantees. They're scaling from 100k to 10M users and discovering their infrastructure can't keep up.

The Japanese context adds constraints: strict financial regulations (FSA), data sovereignty requirements, interfaces with legacy banking systems that still communicate in JIS X 0208. You can't copy-paste a standard AWS architecture and call it a day.

We're looking for someone who can navigate this technical AND cultural complexity. Who understands why a payment system must handle idempotency keys differently depending on whether you're dealing with Zengin or international cards. Who knows that a database migration on a critical service doesn't happen on a Tuesday afternoon without coordination with 4 different departments.

Tech stack: what we use and why

Go as primary language

We've standardized on Go for backend. Not out of dogma, but because after 3 years of FinTech projects, it's what works best for our use cases: predictable performance, simple deployment (a single static binary), concurrency model that handles typical I/O-bound workloads of financial APIs well, mature tooling for distributed services.

We expect you to be comfortable with idiomatic Go, not just capable of translating Java. That means: understanding trade-offs between channels and mutexes, knowing when to use context.Context for cancellation, writing table-driven tests that aren't painful to maintain.

Kubernetes in production

All our deployments go through Kubernetes. We use GKE for most clients, sometimes EKS when there are existing AWS constraints. We expect you to understand not just how to deploy a pod, but how to debug a memory leak in a container, configure resource limits that don't kill performance, set up health checks that actually detect problems.

Reality: Kubernetes in production FinTech is 20% YAML config and 80% troubleshooting. Understanding why a service takes 30 seconds to respond after a rolling update. Investigating intermittent timeouts that only appear under load. Optimizing startup times because a 2-minute cold start isn't acceptable when you're scaling horizontally.

PostgreSQL and data consistency

PostgreSQL remains our relational database of choice. We work with transaction logs that must be ACID-compliant, schemas that evolve without downtime, query plans that need optimization because a full table scan on 50M rows breaks the SLA.

We expect real database understanding, not just knowing how to write basic SQL. Isolation levels and their implications. Index strategies (B-tree vs GIN vs BRIN depending on the case). Partitioning to manage growth. Replication lag and how it impacts application architecture.

Infrastructure as Code with Pulumi

We use Pulumi (primarily TypeScript) to manage infrastructure. Deliberate choice vs Terraform: we prefer real code with type checking and unit tests rather than HCL. It allows us to build reusable abstractions across client projects.

You don't need to be a Pulumi expert—we have established templates and patterns. But you need to be comfortable with the IaC approach in general: everything versioned, everything reviewable, everything reproducible.

The profile we're looking for

Senior for us doesn't mean "X years of experience". It means ability to take ownership of a complete system, from architecture to implementation details. Ability to unblock a team when it's stuck. Ability to say no to a bad technical choice even when it comes from a client.

• Substantial backend experience: 5+ years building and maintaining production systems, ideally in domains where reliability matters (FinTech, healthtech, high-volume e-commerce)
• Ownership mindset: you don't ship code and move on. You follow it in production, you wake up at night if it breaks, you progressively improve it
• Clear technical communication: able to explain complex trade-offs to non-technical stakeholders, in Japanese AND English
• Pragmatism: you know when to optimize and when to ship "good enough" code. You understand the business context of your technical decisions
• Technical curiosity: you read postmortems for fun, you test new approaches in side projects, you have reasoned opinions on tools

The language constraint: why JLPT N2+

We require JLPT N2 minimum (or demonstrable equivalent). This is non-negotiable. Why? Because our clients are Japanese companies where decisions are made in Japanese, where specs are written in Japanese, where incidents are reported in Japanese by local teams.

Internally at Abbeal, we work bilingually—Slack mixes English/Japanese depending on threads, meetings in Japanese for clients, in English for pure technical discussions. But you can't be effective if you depend on a translator to understand requirements or participate in retrospectives with the client.

N2 is sufficient. We're not asking for native mastery. But you need to be able to follow a 60-minute technical meeting in Japanese, read a spec without Google Translate every 3 lines, write a comprehensible incident report.

What you'll actually do

The first 3 months, you'll be ramping up on an existing client project. It looks like:

1. Week 1-2: Environment setup, code review of existing codebase, pair programming with other seniors to understand architecture and gotchas
2. Week 3-6: Ownership of medium-complexity features, participation in on-call rotations (with backup), first client meetings in observation mode
3. Week 7-12: Design and implementation of complete features, technical lead on a microservice, active participation in architecture decisions

After ramp-up, day-to-day looks like this:

• 40% development: you still code, regularly. We're not a company where seniors only make slides.
• 30% design and architecture: you lead technical discussions on new features, you write RFCs, you challenge proposed approaches
• 20% client interaction: spec meetings, demos, trade-off discussions, sometimes real-time troubleshooting during incidents
• 10% ops and continuous improvement: on-call rotation (1 week every 4-5 weeks), performance optimizations, technical debt refactoring, CI/CD improvements

Work environment

Flexible remote, occasional client presence

We operate remote-first in Tokyo. You can work from home most of the time. We have an office in Shibuya for in-person meetings when necessary, but it's not mandatory 5 days a week.

However, expect occasional travel to client sites—typically 1-2 times per month for workshops, planning sessions, or critical incidents that require being on-site. Japanese FinTech clients appreciate physical presence at key moments.

The team

The Tokyo team currently has 12 people: 8 engineers (mix of backend, DevOps, frontend), 2 technical product managers, 2 business/client management roles. All bilingual Japanese-English. Mixed backgrounds: Japanese who've worked abroad, foreigners settled in Japan long-term.

Team culture: pragmatic, direct, anti-useless-process. We do standups when they're useful, not as ritual. We document important decisions, we don't waste 3 hours in meetings for what can be solved in 20 minutes of pair programming. We challenge ideas, not people.

Permanent or freelance

We hire on permanent contract (正社員) or long-term freelance depending on your preference. Permanent offers classic stability + Japanese social benefits. Freelance offers more flexibility and typically a higher daily rate, but you manage your own structure.

In both cases, you're based in Tokyo with valid work visa (we don't sponsor visas for this position—you must already have the right to work in Japan).

What it means to work at a senior engineering services company

Abbeal isn't a classic body shop. We don't do staff augmentation. We don't send you solo to a client to fill a seat. We intervene as a team on structural projects, with end-to-end ownership.

Concretely, that means:

• You work with other Abbeal engineers, not alone embedded in a client team. We build together, we support each other.
• You have a say in technical choices. The client defines business objectives, we define how to achieve them technically. If a client wants a bad architecture, we challenge it.
• Project variety: missions typically last 6-18 months. You don't stay 5 years on the same legacy codebase. You see different FinTech domains, different scales, different challenges.
• No commercial bullshit: we don't ask you to pretend to bill 10 hours when you worked 6. We don't artificially inflate estimates. The client pays for value, not time.

The trade-off: you won't have startup equity, nor the prestige of working for a FAANG, nor the comfort of an internal product you optimize for years. But you'll have impact without politics, variety without instability, and technical challenge without bureaucracy.

How to apply (and how we evaluate)

No lengthy process. We value your time as much as ours.

1. First contact: send CV + GitHub/GitLab link (or equivalent showing code you've written). A short paragraph on why this position interests you. No need for a formal 2-page cover letter.
2. Technical screening (60 min): discussion about your backend experience, concrete cases you've solved, deep dive on a system you've built. We want to understand how you think, not test your memory of algorithms.
3. Practical exercise (take-home or pair programming): design of a backend API for a simplified FinTech use case. We look at your architecture choices, how you handle edge cases, how you test. No whiteboard coding bullshit.
4. Final meeting with the team: more informal discussion about culture, mutual expectations, logistical questions. If everyone's aligned, we make an offer.

Total timeline: 2-3 weeks end-to-end, depending on schedules. We don't drag things out for 2 months.

Conclusion: if this resonates

This position exists because we have concrete projects, clients who have real technical problems to solve, and need someone solid to address them. No bullshit, no false promises. Serious backend engineering, in a demanding FinTech context, with a team that knows what it's doing.

If you're in Tokyo, you want to build systems that matter without the usual corporate nonsense, and the described profile matches your experience, we should talk. Send us your profile through the Abbeal site, Careers Tokyo section, or contact the engineering team directly if you have specific technical questions before applying.