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.
| Category | Purpose | Example projects |
|---|---|---|
| Core libraries | Shared APIs and dependency support | Fabric API, Fabric Language Kotlin, Fabric Permissions API, Placeholder API |
| Building and decoration | Expand creative options while retaining survival play | Macaw's building collections |
| Navigation | Help players understand and traverse a large persistent world | BlueMap, JourneyMap, Waystones |
| Social systems | Improve communication and server identity | Simple Voice Chat, Styled Chat, Dynamic Join Greetings |
| Administration | Support permissions, investigations, and moderation | LuckPerms, Ledger, BanHammer, InvView, Vanish |
| Performance | Reduce memory use and diagnose or prevent lag | Lithium, FerriteCore, Spark, ScalableLux |
| Quality of life | Refine common survival interactions | Graves, multiplayer sleep, teleport utilities, selected Vanilla Tweaks |
Release lifecycle
- 01Identify a player or administrative need.
- 02Research compatible projects and alternatives.
- 03Review version requirements, dependencies, licenses, and client/server scope.
- 04Test the candidate outside the production server when practical.
- 05Create a recovery point before changing production.
- 06Deploy during a communicated maintenance window.
- 07Validate startup logs, commands, performance, and representative gameplay.
- 08Update the client pack and its version.
- 09Publish release notes, installation guidance, and member announcements.
- 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.
| Layer | Purpose | StoneHavenSMP examples |
|---|---|---|
| Admission | Reduce preventable risk before server access | Discord application, verification, allowlist |
| Authorization | Give each role only the access it needs | LuckPerms, Fabric permissions, command restrictions |
| Expectation | Make acceptable behavior understandable | Published rules, onboarding guides, staff procedures |
| Detection | Establish what actually happened | Ledger block, container, and interaction logging |
| Response | Give staff controlled incident tools | BanHammer, InvView, Vanish, staff workflows |
| Recovery | Repair harm without discarding unrelated work | Ledger 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.
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
A first-arrival greeting delivered by Dynamic Join Greetings on StoneHavenSMP.

Returning join
A returning-player welcome that distinguishes established members from first-time joins.
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.
Work still in progress
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 pageSteward
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
01
Production compatibility matters more than isolated success.
A component can be correct by itself and still fail in a larger software stack.
02
Backups are only part of recovery.
Administrators also need known restore points, a clear rollback decision, and confidence in the recovery process.
03
Permissions should be designed deliberately.
Operator access is convenient but should not replace role-based authorization.
04
Documentation is part of deployment.
Members need to understand installation, updates, downtime, and changed behavior.
05
Community policy can be reinforced technically.
Configuration and datapacks can apply a rule consistently and transparently.
06
Administrative tooling is part of the user experience.
Quiet, reliable systems let players focus on the world rather than its infrastructure.
07
Using the system creates better feedback.
Playing on the server exposes usability and balance issues that logs cannot show.
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.
