SwornHero

Minecraft Server Operations Case Study

StoneHavenSMP

Building and operating the primary survival server within the StoneHaven community.

StoneHavenSMP, the primary survival server within the broader StoneHaven community, is a long-term, community-driven Vanilla+ Minecraft server built on Fabric. As its owner and administrator, I manage the complete environment—from hosting, modpack releases, permissions, backups, and moderation systems to community onboarding, documentation, and custom mod development.

Prefer the software side? Explore my mods.

Aerial view of an inhabited StoneHavenSMP settlement with castle walls, farmland, rivers, and roads

At a glance

Project summary

Full infrastructure breakdown
Role
Owner, server administrator, modpack curator, community manager, and mod developer
Platform
Minecraft Java Edition, Fabric, Java 25
Server model
Allowlisted, long-term Vanilla+ survival SMP
Community
StoneHaven
Primary focus
World continuity, community trust, safe change, and approachable player experience
Status
Live and actively maintained

Community architecture

One community, more than one world

Community architecture

StoneHaven is the community: the Discord server, shared identity, documentation, support structure, and relationships that connect its members. StoneHavenSMP is the community's primary survival server and the focus of this case study. IndustryHaven exists separately as an experimental Create-focused environment, but both servers operate beneath the broader StoneHaven identity.

StoneHavenSMP is community-driven and inspired by the collaborative nature of Hermitcraft. It is Vanilla+ rather than heavily transformative, built around long-term projects and world continuity. The server is allowlisted to support a smaller, trust-based community. Activity and playstyle stay flexible, while collaboration, creativity, and a persistent shared history remain the center of gravity.

Running StoneHavenSMP is not simply a matter of starting a Minecraft server. It means maintaining a persistent shared world, evolving a modded software stack without carelessly risking player work, designing fair administrative controls, supporting less-technical players, managing a community, and developing new software when existing tools do not solve the right problem.

The challenge

The server was easy to start. The world was harder to sustain.

The challenge

The real project is maintaining confidence in a shared world. The core tension is continuous improvement without making the world feel unstable, unrecognizable, or hard to return to.

Those constraints shape every major decision:

  • Preserve familiar survival Minecraft while adding meaningful quality-of-life features.
  • Protect long-term builds and player progress.
  • Introduce new mods without destabilizing the complete production stack.
  • Keep installation and updates manageable for members with different levels of technical confidence.
  • Provide staff with necessary investigative and moderation tools without granting excessive access.
  • Communicate downtime and changes clearly.
  • Operate with a small staff structure and reasonable administrative overhead.
  • Remain an active player rather than experiencing the server only through a console.

Stability, fairness, and player confidence are the outcomes being protected—not novelty for its own sake.

Responsibilities

Owning the full operating lifecycle

Scope of responsibility

My role covers the full loop from hosting decisions to player-facing documentation and public software releases. Hosting providers supply hardware and network resilience; I own how that capacity is configured, changed, and explained to the community.

Infrastructure and runtime

  • Hosting-plan selection and resource allocation
  • Server startup configuration
  • Fabric Loader, Fabric API, Minecraft, and Java upgrades
  • Console and log review
  • Performance monitoring and troubleshooting
  • Backup and restore decisions
  • Maintenance windows and rollback planning

Modpack and configuration

  • Mod and datapack evaluation
  • Dependency and compatibility review
  • Server/client requirement analysis
  • Configuration management
  • Versioning and release notes
  • Modrinth-based client distribution
  • Player-facing update and migration instructions

Security and administration

  • Allowlist and application workflows
  • Permission groups and command access
  • Logging and investigation
  • Staff tooling
  • Rule enforcement and incident response
  • Recovery from griefing or configuration mistakes

Community and support

  • Discord structure
  • Member onboarding
  • Announcements and maintenance communication
  • Guides and troubleshooting documentation
  • Support for client crashes and mod mismatches
  • Staff communication and expectations
  • Community feedback and feature decisions

Development

  • Custom server-side Fabric mods
  • Datapacks and policy-enforcement changes
  • Testing and production validation
  • GitHub repository maintenance
  • Version tags, changelogs, releases, licensing, and attribution
  • Public Modrinth publishing

Infrastructure

A production environment for a persistent world

Infrastructure and operations

StoneHavenSMP runs on premium Minecraft hosting with 12 GB of memory, NVMe storage, and access to an AMD Ryzen 9 9900X hosting platform. That CPU description means allocated capacity on high-performance hardware—not exclusive ownership of the entire processor. Fabric and Java 25 power the server software. The configured view and simulation distances are both 10, with a configured player limit of 20. Published infrastructure notes also report an average TPS of 20; treat that as a point-in-time measurement from the public infrastructure page, not a permanent guarantee.

Each of those choices matters to gameplay:

  • Strong single-thread performance supports Minecraft's primary server tick loop.
  • Memory allocation provides room for loaded chunks, players, entities, mods, and supporting processes.
  • NVMe storage helps with chunk access, world saves, startup, and backup operations.
  • Provider DDoS mitigation improves network resilience, but it is not the same as application security or permission design.
  • Performance depends on CPU time, chunk generation, entities, redstone, farms, mods, and configuration—not RAM alone.

Day-to-day operations focus on scheduled maintenance, pre-change backups, startup-log validation, TPS and MSPT monitoring, Spark profiling when diagnosing lag, controlled configuration changes, rollback decisions, and clear member communication before and after maintenance. Hosting includes daily backups with hourly incremental backups. That host capability is useful, but it is not the same as a personally verified restore drill or a full off-site archive model.

Modpack curation

Treating the modpack like a maintained product

Modpack curation and release

The modpack is curated, versioned, and explained—not treated as an ever-growing pile of interesting jars. Selection favors building, communication, navigation, performance, moderation, and quality-of-life improvements while preserving the recognizable feel and progression of survival Minecraft.

Unnecessary mechanical bloat is avoided. I prefer projects with active maintenance and compatible dependency requirements, and I evaluate whether a mod is server-side, client-side, or required on both. Migration behavior matters before changing an established world. So does the experience of less-technical players, not only administrators.

Representative modpack categories and example projects
CategoryPurposeExample projects
Core librariesShared APIs and dependency supportFabric API, Fabric Language Kotlin, Fabric Permissions API, Placeholder API
Building and decorationExpand creative options while retaining survival playMacaw's building collections
NavigationHelp players understand and traverse a large persistent worldBlueMap, JourneyMap, Waystones
Social systemsImprove communication and server identitySimple Voice Chat, Styled Chat, Dynamic Join Greetings
AdministrationSupport permissions, investigations, and moderationLuckPerms, Ledger, BanHammer, InvView, Vanish
PerformanceReduce memory use and diagnose or prevent lagLithium, FerriteCore, Spark, ScalableLux
Quality of lifeRefine common survival interactionsGraves, multiplayer sleep, teleport utilities, selected Vanilla Tweaks

Release lifecycle

  1. 01Identify a player or administrative need.
  2. 02Research compatible projects and alternatives.
  3. 03Review version requirements, dependencies, licenses, and client/server scope.
  4. 04Test the candidate outside the production server when practical.
  5. 05Create a recovery point before changing production.
  6. 06Deploy during a communicated maintenance window.
  7. 07Validate startup logs, commands, performance, and representative gameplay.
  8. 08Update the client pack and its version.
  9. 09Publish release notes, installation guidance, and member announcements.
  10. 10Roll back or patch the change if validation fails.

Client distribution moved from manually shared .mrpack downloads to a Modrinth Share Link. That change improved onboarding and update management, but it also required documenting how existing players migrate without creating duplicate instances or losing personal configuration. The complete inventory lives on the public server site rather than in this case study.

Access control

Trust supported by technical safeguards

Layered protection and permissions

Safeguards are not a statement of distrust toward every player. They protect months of shared work and give staff a fair, evidence-based way to respond when something goes wrong.

Layered protection model used on StoneHavenSMP
LayerPurposeStoneHavenSMP examples
AdmissionReduce preventable risk before server accessDiscord application, verification, allowlist
AuthorizationGive each role only the access it needsLuckPerms, Fabric permissions, command restrictions
ExpectationMake acceptable behavior understandablePublished rules, onboarding guides, staff procedures
DetectionEstablish what actually happenedLedger block, container, and interaction logging
ResponseGive staff controlled incident toolsBanHammer, InvView, Vanish, staff workflows
RecoveryRepair harm without discarding unrelated workLedger rollback, world backups, configuration recovery

Authorization currently uses four permission groups, not four staff roles: Owner, Dev, Staff, Member. Member is the standard player group. Role inheritance, least-privilege thinking, and separation of player and administrative commands keep access intentional. Prefixes and TAB/chat formatting make group visibility consistent. I also test commands from the perspective of an ordinary member, and as owner I may deliberately avoid bypassing gameplay restrictions that apply to everyone else.

Policy can also be enforced by configuration. Waystones provide valuable long-distance travel, but unrestricted crafting would undermine the intended permit and placement model. A datapack disables the crafting recipe for everyone, including the owner. The technical configuration therefore reinforces a public server policy consistently and transparently.

Software development

When the right tool did not exist, I started building it

Developing for a real community

The server provides real problems, real users, and a production environment. Those constraints turn small quality-of-life ideas into software projects that must be configurable, recoverable, compatible, documented, and safe to release.

OriginalDeployed

Dynamic Join Greetings

StoneHavenSMP needed more personal join messages than one static greeting. First-time players and established members should receive different messages, and the result should feel varied without requiring a client-side mod.

The implementation separates first-time and returning-player message pools, persists UUID-based player history, imports existing player data on established servers, and supports weighted random, no-repeat, and shuffle-bag selection. Selection history can be per-player or server-wide. Messages use multi-line Simplified Text Format with safe {player} and {server} placeholders, live reload with validation and safe fallback, and status, preview, and simulation commands. Automated tests cover selection, placeholders, and history behavior; packaged JARs are also exercised in a production-style Fabric server before community deployment.

The important production lesson was compatibility. The first implementation used Adventure Platform and MiniMessage. It worked in clean development and production-style test environments. On the full StoneHavenSMP stack, another mod expected a different Adventure API generation. Greeting logic and player history still worked, but message delivery failed at the rendering and packet boundary. Dynamic Join Greetings was refactored to produce native Minecraft text components through Placeholder API, preserving formatting while removing the conflicting runtime dependency.

A clean test environment proves that a mod can run. A real server proves that it can coexist.
First-time join greeting welcoming a player to StoneHavenSMP

First-time join

A first-arrival greeting delivered by Dynamic Join Greetings on StoneHavenSMP.

Returning join greeting welcoming SwornHero back to StoneHaven

Returning join

A returning-player welcome that distinguishes established members from first-time joins.

Maintained fork

Trowel Continued

Trowel Continued is an unofficial maintained fork of the original Trowel mod by TheEnderCore. My work focuses on preserving its familiar randomized block-placement behavior while updating it for modern Minecraft, Fabric, and Java versions.

That means understanding and modernizing an existing codebase, updating mappings, APIs, dependencies, and build configuration, preserving original expected behavior, keeping Survival block consumption correct, and supporting both singleplayer and dedicated-server use with client-and-server dependency requirements. Releases are tested in real building workflows. Licensing, credits, NOTICE documentation, and responsible attribution stay part of the maintenance work alongside GitHub tags, Modrinth publishing, and ongoing compatibility updates.

This case study does not claim Trowel Continued is currently installed on StoneHavenSMP. It is public software maintained for builders and for future stack decisions.

Research and development

Work still in progress

In Development

Wayfinder Posts

A Fabric navigation project exploring readable, in-world directional signage for paths and settlements. Not represented here as a deployed StoneHavenSMP dependency.

View project page
Planned

Steward

Planned staff-administration tooling. Documented only as a planned direction, not as production software.

Player perspective

The administrator is also a player

Operating and playing in the same world

Playing on StoneHavenSMP keeps administration grounded in the player experience. I do not only see the server through logs and configuration files—I experience the consequences of those decisions in the same world as everyone else.

Active play supports:

  • First-hand testing of modpack changes
  • Discovering friction in ordinary survival workflows
  • Testing permissions without relying only on operator access
  • Understanding how policies affect actual building and collaboration
  • Evaluating whether quality-of-life additions remain balanced
  • Seeing performance problems in their gameplay context
  • Receiving informal feedback during normal play
  • Balancing personal projects with maintenance and support interruptions

That overlap connects the identities of owner, builder, redstoner, administrator, and developing programmer. Each role checks the others.

Community systems

The server extends beyond Minecraft

Community administration and documentation

StoneHaven's Discord and documentation are part of the operating environment. Applications, verification, and allowlisting; Discord role and category structure; staff communication; maintenance announcements; rules; support channels; step-by-step client installation guides; modpack update and migration guides; Distant Horizons troubleshooting; Member Chronicles; and coordinating StoneHavenSMP with IndustryHaven all sit outside the Minecraft process and still decide whether a change succeeds for players.

Communication is part of change management. A technically correct update can still fail players if installation, migration, downtime, or behavior changes are unclear. This case study intentionally omits private staff discussions, application details, member personal information, internal addresses, and other sensitive operational data.

Production notes

What production taught me

Incident and process case notes

These notes are concise records of real production pressure—not invented war stories. Each follows the same structure so the lesson stays visible.

Dynamic Join Greetings rendering conflict

Symptom
Automatic greetings, previews, and simulations produced no visible chat messages on StoneHavenSMP even though status commands and player history behaved correctly.
Investigation
Logs showed packet and rendering failures at the Adventure message boundary. Native Minecraft messages still worked. A different mod on the full stack expected another Adventure API generation.
Root cause
Dynamic Join Greetings bundled a newer Adventure Platform runtime that conflicted with another installed mod's message API expectations.
Resolution
Removed Adventure Platform delivery and switched to native Minecraft text components through Placeholder API, then revalidated joins, previews, and simulations on the full production stack.
Preventive lesson
A clean test environment proves that a mod can run. A real server proves that it can coexist.

Fabric Loader and Fabric API dependency mismatch

Symptom
A server deployment failed during startup after introducing a new mod.
Investigation
Startup logs identified the exact Loader and Fabric API versions required by the candidate mod and the older versions installed in production.
Root cause
The mod's dependency declarations exceeded the production runtime. A successful local build did not mean the live server satisfied those requirements.
Resolution
Chose deliberately between removing the mod and upgrading the Loader/API environment during a planned maintenance window, then revalidated startup before reopening the world.
Preventive lesson
Dependency declarations are part of deployment planning, and a successful local build does not guarantee the production runtime satisfies them.

Client distribution migration to Modrinth Share Links

Symptom
Manually distributed .mrpack files made first-time installs and routine updates harder to explain, especially for less-technical members.
Investigation
Reviewed how players created instances, updated packs, and preserved personal settings. The distribution method itself was creating support load.
Root cause
The pack was treated as a file handoff rather than a maintained product with a clear update path.
Resolution
Moved distribution to a Modrinth Share Link and published migration guidance so existing players could update without creating duplicate instances or losing local preferences.
Preventive lesson
Distribution and documentation are part of release engineering. A better packaging path still fails if migration is left to tribal knowledge.

Outcomes

What the systems make possible

Outcomes

The useful outcomes are mostly qualitative, and that is intentional. Vanity metrics that cannot be verified or kept current do not belong here.

  • A persistent world that players can treat as long-term work
  • Safer, more controlled administrative access
  • Evidence-based incident investigation
  • More recoverable configuration and world changes
  • Easier client onboarding and modpack updates
  • Clearer maintenance communication
  • Server needs converted into reusable public software, including Dynamic Join Greetings
  • A feedback loop between administration, active play, and development

Lessons

Lessons that extend beyond Minecraft

  1. 01

    Production compatibility matters more than isolated success.

    A component can be correct by itself and still fail in a larger software stack.

  2. 02

    Backups are only part of recovery.

    Administrators also need known restore points, a clear rollback decision, and confidence in the recovery process.

  3. 03

    Permissions should be designed deliberately.

    Operator access is convenient but should not replace role-based authorization.

  4. 04

    Documentation is part of deployment.

    Members need to understand installation, updates, downtime, and changed behavior.

  5. 05

    Community policy can be reinforced technically.

    Configuration and datapacks can apply a rule consistently and transparently.

  6. 06

    Administrative tooling is part of the user experience.

    Quiet, reliable systems let players focus on the world rather than its infrastructure.

  7. 07

    Using the system creates better feedback.

    Playing on the server exposes usability and balance issues that logs cannot show.

  8. 08

    Public releases require product discipline.

    Versioning, testing, documentation, licenses, attribution, release artifacts, and support all matter.

Looking ahead

Continuing the work

Next steps

Future work may include continued Minecraft and Fabric version maintenance; further development of Wayfinder Posts; continued maintenance of Dynamic Join Greetings and Trowel Continued; Steward or other staff tooling if that direction stays active; expanded mod documentation; stronger performance baselines and monitoring history; more formal pre-production compatibility testing; improved backup verification and recovery documentation; and continued refinement of the Modrinth distribution process.

None of those items are dated commitments. They are directions, not promises.

Closing

A world people trust enough to keep building in

StoneHavenSMP began as a place to play Minecraft with other people, but operating it has become a practical education in systems administration, release management, access control, troubleshooting, documentation, community leadership, and software development. Every improvement still returns to the same goal: create a world people trust enough to keep building in.