Laravel Open Source

OpenCharity: Open-Source Charity Management Platform Built with Laravel and Filament

4 Jun 2026 17 min read Mohamed Said

Mohamed Said

OpenCharity: Open-Source Charity & Family Assistance Management Platform

GitHub Repository: https://github.com/EG-Mohamed/OpenCharity
Demo / Website: https://masar.msaied.com

Introduction

OpenCharity is an open-source charity management platform built with Laravel and Filament.

The project is designed to help NGOs, mosques, charity organizations, and community foundations manage the full lifecycle of beneficiary support. It provides tools for registering families, managing charity cases, scheduling visits, tracking assistance, storing documents, handling donation targets, and managing online donations.

Instead of using scattered spreadsheets, paper records, or disconnected systems, OpenCharity gives charity teams one structured admin platform to organize their work, improve transparency, and track assistance from the first registration until final delivery.

What Problem Does OpenCharity Solve?

Many charity organizations manage sensitive beneficiary information manually. This can create problems such as:

Duplicate family records
Missing documents
Unclear case status
No clear visit history
Difficulty tracking who received what assistance
Weak donation allocation tracking
Limited visibility into active cases
No centralized dashboard for teams
Hard-to-audit charity workflows

OpenCharity solves these problems by providing a complete case-management system built specifically for charity and humanitarian workflows.

The system allows organizations to manage families, cases, visits, assistance schedules, documents, donation campaigns, and payments in one place.

Who Is OpenCharity For?

OpenCharity is suitable for:

NGOs
Mosques
Charity foundations
Community support organizations
Humanitarian teams
Local aid groups
Social research teams
Zakat and sadaqah distribution teams
Family assistance programs
Donation-based support organizations

Core Concept

The central entity in OpenCharity is the family.

Each family can have:

Multiple family members
One or more charity cases
Visits and follow-ups
Uploaded documents
Assistance schedules
Assistance delivery records
Donation targets
Donations linked to specific needs

This makes the platform useful for long-term case management, not only one-time donation tracking.

Key Features

1. Family & Member Registry

OpenCharity allows organizations to create detailed family profiles.

A family profile can include:

Family name
Contact information
Address details
Map location
Housing status
Monthly income
Social condition
Notes and internal information
Linked family members
Linked cases
Linked documents
Linked assistance records

Family members can also be managed individually with information such as:

Name
Relation to family
Gender
Birth date
Education status
Employment status
Health condition
Income details
Personal notes

This helps charity teams understand the real situation of each family before making assistance decisions.

2. Charity Case Management

OpenCharity includes a flexible case management module.

Each family can have one or more charity cases. A case represents a specific need, issue, request, or assistance file.

Examples of charity cases:

Monthly food support
Medical assistance
Rent assistance
Education support
Emergency case
Orphan care
Debt support
Housing repair
Urgent family support

Each case can include:

Case type
Priority level
Status
Assigned user
Family relationship
Visit records
Assistance schedules
Documents
Donation targets
Internal notes

Case Priority Levels

Cases can be prioritized to help teams focus on the most urgent situations first.

Example priority levels:

Low
Medium
High
Urgent

This is useful when an organization handles many cases and needs to sort them by importance.

Case Status Lifecycle

OpenCharity supports a full case lifecycle.

A typical case workflow may include:

Draft → Under Review → Approved → In Progress → Completed → Closed

This makes it easier to understand where each case stands and what action is needed next.

3. Visit Tracking

OpenCharity supports different types of visits and follow-ups.

Visit types may include:

Field visit
Office interview
Phone call
Follow-up
Reassessment

Each visit can include:

Visit date
Visit type
Assigned visitor
Summary
Findings
Recommendations
Next visit date
Related case
Related family

This is important for organizations that need to verify family conditions before approving assistance.

4. Calendar-Based Scheduling

The system supports scheduled visits using a calendar interface.

This helps staff members:

Plan field visits
Track upcoming appointments
Avoid missed follow-ups
Organize social research work
Manage recurring reassessments

A calendar-based workflow is much easier for teams than managing visits manually in spreadsheets.

5. Assistance Scheduling & Delivery

OpenCharity allows teams to define assistance types and schedule deliveries.

Assistance can be:

Money
Food packages
Medical services
Education support
Rent support
Clothing
Household items
Custom services

Assistance schedules can be configured as:

One-time
Daily
Weekly
Monthly
Quarterly
Yearly
Custom recurring schedule

Each assistance schedule can track:

Assistance type
Quantity or amount
Unit
Funding status
Delivery status
Delivery date
Proof of delivery
Related family
Related case

This gives the organization a clear history of what was planned, what was funded, and what was actually delivered.

6. Proof of Delivery

The platform supports uploading proof-of-delivery files.

This can be useful for:

Internal auditing
Donor transparency
Team accountability
Verifying that assistance reached the correct family
Keeping records for future review

Examples of proof files:

Signed receipt
Delivery image
Scanned paper
PDF confirmation
Staff report

7. Document Vault

OpenCharity includes a document management system for storing important family and case documents.

Supported document categories may include:

Identity documents
Housing documents
Financial documents
Medical documents
Legal documents
Social research reports
Committee decisions
Case-related files

Example documents:

National ID
Birth certificate
Rent contract
Medical report
Income proof
Social research file
Committee approval
Legal paper

Each document can include:

Document type
File upload
Verification status
Expiry date
Visibility settings
Related family
Related case

8. Document Verification & Expiry Tracking

The document module supports verification and expiry tracking.

This is useful when organizations need to know:

Which documents are valid
Which documents are missing
Which documents need review
Which documents are expired
Which cases are missing required files

This makes beneficiary data more reliable and easier to audit.

9. Donations & Fundraising

OpenCharity includes donation and fundraising features.

Donation targets can be created for:

A family
A specific case
A campaign

Each donation target can include:

Goal amount
Collected amount
Progress percentage
Currency
Donation status
Public donation page
Direct donation link

This allows charity organizations to create clear fundraising goals and track progress.

10. Donation Allocation Tracking

OpenCharity supports donation allocation tracking.

A donation can be linked to a donation target, then connected to a family, case, or assistance schedule.

This creates a clear chain:

Donation → Donation Target → Case / Family → Assistance Schedule → Delivery

This is one of the most important features for transparency.

It helps answer questions like:

Who donated?
Which target did the donation support?
Which case received the funds?
Which assistance schedule was funded?
Was the assistance delivered?
Is there proof of delivery?

11. Multi-Currency Support

OpenCharity supports multiple currencies, including:

This is useful for local and international donors.

12. Payment Gateway Tracking

The platform supports tracking donations through different payment methods and gateways.

Supported payment options include:

Paymob
Stripe
Fawry
Manual payments
Other payment methods

This gives organizations flexibility depending on their region and available payment providers.

13. Paymob Integration

OpenCharity includes Paymob payment gateway integration.

The public donation flow can support:

Donation page
Payment initiation
Payment callback handling
Success page
Donation confirmation

This is especially useful for organizations operating in Egypt or regions where Paymob is commonly used.

14. Public Website

OpenCharity is not only an admin panel. It also includes a public-facing website.

The public website can include:

Hero section
About section
Services section
Statistics
Testimonials
FAQ
Active donation cases
Donation call-to-action
Donation case details
Progress bars
Payment flow

This allows organizations to present their work publicly and encourage donations.

15. Public Donation Pages

Each active donation target can have a public donation page.

A donation page may include:

Case title
Case description
Target amount
Collected amount
Remaining amount
Progress bar
Donation button
Payment link

This helps donors understand exactly what they are supporting.

16. SEO Optimization

OpenCharity includes SEO-focused features for public pages.

The project supports:

Page titles
Meta descriptions
Canonical URLs
Hreflang tags
OpenGraph tags
Twitter Cards
JSON-LD structured data

Structured data can include:

Organization schema
Website schema
Project schema
DonateAction schema

This helps search engines better understand the charity website and donation pages.

17. Admin Panel

OpenCharity uses Filament for the admin panel.

The admin panel allows staff members to manage:

Families
Family members
Charity cases
Visits
Assistance types
Assistance schedules
Assistance deliveries
Documents
Donation targets
Donations
System settings
Roles and permissions
Website content
Contact information
Social links
Branding settings

18. Roles & Permissions

OpenCharity includes role-based access control.

This allows the organization to control what each user can access.

Example roles may include:

Super admin
Admin
Case manager
Social researcher
Donation manager
Finance user
Viewer

Role-based permissions are important because charity systems contain sensitive family and financial data.

19. Arabic & English Support

OpenCharity supports Arabic and English.

This makes it suitable for organizations that operate in Arabic-speaking regions while still needing English support for international teams, donors, or documentation.

The multilingual system helps with:

Admin panel translations
Public website translations
Translatable content
Bilingual charity operations

20. System Settings

The platform includes configurable system settings.

Admins can manage:

Website branding
Logo
Contact information
Social media links
Donation settings
Online donation toggle
Public website content
Organization information

This makes the project easier to adapt for different charities without changing code.

Tech Stack

OpenCharity is built using a modern Laravel stack.

| Layer | Technology | | ------------------- | --------------------------------------- | | Backend Framework | Laravel | | PHP Version | PHP 8.3+ | | Admin Panel | Filament | | Reactive Components | Livewire | | Frontend Styling | Tailwind CSS | | JavaScript | Alpine.js | | Database | MySQL | | Testing | Pest | | Roles & Permissions | Filament Shield | | Translations | Laravel Lang, Spatie Translatable | | Calendar UI | FullCalendar | | Payments | Paymob | | Money Handling | Akaunting Laravel Money | | SEO | OpenGraph, Twitter Cards, JSON-LD tools |

Requirements

Before installing OpenCharity, make sure your environment includes:

PHP 8.3+
Composer
Node.js 20+
MySQL 8+
NPM
Laravel-compatible local environment

Laravel Herd is recommended for local development, but you can also use Laravel Valet, Docker, Laravel Sail, or a standard PHP/Nginx/Apache setup.

Installation

Clone the repository:

git clone https://github.com/EG-Mohamed/OpenCharity.git
cd OpenCharity

Install PHP dependencies:

composer install

Copy the environment file:

cp .env.example .env

Generate the application key:

php artisan key:generate

Configure your database in the .env file:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=opencharity
DB_USERNAME=root
DB_PASSWORD=

Run migrations and seeders:

php artisan migrate --seed

Install Shield permissions:

php artisan shield:install --fresh

Create the storage symbolic link:

php artisan storage:link

Install frontend dependencies and build assets:

npm install
npm run build

Demo Credentials

After running the database seeders, the system creates a demo admin account.

| Field | Value | | --------- | ---------------- | | Admin URL | /admin | | Email | admin@test.com | | Password | 123456789 |

Use these credentials only for local testing and development.

For production, change the admin credentials immediately.

Seeded Demo Data

The database seeder creates sample data to help you test the platform quickly.

Seeded data includes:

Case types
Assistance types
Families
Family members
Charity cases
Visits
Documents
Assistance schedules
Assistance deliveries
Donation targets
Donations

This makes it easier to explore the system without manually creating records from scratch.

Development Commands

Run the full development environment:

composer run dev

This can run the local server, queue worker, logs, and Vite development server together depending on the project configuration.

Run the quick setup script:

composer run setup

This is useful for preparing the project quickly during local development.

Domain Model Explanation

OpenCharity is built around a clear domain model.

Family

The family is the main record in the system.

A family can have many:

Family members
Charity cases
Documents
Donation targets
Assistance records

Family Member

A family member belongs to a family.

Each member can store personal, education, employment, health, and income-related information.

Charity Case

A charity case belongs to a family.

A case represents a specific need, request, or support workflow.

Each case can have:

Visits
Documents
Assistance schedules
Donation targets

Visit

A visit belongs to a family or case.

Visits help document field research, interviews, phone calls, follow-ups, and reassessments.

Assistance Schedule

An assistance schedule defines planned support.

It can be one-time or recurring.

Assistance Delivery

An assistance delivery records actual delivery of support.

It can include delivery status, date, and proof file.

Document

A document stores uploaded files related to families or cases.

Documents can be categorized, verified, and tracked.

Donation Target

A donation target defines a fundraising goal.

It can be linked to a family, case, or campaign.

Donation

A donation records money received from a donor or payment method.

Donation Allocation

A donation allocation tracks how donated funds are assigned to a case, family, or assistance schedule.

Example Workflow

Here is a realistic workflow for using OpenCharity.

Step 1: Register a Family

A staff member creates a new family profile with contact information, address, housing status, income level, and basic social information.

Step 2: Add Family Members

The staff member adds each family member with relation, age, education, job status, health condition, and income details.

Step 3: Open a Charity Case

A case is created for a specific need, such as rent support or medical assistance.

The case is assigned a priority and status.

Step 4: Schedule a Visit

A social researcher schedules a field visit or phone interview.

After the visit, they record findings and recommendations.

Step 5: Upload Documents

Required documents are uploaded, such as national ID, medical reports, or rent contract.

Step 6: Approve Assistance

The case is reviewed and assistance is scheduled.

The assistance may be one-time or recurring.

Step 7: Create a Donation Target

If the case needs fundraising, a donation target is created with a goal amount.

Step 8: Receive Donations

Donors can contribute through the public donation page or manual donation entry.

Step 9: Allocate Funds

Donations are allocated to the related case or assistance schedule.

Step 10: Deliver Assistance

The team delivers the assistance and uploads proof of delivery.

Step 11: Close or Continue the Case

The case can be completed, closed, or kept active for future follow-up.

Common Use Cases

OpenCharity can be used for many charity workflows.

Family Assistance Management

Manage families that need recurring monthly support, food packages, housing support, or emergency assistance.

Medical Case Support

Track medical documents, diagnosis reports, required treatment, donation targets, and payment progress.

Rent & Housing Assistance

Manage rent contracts, housing status, landlord details, payment schedules, and proof of payment.

Orphan Support

Track children, guardians, education status, monthly sponsorships, and recurring aid.

Emergency Campaigns

Create urgent donation targets for emergency cases and show progress publicly.

Schedule field visits, record findings, upload documents, and submit recommendations.

Donation Transparency

Track how donations move from donor to target to actual assistance delivery.

Mosque Charity Office

Use the platform as an internal charity office system for local families, zakat, sadaqah, and community aid.

Why Laravel and Filament?

OpenCharity uses Laravel because it provides a stable, modern, and scalable PHP framework for building business applications.

Laravel is strong for:

Authentication
Authorization
Queues
Jobs
Database migrations
Eloquent ORM
Testing
File storage
API development
Localization

Filament is used because it provides a powerful admin panel experience with:

Resource management
Forms
Tables
Filters
Actions
Relation managers
Dashboards
Role-based admin workflows

Together, Laravel and Filament make OpenCharity easier to maintain and extend.

Benefits for Charity Organizations

OpenCharity can help organizations:

Centralize beneficiary data
Reduce manual paperwork
Improve case tracking
Organize visits and follow-ups
Keep documents structured
Track assistance delivery
Improve donor transparency
Manage donation targets
Support bilingual teams
Improve internal accountability
Build a public donation website
Scale charity operations with better data

Benefits for Developers

OpenCharity is also useful for Laravel developers who want to learn or build upon a real-world Filament project.

Developers can learn from:

Laravel project structure
Filament resources
Role and permission management
Multi-language content
Donation workflow modeling
Payment integration
SEO implementation
Case management architecture
Real-world database relationships

Security Considerations

Because OpenCharity handles sensitive beneficiary and donation data, production deployments should follow strong security practices.

Recommended actions:

Change default admin credentials
Use HTTPS
Configure secure file storage
Restrict admin access
Use strong passwords
Set correct file permissions
Enable backups
Protect .env files
Review roles and permissions carefully
Keep Laravel and dependencies updated
Use trusted payment gateway credentials
Disable debug mode in production

Production .env should include:

APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-domain.com

Deployment Notes

For production deployment, you should usually run:

composer install --no-dev --optimize-autoloader
npm install
npm run build
php artisan migrate --force
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan storage:link

You should also configure:

Queue worker
Scheduler cron
File storage
Database backups
SSL certificate
Payment gateway credentials
Mail settings
Proper permissions for storage and bootstrap/cache

Example Laravel scheduler cron:

* * * * * cd /path-to-project && php artisan schedule:run >> /dev/null 2>&1

Suggested Production Server Stack

A recommended production stack could include:

Ubuntu server
Nginx
PHP 8.3+
MySQL 8+
Redis for queues/cache
Supervisor for queue workers
SSL via Let's Encrypt
Daily database backups
GitHub Actions or manual deployment workflow

Example Environment Variables

Example .env values:

APP_NAME=OpenCharity
APP_ENV=local
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=opencharity
DB_USERNAME=root
DB_PASSWORD=

FILESYSTEM_DISK=public

MAIL_MAILER=smtp
MAIL_HOST=localhost
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="hello@example.com"
MAIL_FROM_NAME="${APP_NAME}"

Payment gateway values should be configured according to the payment provider used by the organization.

SEO & Public Donation Pages

The public website is designed to support search visibility and social sharing.

Good SEO for charity websites is important because it helps people discover active causes, donation campaigns, and the organization itself.

OpenCharity supports SEO-friendly public pages through:

Clean page titles
Meta descriptions
Canonical links
Social sharing tags
OpenGraph metadata
Twitter Card metadata
Structured JSON-LD data
Donation-related schema

This makes the platform more suitable for public fundraising campaigns.

Recommended Admin Workflow

For better internal organization, a charity team can use this workflow:

Add family profile
Add family members
Upload required documents
Create charity case
Assign case manager
Schedule visit
Record visit findings
Approve or reject assistance
Create assistance schedule
Create donation target if funding is needed
Collect donations
Allocate donations
Deliver assistance
Upload proof of delivery
Close or reassess the case

Contribution Guidelines

Contributions are welcome.

Before submitting a pull request:

Follow the existing project structure
Check similar files before adding new code
Format PHP code with Laravel Pint
Use translation functions for user-facing strings
Follow conventional commit messages
Avoid unnecessary inline comments
Keep code clean and readable
Test changes before submitting

Format code with:

vendor/bin/pint

Example conventional commits:

feat: add donation target filters
fix: resolve visit date validation issue
refactor: simplify assistance delivery workflow
docs: update installation guide

License

OpenCharity is open-source software licensed under the MIT License.

Credits

OpenCharity is built by Mohamed Said using Laravel, Filament, and the wider Laravel ecosystem.

GitHub profile:

https://github.com/EG-Mohamed

Conclusion

OpenCharity is a complete open-source charity management platform for organizations that need to manage families, cases, visits, assistance, documents, donations, and public fundraising pages.

It is especially useful for NGOs, mosques, and community foundations that need a structured system for beneficiary management and donation transparency.

By combining Laravel, Filament, multilingual support, role-based permissions, document management, donation tracking, and public donation pages, OpenCharity provides a strong foundation for building modern charity and humanitarian management systems.

For source code, installation, and contribution details, visit the GitHub repository:

https://github.com/EG-Mohamed/OpenCharity

Found this useful?