We Built Our Own CRM and Email Outreach System in One Day — Here's How It Works

Manual outreach does not scale the way founders pretend it does on Monday morning. You send a batch of emails, get a spike of replies, promise yourself you will follow up—and two weeks later the hottest thread is buried under newsletters and shipping alerts. Lead data lives in inboxes instead of a database, so nobody can answer simple questions: who is waiting on us, who is warm, who did we already pitch twice. There was no system to work contacts systematically. We were not looking for motivation hacks. We needed a machine with state.

What we decided to build

The default move is to buy another SaaS CRM and bolt on an email sequencer. That stack is easy to demo and expensive to own: two hundred to five hundred dollars a month is common before you count seats, enrichment add-ons, and the integration tax when your workflow does not match their data model. We chose the uncomfortable path on purpose. Instead of renting someone else's opinion of what a pipeline should look like, we scoped a minimal CRM plus outbound automation that matched how AUOTAM actually sells: lean team, high-trust copy, tight follow-up discipline, and full control over deliverability. Target: one day from empty repo to production. Not a slide—a live system we would use the next morning.

The infrastructure choices

We wanted cost, control, and no vendor lock-in. The spine is a small Amazon Lightsail VPS with PostgreSQL as the system of record, TLS on a custom domain, and a boring deployment path we could repeat without ceremony. PostgreSQL wins because relationships and sequences are relational problems—contacts, stages, scheduled sends, events, and suppression lists all belong in tables you can query honestly. Lightsail wins because the bill is predictable and the box is ours; we are not negotiating rate limits with a CRM middleman when volume spikes. SSL and DNS were non-negotiable: deliverability and trust start before the first email leaves the server.

The CRM application

We built a seven-page internal app we could live in daily: Dashboard, Contacts, Contact Detail, Hot Leads, Reminders, Activity Log, and Notifications. That is not feature bloat—it is the minimum set of screens that let a small team answer operational questions without exporting CSVs. Live search and pagination everywhere, because hunting through infinite scroll is how follow-ups die. Fully responsive layout, because half the reviews happen on a phone between calls. The UI is intentionally plain: dense tables, obvious primary actions, and fast filters. Fancy CRMs optimize for demos; we optimized for Tuesday afternoon when you have twelve minutes before the next call.

• Dashboard — counts that matter today: queued sends, replies waiting, hot leads, failures that need eyes.
• Contacts + detail — one canonical record per person, timeline of touches, and sequence state you can explain to a partner without drawing on a whiteboard.
• Hot Leads + Reminders — explicit queues so "I will deal with it later" becomes a dated reminder instead of vapor.
• Activity log + notifications — append-only history for what the automation did, plus human-readable alerts when the system needs a decision.

The email system

Outbound only sends inside weekday windows we configure in the scheduler—no midnight blasts, no weekend carpet-bombing—because we are not trying to win a spam race; we are trying to look like a real company when humans actually read. Each contact can run a four-email sequence with industry-specific templates, spaced by rules we control in the database rather than in a salesperson's head. Sending is AWS SES in production, with capacity at fifty thousand emails per day on our current account tier. Volume scales by configuration: a single environment variable bumps throughput caps without redeploying application code, which matters when you promote a pilot and suddenly need headroom the same week.

The integrations

• Gmail API — syncs inbound replies on a five-minute poll so conversations stay in one thread even when multiple people glance at the same lead. Threading IDs are stored with the outbound message so a reply lands on the correct contact record, not in limbo.
• AWS SNS — wired to SES events so bounces, complaints, opens, and clicks become structured rows we can alert on. Silent failure is the enemy; noisy, actionable telemetry is the goal.
• AWS SES — production sending with configuration sets and headers we own. When a provider throttles or flags something, we see it in our data—not buried in a third-party dashboard we cannot query.
• Reply threading — every outbound send records the identifiers needed to match Gmail's reply to the originating sequence step, so the Activity Log reads like a story instead of a pile of MIME artifacts.

The automation layer

Cron owns scheduling: pick due sends, respect the active send window, back off on errors, and never double-send thanks to row-level locking in PostgreSQL. PM2 keeps the Node processes alive with auto-restart if the VPS hiccups. Reminder jobs surface hot leads when engagement spikes or when a human sets a snooze. Deploy is one command from a clean machine—environment secrets, migrations, and process restart—so "ship a fix" is not a half-day detour. Once it is running, the daily operating cost is attention, not babysitting: you scan the dashboard, clear exceptions, and let the machine handle the cadence.

Why this is not a stunt

This is the same build discipline we bring to client work: name the workflow, define inputs and outputs, automate where the pattern is clear, and keep humans on the decisions that change outcomes. We scoped aggressively, cut scope that did not survive contact with reality, and shipped something we eat ourselves. The lesson is not "every CRM takes a day"—it is that a focused team with a clear state model can replace a fat SaaS bill when the problem is narrow enough to describe without hand-waving. If your bottleneck is genuinely unique, custom often wins on total cost of ownership and behavior fit. If your bottleneck is generic, buy software. We knew ours was specific.

If your team is still running outreach manually—or paying for tools that fight your workflow—book a thirty-minute call at auotam.com/book. We will map what a custom system looks like for your operation: the tables, the queues, the integrations, and the first slice worth shipping before you debate a twelve-month roadmap.