Java Backend Coding Technology

Executable business process specifications. Code that reads like a business process, because it is one. A framework-agnostic methodology for writing predictable, testable Java backend code optimized for human-AI collaboration.

Read the book free Books Work with us

Here’s what changes

Without JBCT

// Hidden failure modes, unclear control flow
public User findUser(String userId) throws NotFoundException {
    long id;
    try {
        id = Long.parseLong(userId);
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("Invalid user ID");
    }

    User user = repository.findById(id);
    if (user == null) {
        throw new NotFoundException("User not found: " + id);
    }

    return user;
    // Multiple failure modes hidden in throws
    // Caller must read docs to know what exceptions to catch
}

With JBCT

// Parse don't validate - invalid states unrepresentable
public record UserId(long value) {
    // Records can't hide the canonical constructor; userId() is the construction path

    public static Result<UserId> userId(String raw) {
        return Number.parseLong(raw)
                     .map(UserId::new);
    }
}

public interface FindUser {
    Promise<User> execute(UserId id);
}

// Usage
UserId.userId(userIdStr)
      .async()
      .flatMap(findUser::execute)
      // Parsing errors: Result<UserId>
      // Not found errors: Promise<User>
      // All failures typed, compiler enforces handling

Result: Parse-don’t-validate makes invalid states impossible. Typed errors eliminate hidden exceptions. Type signatures document failure modes.

One discipline, from design to deployment

• Design — Process-First Design. The unit of design is the process, not the entity. The methodology book: how the structure of a backend is derived from what the business does, not from a data model. The condensed edition is free — the whole argument in about 25 minutes.
• Code — Java Backend Coding Technology. The Java realization this site documents: typed failures, parse-don’t-validate, composition patterns, testing strategy, worked examples. The complete book is free to read online.
• Run — Pragmatica Aether. A distributed Java runtime, currently in pre-release development, where the same composition deploys unchanged — business logic stays free of infrastructure code.

Where to start

• Developers — read the book, then wire up the AI and CLI tooling.
• Engineering leaders — the management perspective: the business case for structural standardization.
• Teams adopting — work with us: assessment, training, architecture review, adoption sprints.

Why “Technology”?

A methodology tells you what good looks like; a technology makes it reproducible. JBCT ships with the pieces that make the discipline mechanical rather than aspirational: a CLI linter and Maven plugin that enforce the structural rules, AI skills and subagents that generate and review compliant code, and a book that derives every rule instead of decreeing it.