How we actually build

The challenge

The client needed a CRM that could replace three separate tools — a pipeline tracker, an email tool, and a reporting dashboard — into one coherent product. It had to support multiple users with role-based access, integrate with Brevo for transactional email and Airtable for data sync, and generate AI email drafts that actually sounded human.

What we built

Full-stack platform on ASP.NET Core 10 with C# 14 Clean Architecture — domain layer fully decoupled from infrastructure. React 19 frontend with TypeScript and TanStack Query for optimistic updates. Redis for session caching and rate limiting. PostgreSQL as the primary store with EF Core migrations. OpenAI integration for email drafting with custom prompt engineering tuned to the client's tone and industry.

Stack

The challenge

Build a platform that could handle multiple independent organizations (full tenant isolation), schedule posts across 4+ platforms with different APIs and rate limits, and offer AI content generation that fits each brand's voice. Billing had to support both Stripe and PayPal with annual/monthly switching.

What we built

Spring Boot 3 / Java 21 backend with a multi-tenant PostgreSQL schema (schema-per-tenant isolation). Next.js frontend with TypeScript for the dashboard. OpenAI and Anthropic models used in parallel — Anthropic for long-form content, OpenAI for short social copy. Redis queues for post scheduling with retry logic. Stripe + PayPal billing with webhook-driven subscription state. Embeddable AI support widget built as an isolated JS bundle.

Stack

The challenge

The plugin ecosystem had grown to the point where in-game actions needed to trigger web dashboard updates in real time. Multiple game servers needed to talk to the same backend without stepping on each other. Auth had to be secure enough for paying customers, not just a JWT with no refresh logic.

What we built

Spring Boot backend with a clean service layer. RabbitMQ as the event bus between game servers and the web layer — each server publishes events, the backend fans them out to connected dashboard clients via WebSockets. JWT + OTP two-factor auth with refresh token rotation. PayPal webhook integration for subscription management. Full OpenAPI spec generated at runtime.

Stack

The challenge

Community servers need moderation that doesn't fall apart under load. Staff were jumping between Discord and in-game consoles to handle incidents. The bot had to be modular (enable features per server), persistent across restarts, and fast enough that slash command responses felt instant.

What we built

Go bot using DiscordGo with a module system — each feature (moderation, tickets, RCON, roles) registers itself as a command group. RCON client built in Go talking directly to Minecraft server processes. SQLite for single-server installs, MySQL for multi-server deployments. Commands respond in under 100ms cold.

Stack

The challenge

Most server owners run 6+ plugins to cover basic commands. Every plugin update is a potential conflict. Config sprawl makes onboarding new staff painful. We wanted to ship one plugin that covered the whole operator surface with a single config file and a zero-conflict design.

What we built

Paper-ready Java plugin with a command framework built on top of Brigadier. Each feature is a module that can be toggled in config — operators who don't need economy can disable it without losing anything else. YAML config with hot-reload. Cross-server sync via Redis pub/sub for networks running BungeeCord or Velocity.

Stack

The challenge

Server owners wanted NPCs that felt alive — animated models, branching conversations, quest triggers — without writing Java themselves. Existing solutions either required heavy manual setup or didn't support custom 3D models. Integration with MythicMobs was critical for the mob health and AI layer.

What we built

Plugin that wraps ModelEngine for model rendering and MythicMobs for AI behavior, adding a dialogue system (branching conversations defined in YAML), quest trigger hooks, and ray-trace click detection for interaction. Developer API exposed for teams building on top of the system. Config-driven NPC creation with no coding required for standard use cases.

Stack

The challenge

Build a fully playable, polished match-3 game without using a framework — purely Java and Swing. The game loop, input handling, animation timing, combo logic, and scoring all had to be written from first principles. Performance had to hold up on low-spec hardware.

What we built

Custom game loop with fixed-timestep updates and variable rendering. Swing-based renderer with double-buffering to eliminate flicker. Grid-based match detection with BFS cascade for chain combos. Score multiplier system that rewards long chains. Animated tile swap and destruction with timed state transitions. All game state serializable for save/load.

Stack

The challenge

Growing networks outgrow single-server setups fast. Routing players to the right game mode, handling server crashes gracefully, deploying updates without taking the whole network down — none of this is solved by default Minecraft tooling.

What we built

Velocity proxy layer with custom plugin for routing rules and fallback logic. Pterodactyl for containerized server management with automated restart policies. Health check endpoints on each node polled by the proxy. Deployment pipeline that rolls new server jars across nodes one at a time with automatic fallback if the new jar crashes on startup.

Stack

The challenge

Four separate products were each building their own auth and data sync logic, leading to duplicated code, inconsistent security, and painful maintenance. A unified API layer was the only way to scale the product suite without the overhead multiplying.

What we built

Spring Boot API with shared token auth (per-product API keys with scoped permissions). Rate limiter backed by Redis with per-key counters and sliding window. Versioned endpoints so products can migrate independently. Webhook delivery system for async event propagation between products. Full OpenAPI documentation generated from annotations.

Stack

The challenge

Staff were managing servers through the Pterodactyl console — not designed for player-facing ops work. They needed player lookups, kick/ban actions, and live server state without needing admin-level access to the full hosting panel.

What we built

Web dashboard consuming OreoAPI for player data and server state. WebSocket stream for live console output with filtering by severity. Role-based access — moderators see player controls, admins see console and config. Action audit log for every staff action with timestamp and actor. Mobile-responsive for on-call staff.

Stack

The challenge

Most anti-cheat plugins fire on the main thread and flood staff with low-confidence alerts — leading to false bans and staff burnout. We needed detection that was fast enough to run async, confident enough to reduce noise, and transparent enough that staff could explain every action taken.

What we built

Async movement and combat analysis running on a dedicated thread pool — zero main thread impact. Confidence scoring per check type, with alerts only firing above a configurable threshold. Evidence packet: when an alert fires, staff see exactly what triggered it (movement delta, CPS, reach data). Flagging system with cool-down to avoid alert spam for the same player.

Stack