Feathers Chat: the reference app behind the FeathersJS guides

A sample app that is really documentation you can run

The About section says what this repository is in one sentence. It includes the server application from the official Feathers chat guide, as well as chat frontend examples for different frameworks.

That framing is the important one. Feathers Chat is not a chat product that happens to be open source. It is the artefact that the guide is built around, so a reader following the tutorial is reading about the code sitting in this repository, which removes the usual gap between documentation and reality.

The project is a FeathersJS chat application, written in TypeScript, MIT licensed, with the homepage at feathersjs.com. The default branch is `dove`, which matches the URL of the guide the README links to, and the branch naming follows the Feathers release train convention where the animal name tracks the framework version.

The repository layout confirms that this is a set of examples rather than one application. There is `feathers-chat-ts/` for the TypeScript API server, `public/` for the plain JavaScript frontend, `react-chat/` for the React example, and `quick-start/` for a further starting point. The root `package.json` is a workspace shell whose only script updates dependencies in the sub-projects, and there is a `.replit` file and a `replit.nix` file, so the whole thing can be run on Replit with a click, which the README links to with a badge.

The last push was on 2026-05-29 and there are no GitHub releases, which is consistent with a repository whose artefacts are examples rather than distributed packages.

The TypeScript API server and its SQLite migration

The API server lives in `feathers-chat-ts/`, and the README gives the whole startup sequence.

Install the dependencies:

cd feathers-chat-ts
npm install

Then compile the source and run the database migration, which the README explains will initialize an SQLite database in the `feathers-chat.sqlite` file:

npm run compile
npm run migrate

And start it:

npm start

or in development mode with `npm run dev`. The server is then reachable at `http://localhost:3030`, which the README names as the place to go to start chatting.

The migration step is the part worth pausing on, because it is a Feathers concept rather than a generic one. A Feathers service with a database backend needs its schema created before the service can be queried, and the migration command is how that happens here. The output is a single SQLite file named `feathers-chat.sqlite`, which means the whole application's state is one file you can copy, inspect with any SQLite client, or delete to start over.

The choice of SQLite for the sample is deliberate and instructive. A guide has to be runnable on a laptop with no external services, and a file-backed database needs no configuration, no credentials and no cleanup. The cost is that the same code against Postgres or MySQL would need a different connection configuration, and anything you learn about the schema from the SQLite file does not transfer directly.

Two frontends, and the client package that links them

There are two frontend examples, and they differ in how much of the Feathers client they expect you to have already understood.

The plain JavaScript frontend is in the `public/` folder, and the README says it is hosted statically by the API server. That means there is no separate build for it and no second process: the server serves the HTML, the JavaScript and the client at one origin, which is the simplest possible demonstration of a Feathers app and is the version most people should start with.

The React example lives in `react-chat/` and works differently. It depends on the generated client package tarball, built from the API project and installed locally from the filesystem rather than from a registry. The README lays out the two steps.

First, build and bundle the client from the API project:

cd feathers-chat-ts
npm install
npm run bundle:client

That creates `../public/feathers-chat-0.0.0.tgz` relative to `feathers-chat-ts`. Then install and run the React app:

cd ../react-chat
npm install
npm start

The React app is then opened at `http://localhost:3000`, and the README states that it connects to the API at `http://localhost:3030` via WebSockets.

That last sentence is the whole lesson of the React example. The Feathers client in the browser opens a WebSocket for real-time events and uses REST for regular calls, and the generated client package is what encodes the service names, the method names and the validation rules on the server. A React developer who has only used a REST library has to learn that the connection is bidirectional and that events flow the other way, and this example is set up to make that concrete.

The README also notes the operational detail that trips people up: you still need the API running in a separate terminal for the app to work, with WebSockets and REST at `http://localhost:3030`.

The Vue frontend is not written yet

Under the heading for the VueJS example, the README contains a single word: TBD.

That is worth reporting plainly rather than working around, because the repository's own description says it includes chat frontend examples for different frameworks, and only two exist. The plain JavaScript and React frontends are complete, and Vue is a placeholder.

The rest of the README is structured as a list of framework sections, with TypeScript, Plain JavaScript and React each carrying a working set of instructions, and Vue carrying nothing. So a Vue developer who lands on this repository expecting the same treatment gets a stub.

There is a reason to be careful about drawing conclusions from that. The default branch is `dove`, and the guide URL in the README points at the same branch, so the tutorial content and the repository content are versioned together. If the Vue example exists on another branch or in a later state of the same branch, this README would be the place it would be described, and it is not. Either way, the state of the Vue section as published is a stub, and anyone planning to use it should check the branch before planning around it.

The React example, by contrast, is the most complete section in the document, with numbered steps, a note about the tarball path, and a troubleshooting note about running the API separately.

Where Feathers Chat is the wrong tool

The first wrong-tool case is shipping it. This is a sample application with an unstated feature set, no authentication story in the README, and no GitHub releases, so there is no version to pin and no changelog to read. The `feathers-chat.sqlite` file is a single file with a single user's worth of state, and the guide that documents it is a tutorial rather than an operations manual.

The second is a React project that already has a client. The React example deliberately uses the generated client package, which means the code is coupled to the service names and methods of this particular API. A real application would generate its own client from its own services, so the value here is the pattern, not the code.

The third is a team that needs the two-process setup to be one process. The README is explicit that the React app needs the API running in a separate terminal, with the frontend on port 3000 and the API on 3030. That is fine for a tutorial and awkward for anything you intend to deploy, and the deployment story is not in this repository.

The fourth is a project that needs a Vue reference implementation, which is exactly what is missing.

The alternative worth naming is the Feathers CLI generator, since the README links to the generator guide in the first place. The difference in approach is that the generator produces a fresh project with your own service names, your own database and your own configuration, whereas this repository gives you a working application whose internals are already decided. For learning, running the reference is the faster route because you can see the finished shape. For a real project, generating is the correct starting point, and this repository is best read as the worked example of what that generator produces.

Maintenance, the Replit path and the licence

The last push to the default branch was on 2026-05-29, and the repository is not archived. The recent releases list is empty, with the README noting explicitly that the repository has no GitHub releases. For a set of examples that is the normal arrangement, since there is nothing to release, the code is the artefact.

The `.replit` and `replit.nix` files at the top level are the most interesting piece of infrastructure. Together with the Replit badge in the README, they mean the whole application can be started in a browser tab on someone else's infrastructure, with no local Node setup and no local database. For a tutorial that removes the last friction point, since the only remaining step is opening a URL.

The root `package.json` is worth a second look, because it reveals the maintenance workflow. The single script, `update-dependencies`, changes into each of `feathers-chat-ts`, `quick-start` and `react-chat` in turn and runs `npm-check-updates -u` in each. So keeping the example projects on current dependency versions is a scripted, repeatable operation rather than a manual chore, and the three sub-projects are updated in one command.

The licence is MIT, with a `LICENSE` file in the tree. For a sample application that is the most permissive and least contentious choice available, since the interesting parts are the patterns rather than the code, and a reader can lift any part of it into their own project without attribution obligations beyond keeping the notice. This is a description of the published terms and not legal advice.

The homepage is feathersjs.com, the guide is at dove.feathersjs.com, and the CI workflow badge in the README points at a GitHub Actions run for the repository, so the examples are tested in continuous integration even though they are not released.

Editorial conclusion

Adopt Feathers Chat when you are learning Feathers by example, because the server here is the one the official guide walks through, so the code on screen matches the documentation line for line, and the plain JavaScript frontend in `public/` gives you a working client with no framework in the way. Do not adopt it as a chat product, because it is a sample with an unstated feature set, a Vue frontend marked TBD, and no GitHub releases. Before you build on it, read the generator guide linked from the README, check the `feathers-chat-ts` directory for the current script names since the root package manifest only carries a dependency update task, and remember that the React example needs the API server running in a second terminal.

Frequently asked questions

Official sources

1. feathersjs/feathers-chat on GitHub
2. Issues
3. License: MIT
4. Project website
5. README