Persistent Records
Every notification is stored as a first-class model in your database with full lifecycle tracking.
Open Source Rails Gem
Own your notification data. Track every delivery.
Sincerely brings observability to Rails notifications. Persist, track, and query every email, SMS, and push notification your app sends.
The notification visibility problem
Most Rails apps implement notifications as mailers, background jobs, or third-party integrations. This approach creates blind spots:
- No persistent record of what was sent
- Delivery tracking requires paid add-ons
- Communication data locked in external dashboards
- No way to query notification history
Sincerely's approach
- Every notification is a database record
- Delivery events captured via webhooks
- Full communication history in your database
- Query and analyze with ActiveRecord
Core Capabilities
Everything you need to own and observe your notification infrastructure
Lifecycle States
Track notifications through states: draft → accepted → delivered → engaged with event-driven updates.
Webhook Integration
Capture delivery and engagement events from AWS SES or other providers via webhook handlers.
Delivery Abstraction
Pluggable delivery systems. Start with AWS SES, swap providers without changing your code.
Queryable History
Use ActiveRecord to analyze patterns, build dashboards, and understand your communication data.
Data Ownership
Your notification data lives in your database, not locked away in a third-party service.
A Dashboard for Your Notifications
Sincerely includes a built-in interface to manage and monitor notifications directly inside your Rails application.
View notification analytics such as deliveries, bounces, spam reports, opens and clicks. Filter notifications by recipient, status, template, or date to quickly investigate issues.
Create and manage notification templates and send messages while keeping a clear record of everything that was delivered.
Simple, Rails-native API
Sincerely feels like Rails. No complex integrations, just familiar patterns.
# Create and send a notification
notification = Notification.create!(
recipient: user,
subject: "Welcome to our platform",
body: render_template(:welcome_email)
)
notification.deliver!
# => :accepted
# Query notification history
Notification.where(recipient: user)
.delivered
.where("created_at > ?", 1.week.ago)
# Track engagement
notification.opened? # => true
notification.clicked? # => false
notification.bounced? # => false
# Event-driven state updates
notification.events
.where(event_type: "delivered")
.order(occurred_at: :desc)Product Principles
The core beliefs that guide Sincerely's design
Data ownership matters
Teams should own their communication data, not rely on external dashboards.
Notifications are domain objects
They should be persisted, stateful, and queryable just like any other model.
Delivery is observable
Accepted does not mean delivered. Track the full lifecycle with real events.
Events drive truth
Notification state changes only through delivery and engagement events.
Built for teams that need visibility
Perfect for
- Mid-to-large Rails teams
- Early-stage MVPs
- Small indie projects
- B2B or B2C products with business-critical notifications
- Teams using AWS infrastructure (SES)
- Tech leads and platform engineers
- Teams needing communication analytics
Get Started
Add Sincerely to your Rails app in minutes
1. Add to your Gemfile
gem 'sincerely'
2. Install and migrate
bundle install
rails sincerely:install
rails db:migrate
3. Configure your delivery provider
# config/sincerely.yml
defaults: &defaults
delivery_methods:
email:
delivery_system: Sincerely::DeliverySystems::EmailAwsSes
options:
region: region
access_key_id: your_access_key_id
secret_access_key: your_secret_access_key
configuration_set_name: config_set
Start tracking your notifications today
Open source, Rails-native, and built for teams that value data ownership.