> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Tutorials
> Ruby and Rails tutorials on installing AppSignal, Solid Queue, background jobs, debugging, strong parameters, authentication, and recent Rails features.
These tutorials were originally produced by [GoRails](https://gorails.com/) with new content that has been authored specifically for AppSignal customers.
Watch the videos, read the written walkthroughs, or hand these pages over to your agent.
The [guides](/guides) explain how to use AppSignal. For a Rails application, start with [AppSignal for Ruby](/ruby) and its [Rails integration](/ruby/integrations/rails). These tutorials explain the Ruby and Rails tools that produce the data AppSignal monitors.
Meet Chris Oliver
GoRails is the content library Chris Oliver has been publishing since 2014.
Alongside GoRails, Chris builds [Jumpstart Pro](https://jumpstartrails.com), a Rails SaaS template, and [Hatchbox](https://hatchbox.io), a deployment platform that has run more than two million deploys since 2016. He co-hosts the Remote Ruby podcast.
His open source work sits in the dependency tree of a lot of Rails applications. [`noticed`](https://github.com/excid3/noticed) handles notifications, [`madmin`](https://github.com/excid3/madmin) admin interfaces, and [`receipts`](https://github.com/excid3/receipts) invoicing, among [the rest of his repositories](https://github.com/excid3).
That combination is what makes the material here worth republishing. The lessons come from someone who runs Rails applications in production, hits the problem first, and then explains it.
AppSignal Expert Context Store
AppSignal offers Intelligence features that are grounded on a context store of at least four signal sources.
| Source | What it contributes |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Your telemetry | [Metrics](/metrics/dashboards), [logs](/logging), and [traces](/performance-tracing) from your applications and the services they call, [host and infrastructure metrics](/metrics/host-metrics), and [how end users experience it all](/browser-monitoring). What is happening in your stack, right now. |
| Our documentation | Validated AppSignal reference and best practices. |
| Expert knowledge | How these application and service frameworks work, from practitioners with acknowledged expert experience, surfaced in tutorials like these. |
| Your organization's knowledge base | Your inventory of applications and infrastructure, and the [ownership](/ruby/integrations/ownership) and [team structure](/organization/team/teams) mapped onto it. [Logbook](/anomaly-detection) notes on incidents, and the [Jira](/application/integrations/jira), [GitHub](/application/integrations/github), and [Linear](/application/integrations/linear) tickets they turn into. Who owns what, and what has already been decided about it. |
The Intelligence features
* **[Intelligence dashboards](/metrics/magic-dashboards).** Dashboards build themselves from the integrations AppSignal detects, so a new Solid Queue or Sidekiq install arrives with the charts that matter for it already laid out.
* **[Time Detective](/trace-page).** Reconstructs what your application looked like at the moment of a trace, so a slow request can be read against the state it actually ran in.
* **[AppSignal MCP](/mcp-server) and the [CLI](/cli).** Put an agent in front of all of it, in your editor or your terminal, so you can ask questions of your own data in your own words.
The premise is the same across all of them: AppSignal enriches and interprets your telemetry rather than only storing it.
These tutorials as expert context
Expert knowledge is the one signal AppSignal cannot produce on its own. Documentation and telemetry are ours to write, and your knowledge base accumulates as your team works.
Expert knowledge does not. Knowing how Solid Queue behaves under load, or which of `step` and `next` you want at a breakpoint, does not fall out of having instrumented the framework. It comes from people who have run these tools in production and spent years explaining them to other developers. Getting that into a context store means working with them.
So these tutorials are made with GoRails. What is documented here is what Chris and his team teach, published under the same URLs, in the same corpus, as everything else AppSignal's Intelligence features read.
One page serves both audiences:
* **People.** A video, then a written walkthrough with the commands and code in order.
* **Agents.** Every page is served as plain Markdown at its URL with a `.md` extension, and listed in [`llms.txt`](https://docs.appsignal.com/llms.txt). AppSignal's own Intelligence agents read it, and so does any agent you build and point at these docs yourself.
The tutorials
Install AppSignal in Rails and inspect data from a deployed application.
Run Active Job on your existing database, with no Redis.
Mount a job dashboard inside your own application.
Run jobs in parallel and act once they have all finished.
Breakpoints, stepping, and walking the stack from the console.
Permit and require parameters in one step with Rails 8.
Supply fallback values for parameters the browser may omit.
Add user impersonation to the Rails 8 authentication generator.
Run your CI suite locally and sign off on GitHub pull requests.
Respond with `text/markdown` using the Rails 8.1 MIME type.