Skip to content
Moeijiro

About

I build the systems between services, and the products on top.

I'm Moeijiro, a Python and full-stack developer. I work on the parts of software that connect things (FastAPI backends, API integrations, webhooks, Discord bots) and on the web apps people use to run them.

My public work includes 17 open-source projects. Each one is built end-to-end with a backend, a web interface, automated tests, CI, documentation and local runnable demos.

I'm open to freelance projects and full-time roles.

Focus

What I work on

  • Python backends

    FastAPI services with typed models, authentication, roles, background work and a test suite.

  • Automation

    Webhook-triggered workflows, schedulers, monitors and alerts that record what happened and why.

  • Discord systems

    discord.py bots, OAuth2 dashboards, moderation and community tooling with real permission checks.

  • API integrations

    Moving data between services with mapping, retries, signing and a readable log of every failure.

  • Full-stack products

    Next.js and React front ends on top of those backends: dashboards, portals, consumer apps.

  • How this translates into services →

How I build

The unglamorous parts, done on purpose

They show up across the repositories as code you can read, not as slogans.

  1. 01Failures are data

    A timeout is recorded as a timeout, not as a change or a silent no-op. Runs, checks and automations keep the reason they failed. ScoutFlow · DataBridge

  2. 02Secrets stay on the server

    OAuth tokens and credentials are encrypted at rest; API keys and refresh tokens are stored as digests. Discord Automation Platform · StudyRaid

  3. 03Outbound requests are guarded

    Services that fetch URLs for users check resolved addresses and every redirect hop against private ranges. ScoutFlow · NexaFlow

  4. 04Retries only when they help

    Timeouts, 429 and 5xx back off and retry; a 4xx is an answer and is never retried. DataBridge · Webhook Automation Hub

  5. 05Totals come from history

    Counters that matter are derived from append-only records, so they can't drift from what happened. StudyRaid

  6. 06Demos run the real code

    Seed data is produced by the same services as production, and tests drive real apps in-process. StudyRaid · NexusGuard

Real code · DataBridge

Retry with exponential backoff, but only where a retry can change the outcome. An unsafe URL is never retried; a 4xx is returned as the answer.

backend/app/connectors/http.py · L147–169View on GitHub ↗
def retryable_status(status: int) -> bool:
    return status == 429 or status >= 500


async def send_with_retries(method: str, url: str, **kwargs: Any) -> tuple[HttpResponse | None, int, str | None]:
    """(response, attempts, error). ``response`` is None when no HTTP answer ever came back."""
    attempts = settings.retry_attempts
    error: str | None = None
    for attempt in range(1, attempts + 1):
        try:
            response = await request(method, url, **kwargs)
        except UnsafeURL:
            raise
        except RequestFailed as exc:
            error = str(exc)
            if not exc.retryable or attempt == attempts:
                return None, attempt, error
        else:
            if not retryable_status(response.status) or attempt == attempts:
                return response, attempt, None
            error = f"HTTP {response.status}"
        await asyncio.sleep(settings.retry_base_delay_seconds * (2 ** (attempt - 1)))
    return None, attempts, error

The shape most of my projects share

DiscordWebhooksWeb appPython backendFastAPI · PydanticAsync workersschedulers · retriesDatabaseDiscord · TelegramExternal APIs
  • Discord → Python backend
  • Webhooks → Python backend
  • Web app → Python backend
  • Python backend → Async workers
  • Python backend → Database
  • Async workers → Discord · Telegram
  • Async workers → External APIs

Hover or tap a node to see what it does and which projects implement it.

Stack

Counted from the code

How many of the 17 repositories use each technology, taken from their dependency files. Nothing is listed that isn't in the code.

Backend

  • Python17/17
  • FastAPI17/17
  • Pydantic v217/17
  • SQLAlchemy 217/17
  • httpx · asyncio17/17
  • pytest17/17
  • Alembic1/17

Discord & integrations

  • discord.py6/17
  • Discord OAuth2 & REST2/17
  • Telegram Bot API4/17
  • Webhooks & HMAC signing
  • OpenAI-compatible API1/17
  • BeautifulSoup1/17
  • WebSockets1/17

Security

  • JWT sessions12/17
  • cryptography (Fernet, AES-GCM)7/17
  • scrypt / bcrypt / argon2 passwords10/17
  • API-key hashing4/17
  • SSRF protection5/17

Frontend

  • TypeScript17/17
  • React 1917/17
  • Tailwind CSS v417/17
  • Next.js 1614/17
  • Motion13/17
  • shadcn/ui10/17
  • Recharts1/17
  • Vite3/17

Data & tooling

  • SQLite17/17
  • PostgreSQL1/17
  • Docker1/17
  • GitHub Actions CI17/17
  • Make17/17

How I work

Four habits you'll find in the code

  1. 01

    The README is a design document.

    Each repository explains its architecture, security choices and known trade-offs, not just how to install it.

  2. 02

    Tests drive the real code.

    Suites call the actual app in-process instead of mocking everything; demo data comes from the same services.

  3. 03

    Scope is explicit.

    Each repository documents its architecture, concrete boundaries and known trade-offs upfront.

Have a project in mind?

I build APIs, automation systems, Discord integrations and full-stack applications. Tell me what it should do and I'll tell you how I'd build it.