Deploying Genea.app

Introduction

Genea.app is a privacy-first, open-source tool for building and editing family trees online. Unlike traditional genealogy software, Genea.app is completely serverless - all processing happens in your browser, giving you complete control over where to save your data and avoiding vendor lock-in.

Built as a modern web application, Genea.app provides a visual interface for creating family trees while using the standard GEDCOM format for data storage. This means your genealogy data can be exchanged with other genealogy services like MyHeritage, FamilySearch, or Ancestry.

Key highlights of Genea.app:

• Privacy by Design: All processing happens in your browser - no data sent to servers
• GEDCOM Standard: Data formatted following GEDCOM specifications for compatibility
• Git Integration: Connect to GitHub, GitLab, Gitea, or self-hosted repositories
• Cross-Platform: Works on mobile devices and desktop browsers
• Visual Tree Builder: Intuitive interface for building family trees
• No Vendor Lock-in: Your data stays in your control
• Import/Export: Import from other genealogy services via GEDCOM
• Open Source: Transparent, community-driven development

This guide walks through deploying Genea.app on Klutch.sh using Docker, configuring the application, and connecting it to your data storage.

Why Deploy Genea.app on Klutch.sh

Deploying Genea.app on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically builds and deploys your Genea.app instance. Push to GitHub, and your genealogy tool is available.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, ensuring secure access to your family tree builder.

GitHub Integration: Connect your deployment repository directly from GitHub for automatic updates.

Custom Domains: Assign a custom domain for a family-branded genealogy portal.

Always-On Availability: Your genealogy tool remains accessible 24/7 from any device.

Complete Control: Self-hosting gives you full control over the application version and configuration.

Family Sharing: Provide a consistent URL for family members to access the tool.

Prerequisites

Before deploying Genea.app on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your Genea.app configuration
• Basic familiarity with Docker and containerization concepts
• (Optional) A GEDCOM file from existing genealogy software
• (Optional) A Git repository for storing your genealogy data
• (Optional) A custom domain for your Genea.app instance

Understanding Genea.app Architecture

Genea.app has a unique architecture that prioritizes privacy:

Client-Side Processing: All genealogy data processing happens in the browser. The server only delivers the application files - no user data is ever transmitted.

Static Web Application: The application is a static web app that can be served by any web server.

GEDCOM Storage: Family tree data is stored in GEDCOM format, either locally or in a Git repository.

Git Integration: Optional integration with Git services allows version-controlled storage of genealogy data.

No Database Required: Since all processing is client-side, no database is needed.

Preparing Your Repository

To deploy Genea.app on Klutch.sh, create a GitHub repository containing your Dockerfile.

Repository Structure

genea-app-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM node:18-alpine AS builder

WORKDIR /app

# Clone the repository
RUN apk add --no-cache git && \
    git clone https://github.com/genea-app/genea-app.git .

# Install dependencies and build
RUN npm ci && npm run build

# Production stage
FROM nginx:alpine

# Copy built application
COPY --from=builder /app/dist /usr/share/nginx/html

# Copy nginx configuration
RUN echo 'server { \
    listen 80; \
    location / { \
        root /usr/share/nginx/html; \
        index index.html; \
        try_files $uri $uri/ /index.html; \
    } \
}' > /etc/nginx/conf.d/default.conf

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Creating the .dockerignore File

Create a .dockerignore file:

.git
.github
*.md
README.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local
node_modules

Deploying Genea.app on Klutch.sh

Once your repository is prepared, follow these steps to deploy Genea.app:

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Genea.app deployment configuration"
git remote add origin https://github.com/yourusername/genea-app-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “genea-app” or “family-tree”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Genea.app Dockerfile.

Configure HTTP Traffic

Genea.app serves its web interface over HTTP. In the deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 80 (nginx’s default port)

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will:

• Detect your Dockerfile automatically
• Build the container image
• Start the Genea.app container
• Provision an HTTPS certificate

Access Genea.app

Once deployment completes, access your Genea.app instance at https://your-app-name.klutch.sh. You’ll see the Genea.app interface ready to create or load a family tree.

Using Genea.app

Starting a New Family Tree

To create a new family tree from scratch:

1. Click New Tree on the main screen
2. Start by adding yourself or a family member
3. Add parents, children, and spouses
4. Save your progress locally or to Git

Importing Existing Data

To import from other genealogy software:

1. Export a GEDCOM file from your existing software
2. In Genea.app, click Open File
3. Select your GEDCOM file
4. Your family tree will be loaded and displayed

Connecting to Git

For version-controlled storage:

1. Click the Git option in the menu
2. Choose your Git provider:
   • GitHub
   • GitLab
   • Gitea
   • Self-hosted Git
3. Authorize access
4. Select or create a repository
5. Your changes will be saved to Git automatically

Editing Family Members

To edit a person’s details:

1. Click on the person in the tree view
2. Edit their information:
   • Name
   • Birth date and place
   • Death date and place
   • Other events
3. Changes are reflected immediately

Adding Relationships

To add family relationships:

1. Select a person in the tree
2. Choose to add:
   • Parent
   • Child
   • Spouse
3. Fill in the new person’s details
4. The relationship is automatically created

Data Storage Options

Local Storage

For personal use:

• Data stored in browser localStorage
• No internet required after initial load
• Data persists between sessions
• Limited to single device

Git Repository Storage

For collaboration and backup:

Provider	Features
GitHub	Public or private repos, wide accessibility
GitLab	Self-hosted option available
Gitea	Lightweight self-hosted option
GitBucket	Java-based self-hosted

File Download

Manual backup option:

1. Click Save or Download
2. A GEDCOM file is generated
3. Save to your computer
4. Import into any GEDCOM-compatible software

GEDCOM Compatibility

Supported Data

Genea.app supports standard GEDCOM data:

• Individual records (names, dates, places)
• Family relationships
• Events (birth, death, marriage, etc.)
• Notes and sources
• Media references

Import Sources

Import from popular services:

• Ancestry
• FamilySearch
• MyHeritage
• Gramps
• Legacy Family Tree
• Other GEDCOM-compatible software

Export Destinations

Export to any GEDCOM-compatible service:

• Same services as import
• Personal archives
• Sharing with family

Privacy Considerations

Client-Side Processing

Your data never leaves your browser:

• No server-side storage
• No data transmitted to Genea.app servers
• Complete privacy for sensitive family information

Secure Git Storage

When using Git integration:

• Use private repositories for family data
• Review Git provider’s privacy policies
• Consider self-hosted Git options

Production Best Practices

Data Backup

Protect your family history:

1. Regular GEDCOM Exports: Download copies periodically
2. Git Version History: Git preserves all changes
3. Multiple Locations: Store backups in multiple places

Sharing with Family

Tips for family collaboration:

• Share the deployed URL with family members
• Each person can work on their data independently
• Merge changes through Git or GEDCOM exchange

Troubleshooting Common Issues

Application Not Loading

Solutions:

• Clear browser cache
• Try a different browser
• Check browser console for errors
• Verify deployment is running

GEDCOM Import Errors

Solutions:

• Validate GEDCOM file format
• Check character encoding (UTF-8)
• Try a simpler export from source
• Review any error messages

Git Connection Issues

Solutions:

• Re-authorize the Git provider
• Check repository permissions
• Verify network connectivity
• Try disconnecting and reconnecting

Additional Resources

• Official Genea.app Website
• Genea.app GitHub Repository
• Klutch.sh Deployments

Conclusion

Deploying Genea.app on Klutch.sh gives you a privacy-first genealogy tool with automatic builds and secure HTTPS access. The combination of Genea.app’s client-side architecture and Klutch.sh’s deployment simplicity means you get a powerful family tree builder without compromising on privacy.

With GEDCOM compatibility, Git integration, and a visual tree builder, Genea.app provides everything you need for modern genealogy work. Whether you’re just starting to document your family history or migrating from commercial services, Genea.app on Klutch.sh delivers a reliable, privacy-respecting platform that puts you in control of your family data.