DEV Community: Andrew Miracle

leadmark.email: Turn Your Inbox into a Sales Automation Engine via Postmark

Andrew Miracle — Mon, 09 Jun 2025 05:31:39 +0000

This is a submission for the Postmark Challenge: Inbox Innovators.

Leadmark – AI-Powered Inbox Automation
Hackathon Submission for Postmark’s Dev Inbox Challenge

🔗 Live demo: https://www.leadmark.email
📂 Source code: https://github.com/tecmie/leadmark

🛠️ The Problem

Medium to Large scale Sales teams across several industries from enterprise to real-estate receive an average 300–1,000 new leads per day, yet spend 1–4 hours per rep just qualifying them. At $20–30 USD hour × 20 reps, that’s roughly 40 hours—or $1,000 USD—burned daily on unqualified prospects.

💡 The Solution

leadmark.email transforms every inbound email lead into an intelligent, AI-driven workflow—powered by Postmark’s Inbound Email Parsing. The core innovation? Treating each unique email address as an API endpoint that triggers business automation in real time.

Setting up your mailbox and Assistant

In this quick walkthrough, I show you exactly how to configure Leadmark's AI “assistant objective”—so you can start automatically qualifying and responding to leads in seconds.

Automating Qualification and Mail + Scheduling and Contacts

In this extended demo, we pick up right where the mailbox & AI assistant setup left off—and dive into every corner of the Leadmark app. From your email dashboard and workspace to built-in calendar scheduling and user profile management, see how leadmark.email turns your inbox into a seamless, end-to-end sales automation platform.

How leadmark.email Uses Postmark’s Inbound Email Parsing

Webhook Processing: Real-time parsing via a worker with a webhooks /api/postman endpoint.
Full Message Extraction: Captures headers, body content, attachments, and metadata to enable MX routing for multiple custom email inboxes (i.e custom@leadmark.email)
Bidirectional Communication: Inbound parsing + outbound response sending through Postmark’s API.
Production Architecture: Async job processing (BullMQ/Redis), robust error handling, and horizontal scaling.

Example of a simple lead-gen form for a Gym Franchise & Real Estate Investment Firm https://www.leadmark.email/form/candidate-contact-form.

This form is linked to an actual email from a demo real estate agency and filling the form will automate a lead qualification cycle up to the point where a meeting is booked between you and an Account Manager

Key Features + Postmark

Smart Email Replies
- Parse emails via Postmark webhooks
- AI analyzes content for qualification and responds in real-time via Postmark’s outbound API
Auto Meeting Booking
- Detects scheduling intent
- Checks Google Calendar and books meetings, sending email confirmations
Lead Scoring Pipeline
- Processes emailed form submissions
- Scores and categorizes leads, triggering follow-ups to managers
Document-Savvy Chats
- Parses PDF/DOCX attachments
- Extracts data for AI responses, maintaining thread context

🛠️ Technical Implementation

1. Postmark Webhook Handler

// apps/processor/src/api/postman.ts
router.post<{}, PostmanResponse>("/", async (req, res) => {
  const input = req.body as InboundMessageDetails;
  // Validate mailbox ownership
  const mailboxWithOwner = await _validateMailbox(input.To);
  // Async processing
  await postmanEventProducerMQ.postman(input);
  res.json({ message: "Webhook received" });
});

2. GPT + Tools + Conversational AI

// Generate AI response
const { aiResponse, aiResponseToHtml } = await getAIResponse({
  thread, messageText, mailbox, contact, name });
// Send via Postmark outbound API
await postmark.sendEmail({
  From: `${owner.full_name} <${mailbox.unique_address}>`,
  To: input.FromFull.Email,
  Subject: replySubject,
  HtmlBody: aiResponseToHtml,
  TextBody: aiResponse,
});

3. Architecture Flow

Email is sent to Postmark Inbound, which parses it into JSON and sends it via webhook to /api/postman. The API enqueues the job in BullMQ/Redis. The job is processed by Parsing & Scoring, which extracts data and sends it to the AI/Rules Engine for lead qualification. The engine returns a decision, stored in Supabase/Postgres. Parsing & Scoring triggers an auto-reply or forward via Postmark Outbound to the recipient. Real-time updates from the database reflect lead status on the Dashboard.

📈 Impact & Metrics

About $750 USD per day saved for an average 20-rep team
<30 s from email arrival to qualification & routing
98%+ parsing accuracy in pilot tests
90%+ rule-based filtering accuracy out of the box

🔮 What’s Next

AI-Driven Scoring: Swap keyword rules for fine-tuned GPT models
Visual Dashboard: Live metrics, rule-builder UI, executive insights
Omni-Channel: Integrate WhatsApp look into contacts for 360 engagement
Team Management: Role-based access, multi-domain support

🙏 Get Started in Minutes

Clone & install:

   git clone https://github.com/tecmie/leadmark.git
   cd leadmark && npm install

Set environment variables:

POSTMARK_API_KEY, SUPABASE_URL, SUPABASE_KEY
GOOGLE_CALENDAR_CREDENTIALS, OPENAI_API_KEY (for AI)
1. Run:

   npm run dev

Configure Postmark:

Point your inbound webhook to https://<your-domain>/api/postman

LeadMark turns every email into a revenue-driving, AI-powered workflow—powered by Postmark’s Dev Inbox!

Code Repository

🔗 https://github.com/tecmie/leadmark

Team Members

This submission was built by @koolamusic and the Tecmie team.

Soroban by Example

Andrew Miracle — Mon, 19 Aug 2024 06:59:56 +0000

The challenge

When exploring a new smart contract language, after learning the syntax and data types, one of the best ways is through examples, boilerplates and exploring various strategies to implement something that you would have done in a previous language. Within the Web3 space there are a couple strategies that proven effective.

The Openzeppelin library format
The Scaffold ("insert ETH,Stark,Soroban") format
"Smart contract Language" by example
Factory contracts + Wizards and Generators

We can easily group these into "Bootstrappers" - "Boilerplate" - "Libraries" in a Magic Quadrant, these various strategies enable you quickly go from 0 - 1 in a new smart contract language.

It goes without saying, that project based learning is the most effective approach to becoming proficient in Soroban as it is with any other smart contract language or programming language in general. However, the daunting challenge that Soroban presents, especially for developers coming from more widely-used smart contract languages like Solidity, is its intimidating appearance at first glance. For those who are not familiar with Rust, Soroban's syntax and concepts can seem foreign and overwhelming, creating a significant barrier to entry. This unfamiliarity and perceived complexity cause blockchain developers to stick with the languages they are more comfortable with, despite the potential benefits Soroban may offer.

The Resolution

We built Soroban by Example is a comprehensive resource designed to help developers, especially those transitioning from other smart contract languages like Solidity, to learn and adopt Soroban through a project-based approach.

Our key Objectives for Soroban Examples

Familiarity: Help developers find implementations of well-known concepts from other smart contract languages
Developer Experience: Provide an interactive and user-friendly documentation explorer for a great DX
Simplicity: Keep the example snippets clean, simple, and focused on core concepts
Integrated Playground: Allow developers to explore, modify, and try out the example contracts
AI-Assisted Variants: Generate customized variants of the example contracts using an AI assistant

💡 However while keeping an ambitious goal in view, there were a couple challenges with trying to fit the world into Soroban. Essentially looking at the more popular blockchain ecosystems and their paradigms to fit into how smart contracts on Stellar can be written

EVMs have this concept of the ZERO_ADDRESS for burning tokens and NFTs and performing a lot of modifer functions, however, that is irrelevant to the context of Soroban where ZERO_ADDRESS is useless and instead of modifiers, modules are preferred
Solidity, the most popular smart contract language uses inheritance as a form of extensibility, but this does not apply to Soroban, as everything you will need from the host is available by passing &env into functions to get access to the host environment. This means that in Soroban we favor functional composition over inheritance.

For some of us on the team, this was our first foray into the Soroban ecosystem, even Koha who has worked in DevRel roles for protocols and teams building within the EVM ecosystem, agrees that Soroban is more exciting 🤣. Having to fit into the standards/systems from more popular smart contract languages is boring.

How we got here (Our Failed Attempts)

Before getting to this point we made several attempts at achieving our objectives. Our first attempt — AI Code Generator was building out a Custom GPT to learn Soroban and get example contracts

💡 In order to achieve this initial milestone, we had to train a custom GPT with documents from the stellar developer docs. To achieve that, we wrote a simple scraper script fetch the developer docs and chunk them into text files, see our github repo for the scraper implementation.

kohasummons / crawler

A Webscraper and File Splitter

Crawler

A lightweight web crawler that can also split files.

View on GitHub

However after a couple test runs, we realized that this GPT is not really great at understanding the JTBD (Job to be Done) and still hallucinates in rust when asked to perform more advanced instructions like generate specific type contracts and tests.

Alternative paths

For the AI Code Generator, we found some options like kapa.ai However upon further explorer, we realised that there would be limitations with that implementation as it would only cater to document search and suggestions.

This also meant we could not avoid manually curating the examples ourselves and reviewing each publication one by one.

Final Resolution

After so many trials and errors, we decided that the best way to go about this was to manually curate each example contract ourselves and train / finetune an examples generator model called “Soroboy” — Soroboy will be different from a GPT, because this time it will live inside the context of an example smart contract page.

We first started by curating all contract examples in a Notion workspace and tracking their Okashi playground links as well. This meant starting out with core concepts and generating baseline contracts that are a great starting point.

When a user visits our example website, they can have a conversation with Soroboy to generate a variant of the contract example on that page.

In the example below, Soroboy is able to generate a variant of an only_owner contract with multiple owners instead of one owner

To achieve this, we have to manually curate soroban contracts ourselves, review them exploration on this front focuses on training an AI model on examples, so that it can leverage that for contextual exploration, our idea around this is something that generates variations of an existing contract. The workflow is something like this.

Take an existing Soroban Example
Input prompt to modify the contract according to a certain use-case
Generate new example code based on context and new “use-case” instruction

💡 To implement this, we used a Vector storage library LanceDB which is an in-memory DB built with Rust and uses the [Apache-Arrow Data Format] for compact storage.

Lance was perfect for this exploration, because all of your vector embeddings are simply files that can be tracked on github. See our rag embeddings to get a sense of what this looks like.

For Generation capabilitie, API Calls are routed to OpenAI GPT-4o at the moment. To be able to inject the AI module into the documentation page, we have to implement a custom react library and API server to manage the interactions for this.

Deviation from original plan

A couple things we finally executed that weren’t part of our original plan was to embed an Okashi playground into docs website.

If you take a look at our Root Notion Database You will notice that all of our docs page, when being prepared had their own Okashi playground. We had chosen Okashi because it was dead simple to use, and we didn’t have to maintain a large repo of example contracts with their own Cargo.toml

This was great for testing and exploration and during the development of this project, Our team wondered what the experience for our users would be like, if they could simply compile and run these contracts in a codesandbox fashion.

Okashi was the first choice for us, however there are some limitations with Okashi we wish the maintainers would be open to support to greatly improve DX

Duplication: Can we get the ability to duplicate a contract on Okashi into our own workspace or just anywhere?
Embeddable Widgets: Can we inject an iframe version of Okashi as a widget on any website.

If you take a look at the simple Soroban Loop Example on our website. You will notice that there is an Okashi Widget embedded within the page. As a matter of fact all the pages have an Okashi widget inside of them. We were able to do this by writing a custom_proxy_server that acts as a middleware between our website and Okashi.

daccred / okashi-widget-proxy

A simple proxy that enables us implement widgets in okashi

This server simply transpiles an Okashi request so we can get the full DOM object of Okashi and modify the views to suit our Widget capabilities.

We consider this to be a hack — a rather brute way of achieving our purpose, that enables us provide the intended experience for this project. We’ve already reached out to Morgan and the Okashi team on Discord, hopefully we can get their attention and have this as a feature in Okashi

In hindsight, I think we under-estimated how much work we would have to do in order to achieve the core objectives of this project, some of the artefacts we produced were

Stellar website scraper utility - https://github.com/kohasummons/crawler
Okashi Proxy Server - https://github.com/koolamusic/okashi-proxy/
OpenAI API Server (Not opensource “API keys and envs in repo 😂”
Soroban by Example Documentation Website - https://sorobanexamples.xyz
Soroban Custom GPT on ChatGPT - https://chatgpt.com/g/g-oW0Pjt0tu-soroban-v1
Project Repository — See Notion Database
Vector Embeddings of All contract examples

Beyond the hackathon

Soroban is an amazing smart contract language, and we intend to continue maintaining this project, as well as exploring Soroban and creating new projects with it.

Monorepo: Over the coming weeks we will work towards consolidating all code artefacts into one monorepo to improve code organization and contribution to each module that enhances the experience and delivery of Soroban by Example.
Multilingual Support: Once consolidation is complete, we will work on integrating 3 more languages “spanish, french and mandarin” hopefully with support from the community

Our goal with this project apart from increasing discoverability for the Soroban ecosystem and showing so-many simple use-cases and boilerplates that developers and individuals exploring the Soroban ecosystem can interact with. Will also be to offer

DevRel consultation services, for building out developer documentation for DevTools within the ecosystem to improve DX for teams building products targeting developers. Members of our team already work in DevRel roles across projects building within the EVM & Move blockchains [Insert Project Names and Protocols]
Soroban consultation: provide consultation services for organisations and founders who are targeting the stellar ecosystem as a blockchain of choice to build innovative solution within stellar

Some future updates

Improve the UX for rendering examples on page, so we can have tabs for playground and static text, so that showing the Playground becomes an Opt-In feature like the AI Assistant
Memory Module for AI to persist new generated code for learning purposes, finetuning and publishing new example use-cases
Metered usage of AI generations. for the purposes of sustainability we might limit our AI Generations to 100 per day, essentially target a number that keeps our OpenAI spend down to $5 per day max and reset it every 24 hours.

The team

This hackathon submission was made by:

Joshua Omobola (@koha): https://github.com/kohasummons
Mercy Thaddeus (@mercythaddeus): https://github.com/ThaddeusMercy
Andrew Miracle: https://github.com/koolamusic
MJ(@0xilance): https://github.com/0xilance

Inspirations and Footnote

We took a lot of inspiration from projects within the ecosystem pushing the boundaries of what is possible with Soroban.

Stellar Soroban Examples:
Coinfabrik Stellar Examples
Math Soroban
iMath Soroban
AMM DEX Soroban
Solidity by Example
Cairo by Example
Stellar Assets Token Playground
Okashi
Soroban Rust SDK Documentation https://docs.rs/soroban-sdk/21.5.0/soroban_sdk/index.html

Deadline versus Lifeline

Andrew Miracle — Wed, 23 Jan 2019 23:00:00 +0000

We are stuck goals and milestones in a modern age, where everything is moving fast and millenials are expected to meet very high expectations, this is not our point though

Have you ever given a developer a job to do for you with an ETA. this applies to most creatives, artist, music producers, carpenters etc.

Are you a deadline or lifeline person : This comparison will help you find out

Deadline

sticks to the timeline and delivers before time
Sticks to a particular process/strategy and gracefully follows it through

Lifeline

Good at emergency deliveries, tight delivery expectations
Hacks processes to produces optimal results, most cases short term.

This makes me reflect between Mourinho and Pep Guardiola, two wonderful personalites, winners they are, however I would categorize one as a Lifeline person and another one as a deadline person

In the startup world, you require a mix of both, roll out a feature immediately, so that the VC and users would be happy, experiencing the potential of that feature, then gradually iterating through the process to optimize and fine tune delivery and results.

Who are you ? Deadline : Lifeline

What can a course in programming to do you ?

Andrew Miracle — Tue, 22 Jan 2019 23:00:00 +0000

So you may be wondering what benefits you get from learning how to code, apart from the obvious benefits, learning how to code can help you

Improve your perception and thought process
Add value to your current role or position
Teach you discipline as (programming requires discipline)
Help you get a job (There are a lot of testimonies out there about totally beginners getting a job after completing a coding program)

It is very easy to get started with online resources that make it easy and have a very welcoming community where you can learn from

If you are not convinced yet, these are life changing testimonies from people who after taking a course in programming improved and transformed their lives.

I’m a Woman Who Learned to Code and, Honestly, It Changed My Life

Lessons from 7 self-taught coders who now work full time as software developers

Student Testimonies from Favcode54

Student Testimonies from Codecademy

I just got a Front End Dev job. And I have freeCodeCamp to thank for it…

FCC Testimonies

After Software Development what's next?

Andrew Miracle — Mon, 21 Jan 2019 23:00:00 +0000

I recently came across an acquaintaince who had about 20 years of experience in the software development field, and was wondering what next he should do at this point in his career and life, though I didnt have the opportunity to share my answers to him, at the top of my head, these were my thoughts

Management
Mentorship

Management

With over 20 years in your belt, you should have the opportunity to notice how trends have been shaped, improved and change, move to the top of the Product Development Cycle which is either (idea => design) or (design => implementation) or (design => user adoption) you should be able to match any of these with your personal capacity and strengths.

Mentorship

Give back to the community, what is it that you have learnt over this years that you can share with the younger generation of budding software developers and enthusiasts, trust me, its a very lonely journey for those starting and having someone with long term experience to talk to can be de-stressing and comforting, the side benefit is that, it helps you keep up with the latest trends in technology and also keep you abreast with industry trends too.

However, after spending over 20 years in any field, I tend think that there are a broad spectrum of choices after that long period of time, anyone should have figured their edge and strengths by now to know where they can focus the remaining part of their time and energy on.

Lessons learned from developing for a startup

Andrew Miracle — Mon, 31 Dec 2018 23:00:00 +0000

Although we’d like to develop products and services iteratively, the truth is organisations think in terms of strict deadlines – and budgets. We product owners need to think about how we manage this.

Browsers update regularly, making frequent, (mostly) small changes. This causes little disruption for users. It’s rare you’ll download a big update and find everything is completely different. This is is how we’d like to develop software over several years, especially with embedded systems.

But let’s say you have a finite budget and, consequently, a set-in-stone launch date – like the ship in the above picture. The expectation is that the product will be ready, and won’t sink if it bumps into any icebergs.

If your best feedback will come from real usage, you might plan a beta phase, as we did when developing library self-service software. This is useful,but there’s a big difference between a controlled roll out to 4 small libraries, and installing kiosks in over 20 libraries within various institutions in a region, where staff are less invested in the new product and require understanding to be able to utilize the benefits of the product.

We unearthed user problems during the launch I would have liked to have fixed more quickly, but we ran up against the big launch date curse of no more project money.

The lesson learned is therefore quite simple:

If you have an official launch date, make sure there is some project budget remaining for further changes after this date.

Note: It’s important this money is kept aside for the project. There’s little value in coming in under budget (besides some temporary good PR that’ll come back to bite you later in your career) if your product isn’t perfect – and it’ll never be perfect.