Deploying Scoold

Introduction

Scoold is an open-source Q&A platform that provides Stack Overflow-style functionality for teams and communities. Built on top of Para (a backend server), Scoold offers a familiar question-and-answer experience with voting, tagging, reputation systems, and more.

Perfect for internal knowledge bases, customer support forums, or developer communities, Scoold provides the collaborative knowledge-sharing features you need without the complexity of larger enterprise solutions.

Key highlights of Scoold:

Q&A Format: Questions, answers, and comments
Voting System: Upvote/downvote content
Reputation System: Gamified user engagement
Tags and Categories: Organize content effectively
Full-Text Search: Find answers quickly
Markdown Support: Rich text formatting
LDAP/SAML/OAuth: Enterprise authentication
Moderation Tools: Flag, close, and merge questions
Slack Integration: Notifications and search
Spaces: Separate communities within one instance
REST API: Programmatic access
Customizable: Themes and branding

This guide walks through deploying Scoold on Klutch.sh using Docker, configuring the Q&A platform, and building your knowledge base.

Why Deploy Scoold on Klutch.sh

Deploying Scoold on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh builds your Scoold configuration automatically.

Persistent Storage: Attach volumes for Para database and uploads.

HTTPS by Default: Secure access with automatic SSL.

GitHub Integration: Version control your configuration.

Scalable Resources: Handle growing communities.

Always-On Access: 24/7 availability for knowledge sharing.

Prerequisites

Before deploying Scoold on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository
Basic familiarity with Docker
Para backend (or plan to deploy one)
(Optional) OAuth credentials for authentication
(Optional) A custom domain

Deploying Scoold on Klutch.sh

Create Your Repository

Create a new GitHub repository for your deployment. Add a Dockerfile:

FROM eclipse-temurin:17-jre

WORKDIR /app

RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

RUN curl -L https://github.com/Erudika/scoold/releases/latest/download/scoold.jar -o scoold.jar

COPY application.conf /app/

ENV JAVA_OPTS="-Xmx512m"
ENV SERVER_PORT=8080

EXPOSE 8080

HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/ || exit 1

CMD ["java", "-jar", "scoold.jar"]

Create Configuration

Add application.conf:

para.endpoint = "https://para-api.example.com"
para.access_key = "app:scoold"
para.secret_key = ${PARA_SECRET_KEY}

scoold.host_url = "https://scoold.example.com"
scoold.app_name = "My Q&A Community"

scoold.admins = "admin@example.com"

Push to GitHub

Commit and push your files.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project.

Create a New App

Connect your GitHub repository.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 8080

Set Environment Variables

Configure settings:

Variable	Value
`PARA_SECRET_KEY`	Your Para secret key
`PARA_ENDPOINT`	Para API URL
`SCOOLD_HOST_URL`	Your Scoold URL

Attach Persistent Volumes

Add volumes if using embedded Para:

Mount Path	Recommended Size	Purpose
`/app/data`	10 GB	Para data (if embedded)

Deploy Your Application

Click Deploy to build.

Access Scoold

Navigate to your deployment URL and sign in.

Para Backend

Understanding Para

Scoold requires Para as its backend:

Para handles data storage
Provides search functionality
Manages authentication
Can be embedded or separate

Embedded Para

Simple deployment with embedded backend:

para.standalone = true
para.dao = "H2DAO"

External Para

For production deployments:

Deploy Para separately
Configure connection in Scoold
Use robust database (PostgreSQL, MongoDB)

Initial Configuration

Admin Setup

Configure administrator access:

Set admin emails in config
First matching user gets admin
Add additional admins via settings

Basic Settings

Configure community basics:

scoold.app_name = "Developer Community"
scoold.welcome_message = "Welcome to our Q&A!"
scoold.max_tags_per_post = 5
scoold.min_title_length = 10

Authentication

Password Authentication

Simple email/password login:

scoold.password_auth_enabled = true

OAuth Providers

Configure social login:

# Google
para.google_app_id = "your-client-id"
para.google_secret = ${GOOGLE_SECRET}

# GitHub
para.github_app_id = "your-client-id"
para.github_secret = ${GITHUB_SECRET}

LDAP Integration

Enterprise directory authentication:

para.ldap.server_url = "ldap://ldap.example.com"
para.ldap.base_dn = "dc=example,dc=com"
para.ldap.user_dn_pattern = "uid={0},ou=users"

SAML/SSO

Single sign-on configuration:

para.security.saml.idp.metadata_url = "https://idp.example.com/metadata"
para.security.saml.sp.entityid = "scoold"

Content Management

Questions

Users can ask questions:

Title and description
Tag assignment
Markdown formatting
File attachments (Pro)

Answers

Respond to questions:

Multiple answers per question
Accept best answer
Vote on quality
Comment on answers

Spaces

Creating Spaces

Separate communities:

scoold.spaces_enabled = true

Create new space
Assign moderators
Customize settings
Invite members

Space Configuration

Per-space settings:

Access control
Moderation rules
Custom branding
Separate content

Reputation System

Earning Reputation

Users gain points:

Action	Points
Question upvoted	+10
Answer upvoted	+10
Answer accepted	+15
Question downvoted	-2

Privileges

Reputation unlocks features:

Reputation	Privilege
50	Comment everywhere
100	Vote on questions
200	Edit posts
500	Close questions

Moderation

Moderator Tools

Manage content quality:

Close questions
Merge duplicates
Protect questions
Delete spam

Flagging System

Community moderation:

Users flag inappropriate content
Flags reviewed by moderators
Action taken on valid flags

Approved Answers

Official responses:

Mark answers as approved
Display approval badge
Filter by approved answers

Customization

Theming

Customize appearance:

scoold.dark_mode_enabled = true
scoold.logo_url = "https://example.com/logo.png"
scoold.footer_html = "<p>Custom footer</p>"

Custom CSS

Add styling:

scoold.inline_css = """
  .navbar { background: #your-color; }
"""

Email Templates

Customize notifications:

Welcome emails
Answer notifications
Digest emails

Integrations

Slack Integration

Connect to Slack:

scoold.slack.app_id = "your-app-id"
scoold.slack.signing_secret = ${SLACK_SECRET}

Features:

Search from Slack
Post to channels
Notifications

Webhooks

Event notifications:

scoold.webhooks.enabled = true
scoold.webhooks.url = "https://your-endpoint.com/webhook"

API Access

REST API

Programmatic access via Para:

curl -H "Authorization: Bearer TOKEN" \
  https://para-api.example.com/v1/questions

Search API

Full-text search:

GET /v1/questions?q=search+term

Troubleshooting

Para Connection Issues

Verify Para endpoint
Check credentials
Review network connectivity
Test Para directly

Authentication Problems

Verify OAuth credentials
Check callback URLs
Review LDAP settings
Test with password auth

Search Not Working

Verify Para search config
Rebuild search index
Check for indexing errors

Best Practices

Community Building

Seed with quality content
Recognize contributors
Respond quickly
Establish guidelines

Content Quality

Close duplicates
Edit for clarity
Maintain tags
Curate top answers

Additional Resources

Conclusion

Deploying Scoold on Klutch.sh provides a powerful Q&A platform for your team or community. With Stack Overflow-style features, flexible authentication, and extensive customization options, Scoold enables effective knowledge sharing. Combined with Klutch.sh’s reliable hosting, you get an always-available platform for building and accessing your collective knowledge base.