How to Write Japanese Business Emails: Etiquette, Keigo & Phrases for Engineers in Japan (2026)

Are you an engineer working in—or planning to break into—the Japanese tech scene? Do you feel like Japanese “Keigo” (honorifics) is a legacy codebase riddled with undebuggable bugs?

Maybe you’ve experienced these runtime errors:

• “I memorized the static tables in the textbook, but I can’t deploy them during a meeting (Runtime).”
• “The verb changes so drastically depending on the listener’s rank that I’m hitting a Stack Overflow.”

Your frustration likely stems from treating Keigo as a “memorization task.” In reality, navigating Japanese corporate culture feels like maintaining a massive legacy system where Keigo functions as a fundamental law of physics designed to reduce the “coefficient of friction” within the human network.

Failing to implement this protocol is like throwing unhandled “Exceptions” into your social code—it creates unnecessary noise that stalls project progress and system-wide deployment.

As someone who used to analyze On-Board Diagnostics (OBD) logic for automotive systems, I realized Keigo isn’t a list of words—it’s a State Machine.

In this article, we’ll refactor Keigo into a logical algorithm, defining the ultimate “Keigo cheat sheet” for the engineering mind.

If you’re also wondering how to write Japanese business emails that won’t get silently ignored—this article covers that too.

Why Japanese Business Emails and Keigo Feel Like Legacy Code

The “Keigo module” crashes because it relies on heavy look-up tables rather than efficient, real-time logic. To fix the latency, we must move from static data to dynamic execution.

The Problem with Static Tables: Why 2D “Keigo cheat sheets” fail in production (Runtime)

Most textbook “Keigo tables” are essentially massive Static Tables. However, real-life conversation is Dynamic. 

In OBD logic, fault detection must happen in milliseconds. Similarly, if you’re scanning a mental lookup table for “the respect form of this verb” during a conversation, your latency will be too high, and the communication will Timeout.

From Rote Memorization to Logic: Why Keigo should be viewed as an algorithm for “Japanese honorifics.

That “coefficient of friction” exists precisely because Keigo is treated as static data rather than dynamic logic. Keigo is not about memorization; it’s a logic gated by “Relative Pointers” (the positional relationship between you and the subject).

• 尊敬語-Sonkeigo (Respectful): A wrapper for the other person’s methods to increment their status.
• 謙譲語-Kenjougo (Humble): Lowering your own instance to relatively elevate the other person.
• 丁寧語-Teineigo (Polite): The common communication protocol (Standard Library).

Once you grasp this architecture, you can dynamically generate the correct honorific even for verbs you’ve never encountered before.

How to Write Japanese Business Emails: Keigo as a State Machine

A State Machine is defined by its states and the inputs that trigger transitions. In Japanese, the “State” is determined by the pointer’s position in the social hierarchy.

Mapping the Social Hierarchy as States: Defining states (Respect, Humble, Polite) via “Self, Other, and Third-party” pointers. 

%%{init:{'flowchart':{'nodeSpacing':40,'rankSpacing':60}}}%%
flowchart TD
    START["🎯 Input: Verb<br/>（動詞を入力）"] --> EVAL{"Who is the Subject?<br/>（主語は誰？）"}

    EVAL -->|"Superior / Client<br/>（上司・クライアント）"| SON["尊敬語 Sonkeigo<br/>Respectful Form"]
    EVAL -->|"Self / Internal Team<br/>（自分・社内）"| KEN["謙譲語 Kenjougo<br/>Humble Form"]
    EVAL -->|"Neutral / Default<br/>（中立・デフォルト）"| TEI["丁寧語 Teineigo<br/>Polite Form"]

    SON --> SON_R["お + stem + になる<br/>Regular Pattern"]
    SON --> SON_S["Special Form:<br/>いらっしゃる etc."]
    KEN --> KEN_R["お + stem + する<br/>Regular Pattern"]
    KEN --> KEN_S["Special Form:<br/>参る, 申す etc."]
    TEI --> TEI_R["verb + ます / です<br/>Standard Polite"]

    SON_R --> OUT["✅ Output<br/>Correct Keigo"]
    SON_S --> OUT
    KEN_R --> OUT
    KEN_S --> OUT
    TEI_R --> OUT
    TEI --> SAFE["🛡️ FAIL-SAFE<br/>Lost? Always fall<br/>back here"]

    style SON fill:#fef3c7,stroke:#d97706,color:#92400e
    style KEN fill:#f3e8ff,stroke:#7c3aed,color:#4c1d95
    style TEI fill:#d1fae5,stroke:#059669,color:#064e3b
    style SAFE fill:#d1fae5,stroke:#059669,color:#064e3b
    style OUT fill:#e0f2fe,stroke:#0284c7,color:#0c4a6e

Operating Keigo begins with identifying the current State.

• State: Respect (尊敬): When the target is a “Superior or Client.”
• State: Humble (謙譲): When the subject is “Self or Internal Team,” and the action is directed toward a “Superior.”
• State: Polite (丁寧): The default state to maintain a standard connection, regardless of context.

The Core Variable: Defining the “stem” variable in the Keigo algorithm. 

Before generating Keigo, we must define the common variable: the “stem.” For engineers, think of this as String Manipulation. 

Technical Note: The “stem” here refers to the base string of a verb’s “masu-form” after stripping the “masu” suffix. In code: verb.replace(“masu”, “”).

Input & Output Examples:

• Read: 読みます (yomimasu) → yomi (読み)
• Write: 書きます (kakimasu) → kaki (書き)

Transition Rules for Standard Methods: Logic for dynamic verb conversion.

flowchart TD
    INPUT["📥 Input Verb<br/>e.g. 書きます (kakimasu)"] --> STRIP["✂️ Strip 'masu'<br/>→ stem: 書き (kaki)"]
    
    STRIP --> CHECK{"Target State?"}
    CHECK -->|Sonkeigo<br/>尊敬語| SON["お + stem + になる<br/>→ お書きになる"]
    CHECK -->|Kenjougo<br/>謙譲語| KEN["お + stem + する<br/>→ お書きする"]
    CHECK -->|Teineigo<br/>丁寧語| TEI["stem + ます<br/>→ 書きます (as-is)"]
    SON --> SPECIAL{"Special Override<br/>Exists?"}
    KEN --> SPECIAL2{"Special Override<br/>Exists?"}
    SPECIAL -->|Yes| SOUT["Use irregular form<br/>e.g. 見る → ご覧になる"]
    SPECIAL -->|No| ROUT["Use template output"]
    SPECIAL2 -->|Yes| KOUT["Use irregular form<br/>e.g. 行く → 参る"]
    SPECIAL2 -->|No| KROUT["Use template output"]
    style INPUT fill:#e0f2fe,stroke:#0284c7
    style SON fill:#fef3c7,stroke:#d97706
    style KEN fill:#f3e8ff,stroke:#7c3aed
    style TEI fill:#d1fae5,stroke:#059669

Pass your stem variable into these common templates (much like a Regex or Template Literal):

• Standard Sonkeigo: お + [stem] + になる（o + [stem] + ni naru）
  • 例: 書く (kaku) → お書きになる（O-kaki-ni-naru）
• Standard Kenjougo: お + [stem] + する（o + [stem] + suru）
  • 例: 貸す (kasu) → お貸しする（O-kashi-suru）

Error Handling in Real-time: A “Fall-back” strategy for when you lose track of the State. 

In engineering, we use “Fail-safes” to return a system to a safe state during an anomaly. 

If you’re mid-sentence and can’t resolve whether to use Respectful or Humble, Fall back to 丁寧語-Teineigo (〜です、〜ます). Polite Japanese is a “universal protocol” that never throws an error. It prevents a total system crash.

Just as you need a fail-safe for verbal communication, you also need a “parser” for your development environment. In many JTCs, the terminal output—from Git conflicts to compiler errors—may be localized in Japanese. Treat these not as incomprehensible bugs, but as legacy log files that require a specific decoder.

→ Decode the terminal: Japanese Error Messages in Terminal: Decoding Legacy JTC Bash Output

Terminal logs are only half the battle. When refactoring JTC systems, you will inevitably encounter “Static Comments” — Japanese notes embedded directly in the source code. These comments often contain the “Internal Logic” or “Technical Debt” warnings that never made it into the official specs. Decoding these is essential for a safe system migration.

→ Decipher the source code: Reading Japanese Source Code Comments: A Glossary for Translating Legacy JTC Code

How to Write Japanese Business Emails: Format, Phrases & the Protocol Stack

Knowing how to write Japanese business emails is less about memorization and more about implementing the correct protocol stack.

In the Japanese corporate world, emails are standardized communication protocols. Following the boilerplate isn’t just polite; it’s about minimizing handshake latency.

Japanese Business Email Opening & Closing Phrases: The SYN-FIN Structure

sequenceDiagram
    participant You as 👨‍💻 You (Sender)
    participant Recv as 👨‍💼 Recipient
    Note over You,Recv: === TCP 3-Way Handshake ===
    You->>Recv: 🔹 SYN: [会社名] [名前]様
    You->>Recv: 🔹 SYN: お世話になっております
    Note right of Recv: Connection Established ✅
    Note over You,Recv: === Payload (Main Content) ===
    You->>Recv: 📦 Request / Report / Information
    Note over You,Recv: === Connection Close ===
    You->>Recv: 🔹 FIN: ご確認のほどよろしくお願いいたします
    You->>Recv: 🔹 FIN: [署名]
    Note over You,Recv: ✅ Session Complete

This boilerplate isn’t just politeness; it’s a mandatory TCP 3-way handshake. Just as a network connection requires a SYN-ACK sequence to verify readiness, Japanese business emails must establish a session before the payload (main content) is delivered.

Standardizing Japanese email etiquette into a communication protocol allows you to trigger these phrases like pre-defined methods, minimizing latency in human processing. Skipping this “Otsukaresama” header causes a protocol mismatch, often resulting in communication timeouts or the recipient’s “firewall” dropping your packets.

• Header: [相手の社名] [名前] 様、お世話になっております。[自分の社名] の [名前] です。
• Footer: よろしくお願いいたします。 

Japanese Business Communication Etiquette in Async: Slack, Teams & Git

Even in async comms, respect the stack. Instead of a command like “Check this” (Request), send a Non-blocking Request like “I would be happy if you could check this.” This respects the other person’s Thread and avoids blocking their workflow.

This “Non-blocking” etiquette also applies to your version control. In a JTC environment, your Git commit messages are asynchronous “status packets” seen by the whole team. Using the correct format—essentially a standardized header for your code payload—is a high-efficiency way to practice Horenso without extra meetings.

→ Refactor your commit logs : Japanese Git Commit Message Format: A Cheat Sheet for Expat JTC Developers

→ Use ChatGPT to check your Keigo : DeepL vs ChatGPT for Japanese: Fix Business Emails Like an Engineer (2026)

Resolving Dependencies: The Logic of ”Nemawashi” and ”Consensus culture”

In Japanese corporate culture, “Nemawashi” is Dependency Resolution—a pre-launch Pull Request (PR) performed before the main process.

To understand why this is necessary, you must understand the Ringi System, which functions as a Distributed Consensus Algorithm.

The Ringi process is a multi-step approval requiring agreement across all stakeholder nodes. A proposal doesn’t just need a “Merge” from your boss; it needs a cryptographic-like consensus from Finance, Legal, and other Module Leads.

Nemawashi is the process of resolving these dependencies individually so that the final “meeting” (the Execution phase) is merely a formality that returns a 200 OK status.

View the Japanese company hierarchy as a System Architecture:

• CEO = Root Privileges
• Managers = Module Leads
• You = Implementation Dev.

Higher nodes in the hierarchy require stricter Encapsulation (Humble language). This is exactly where that “coefficient of friction” from the introduction becomes concrete: if your “PR” isn’t formatted with the correct Keigo headers, the Ringi node will return a “403 Forbidden,” stalling your project deployment indefinitely.

→ Complete guide to Nemawashi and the Ringi approval protocol : What is the Ringi System & Process? Guide for Engineers in Japan

Japanese Business Email Phrases Decoded: What 承知・検討・よろしく Really Return

Technical terms in a Japanese office often carry specific “Return Values.” Treat these terms as variables to be injected into your honorific engine.

Implementing Japanese Business Etiquette & Email Etiquette for Developers

While lists of Japanese technical vocabulary exist elsewhere, the key is how you implement them into your honorific engine. We treat these terms as variables to be injected into the Respectful or Humble methods.

When turning technical terms into Keigo, treat the “action” part as the variable. 

Implementing (実装します：Jissou-shimasu):

• 【Standard】実装します（Jissou-shimasu）
• 【Respect】実装なさいますか？（Jissou-nasaimasu ka?）
• 【Humble】私が実装いたします。（Watakushi ga jissou-itashimasu.）

Common Business Phrases for Devs: Decoding the “Return Value.”

• “承知いたしました（Shochi-itashimashita）” → Return: SUCCESS (200 OK) (Task accepted)
• “検討します（Kento-shimasu）” → Return: PENDING (Logic required/404) (Cannot say Yes right now)

Keigo Cheat Sheet: Run This Before You Send

Now that you understand the states, use this as your daily runtime reference. Run this logic gate before every “Commit” (Speak/Send) to ensure compatibility with the environment.

How to Use This Flowchart at Work: Run the logic before you commit.

%%{init:{'flowchart':{'nodeSpacing':30,'rankSpacing':50}}}%%
flowchart TD
    Q1{"❓ Who is the subject?<br/>（主語は誰？）"}

    Q1 -->|"Me / My Team<br/>（自分・自チーム）"| HUMBLE["🙇 Humble: Kenjougo<br/>お + stem + します<br/>o + {stem} + shimasu"]
    Q1 -->|"Other / Client<br/>（相手・クライアント）"| RESPECT["🎩 Respect: Sonkeigo<br/>お + stem + になります<br/>o + {stem} + ni narimasu"]

    HUMBLE --> Q2{"📋 Is it a formal<br/>situation?"}
    RESPECT --> Q2

    Q2 -->|"Yes → Formal"| EXEC["✅ Execute the<br/>template above!<br/>（テンプレート実行）"]
    Q2 -->|"No / Unknown"| FALLBACK["🛡️ Fall back to Polite<br/>〜です / 〜ます<br/>~desu / masu"]

    EXEC --> GO["🚀 Execute!<br/>Speak / Send"]
    FALLBACK --> GO

    style Q1 fill:#fef3c7,stroke:#d97706,color:#92400e
    style HUMBLE fill:#f3e8ff,stroke:#7c3aed,color:#4c1d95
    style RESPECT fill:#fef3c7,stroke:#d97706,color:#92400e
    style Q2 fill:#dbeafe,stroke:#2563eb,color:#1e3a5f
    style EXEC fill:#d1fae5,stroke:#059669,color:#064e3b
    style FALLBACK fill:#d1fae5,stroke:#059669,color:#064e3b
    style GO fill:#d1fae5,stroke:#059669,color:#064e3b

If you keep this logic flow Resident in Memory, you’ll be able to ship code (and conversation) in the complex Japanese runtime environment without any fatal errors.

Conclusion

This is more than just a Keigo cheat sheet; it’s a framework for hacking Japanese business etiquette. By refactoring your approach, you can master Japanese honorifics and thrive within any Japanese corporate culture.

If you want to move beyond the theory of state machines and master the practical runtime of IT Keigo for the workplace, this guide is your next deployment.

→ Find your language mentor : Best Online Japanese Tutors for Devs

Next Steps: Level Up Your Navigation

This article is a sub-module of Layer 4. To master the complete business etiquette protocol or explore the entire career blueprint, choose your next destination:

🔼 Back to Layer 4: Structural Japanese & Business Etiquette (Return to the module overview: Keigo, Email Protocols, and Office Life)

🏠 Return to The Engineer’s Blueprint: Decoding Japanese Workplace Culture (Access the Master Manual including Genba Communication, Tech Specs, and Career Strategy)