How to Use the SignBoard Plugin on a Minecraft Server

Overview

Running a Minecraft server often means giving players quick access to rules, commands, tips, links, or other useful details. A giant wall of signs works, technically, but nobody joins a server hoping to read a wooden novel.

SignBoard is a Spigot plugin that solves this by attaching scoreboard popups to signs or living entities. When a player looks at the sign or interacts with the entity, the information appears on their screen in a cleaner format. You can also attach commands to boards, which makes SignBoard useful for server hubs, tutorials, shops, NPC areas, and help stations.

This guide explains how to install SignBoard, create boards, edit their lines, attach commands, use entities, adjust configuration files, and fix the most common problems.

Downloading SignBoard

1. Open the SignBoard page on Spigot.
2. Click Download Now on the right side of the page.

1. Save the plugin `.jar` file somewhere easy to find, such as your desktop or downloads folder.

Installing the Plugin

SignBoard requires a plugin-compatible server type, such as Spigot or Paper. It will not run on a Vanilla server, and it is not meant for Forge or Fabric modded setups unless your server software specifically supports Bukkit-style plugins.

1. Open your server panel and go to the file manager or FTP client.

1. Log in with your panel or FTP password if prompted.

1. Open the `plugins` folder.
2. Upload the SignBoard `.jar` file and wait for the upload to finish.

1. Return to the main server page and restart the server.

After the restart, SignBoard should create its plugin folder and configuration files automatically.

First Steps In-Game

Most SignBoard setup is handled through in-game commands. To use these commands, your account needs operator access or the correct permission nodes from a permissions plugin such as LuckPerms.

SignBoard can be configured in two main ways:

• Create and edit boards with commands in-game.
• Edit board data directly in the plugin files.

The command method is usually faster for normal setup. The file method is useful when you want to review the exact saved text or make several changes at once.

Creating a Board on a Sign

Place a sign anywhere on your server. The text written directly on the sign can be anything, because the SignBoard popup is controlled separately.

Run this command in chat:

`/sb board new [name]`

Replace `[name]` with a board name you will remember. For example:

`/sb board new rules`

New boards usually include default lines. To attach the board to the sign, look directly at the sign and run:

`/sb sign attach [name]`

Players can now look at that sign to view the scoreboard popup. If you are making many boards, the default starting lines may get annoying. Those can be changed in the plugin's locale files, covered later in this guide.

Editing Board Lines

A SignBoard board can use lines 1 through 16. The line numbering starts at the bottom of the scoreboard and moves upward. The numbers shown on the right side of the board help identify which line you are editing.

Use this command format:

`/sb board [name] lineX [text]`

Replace `X` with the line number. For example:

`/sb board rules line1 &aWelcome to the server`

You can use Minecraft color codes in the board text. If you want a blank line, run the line command without adding text after the line number.

After editing, look at the sign again and attach the board once more:

`/sb sign attach [name]`

This saves the latest version of the board to the sign. It is a small step, but skipping it is a great way to wonder where your work went after a restart.

Adding Commands to a SignBoard

SignBoard can also run commands when players interact with a board. Commands may be executed by the player or by the server console, depending on how you configure them.

Look at the sign and use this format:

`/sb sign [interaction] [command]`

Available interaction types include:

• `before`
• `after`
• `onclick`
• `onrightclick`
• `onshiftclick`
• `onattack`
• `onkill`

The `before` and `after` options run a command before or after the board appears. Options such as `onrightclick` run when a player performs that action on the sign. The `onattack` and `onkill` options are more useful for entity-based boards.

To run a command as console, prefix it with `_rfc_`. For example:

`/sb sign onrightclick _rfc_ gamemode survival {PName}`

In that example, `{PName}` represents the player who right-clicked the sign. This lets the command target the correct user instead of affecting everyone or nobody, both of which are usually bad options.

Using Entities Instead of Signs

SignBoard can attach boards to living entities too. The command structure is similar, but you use `entity` instead of `sign`.

For example, look at the entity and run:

`/sb entity attach [name]`

This attaches the selected board to that entity. Any command interactions should also be configured with entity commands rather than sign commands.

Entity boards are useful for NPCs in spawn areas, quest hubs, shops, tutorials, or any location where a sign would feel awkward. For persistent NPCs, you may want a plugin such as Citizens. Regular passive mobs can work too, although they are less professional unless your server's brand is "wandering cow with instructions."

Useful Commands and Permissions

SignBoard has a larger command set than most servers need on day one. For full command details, review the plugin's official Spigot page. The most common workflow is:

1. Create a board with `/sb board new [name]`.
2. Edit lines with `/sb board [name] lineX [text]`.
3. Attach the board with `/sb sign attach [name]` or `/sb entity attach [name]`.
4. Add optional interaction commands with `/sb sign [interaction] [command]` or the entity equivalent.
5. Reload changes with `/sb reload` when needed.

If non-operator players need access to SignBoard features, assign the proper permission nodes with a permissions plugin such as LuckPerms. Avoid giving broad operator access just so someone can edit signs. That is convenient for about five minutes, then painful later.

Editing the Configuration Files

You can also customize boards from the SignBoard files. This is especially helpful after a board has already been created in-game, because you can open the saved file and adjust the exact text.

1. Open your server file manager or FTP client and log in.
2. Go to this folder:

`/plugins/SignBoard`

1. Find `boards.yml` and open it with the file editor.

1. Make your changes, then save the file.

1. Restart the server, or run `/sb reload` in-game if the plugin accepts the change without a full restart.

Be careful with spacing in YAML files. Incorrect indentation can stop the file from loading properly.

Other SignBoard Files

The SignBoard folder contains more than just `boards.yml`. Most files can be left alone unless you have a specific reason to edit them.

The `config.yml` file controls general plugin behavior. One useful option is `view_distance`, which affects how close a player must be before a sign board activates. Other settings may control messages shown to operators or console output.

The `Locale` folder contains language and message files. These are useful if you want to change plugin prompts or adjust the default board template. The `defaultBoardLineX` values control the starting lines used when new boards are created, so editing them can save time if you are building several similar boards.

Common Problems

The plugin does not load

Confirm that the server is running Spigot, Paper, or another compatible plugin server type. Then check that the SignBoard `.jar` file is inside the `/plugins` folder. Restart the server after uploading the file.

If it still does not load, make sure you installed it on the correct server profile or instance. Uploading the plugin to the wrong profile is easy to miss.

Commands do not work

Your account needs operator access or the correct permission nodes. You can temporarily run `op [username]` from the console for testing, or use LuckPerms for a cleaner long-term setup.

Also check the command syntax. SignBoard commands often require a board name, line number, interaction type, or target. One missing argument can make the command fail.

Board changes disappear after restart

After editing a board in-game, attach it again with one of these commands:

`/sb sign attach [name]`

`/sb entity attach [name]`

Attaching applies the current board data to the sign or entity and helps ensure the changes are saved into `boards.yml`.

Helpful References

• SignBoard on Spigot
• How to become a Minecraft server operator
• Installing and using LuckPerms
• Minecraft color code guide