1(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,91475,e=>{"use strict";var t=e.i(43476),a=e.i(18566),i=e.i(57688),o=e.i(22016),s=e.i(50682),n=e.i(75254);let r=(0,n.default)("pencil",[["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",key:"1a8usu"}],["path",{d:"m15 5 4 4",key:"1mk7zo"}]]),l=(0,n.default)("square-pen",[["path",{d:"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7",key:"1m0v6g"}],["path",{d:"M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z",key:"ohrbg2"}]]),c=[{id:"1",title:"Introducing an API Gateway",slug:"introducing-an-api-gateway",excerpt:"As Keplars continues to evolve from a simple MVP into a production-grade email infrastructure platform, we've been making steady improvements to our internal architecture.",date:"Dec 10, 2025",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/apigateway%40300x.png",content:`As Keplars continues to evolve from a simple MVP into a production-grade email infrastructure platform, we've been making steady improvements to our internal architecture. 2 3One of the most important recent changes was introducing an API Gateway into our stack. 4 5After evaluating several options, we integrated Apache APISIX, the cloud-native API gateway maintained by the Apache Software Foundation. 6 7Why an API Gateway? 8 9As we move toward a more modular, semi-microservice architecture, we needed a clean and reliable routing layer that could sit between external requests and our internal services. Without this, responsibilities like routing, authentication, rate limiting, and observability tend to leak into individual services, making the system harder to reason about and scale. 10 11APISIX gives us a clear separation of concerns. It allows Keplars to handle: 12 13- Centralized request routing 14- Consistent security policies 15- Better traffic control and rate limiting 16- Cleaner service-to-service boundaries 17 18This change significantly simplifies our internal services and makes future iterations safer and more predictable. 19 20--- 21 22Why Apache APISIX? 23 24APISIX stood out for a few reasons: 25 26- Strong performance characteristics at scale 27- A flexible, plugin-based architecture 28- First-class support for modern cloud-native patterns 29- Transparent, well-maintained open-source development 30 31We rely heavily on open-source software, and having infrastructure components we can trust and understand deeply is critical for a platform that handles product-critical communication. 32 33Huge respect to the Apache Software Foundation and the contributors behind APISIX for maintaining such a high-quality project. 34 35--- 36 37What this means for Keplars users: 38 39While this change happens entirely behind the scenes, it directly supports our core goals: 40 41- More predictable behavior in production 42- Better reliability as traffic grows 43- A foundation that allows us to add features without increasing complexity 44 45It's another step toward making Keplars boring in the best way: reliable, predictable, and focused on solving real problems without introducing unnecessary friction. 46 47--- 48 49Conclusion: 50 51Introducing Apache APISIX as our API Gateway marks a significant milestone in Keplars' architectural evolution. While the change itself may seem invisible to end users, it represents our commitment to building infrastructure that scales thoughtfully and maintains reliability as we grow. 52 53This is the kind of infrastructure work that doesn't make headlines, but it's what allows us to ship features faster, maintain system stability, and keep our promises to developers who depend on Keplars for critical communication. 54 55As we continue building, expect more of these "boring" improvements: solid, well-tested changes that make the platform more dependable, not more complex. 56 57If you're using Keplars or considering it for your email infrastru
57cture, know that every architectural decision we make is guided by one principle: make it work reliably, then get out of the way.`,seoTitle:"How We Built an API Gateway for Keplars Using Apache APISIX",seoDescription:"Keplars integrated Apache APISIX as its central API gateway for request routing, rate limiting, and security. Here's why we chose APISIX and what it means for platform reliability.",seoKeywords:["Apache APISIX","API gateway","microservices routing","rate limiting","request routing","Keplars infrastructure","cloud-native API gateway","email infrastructure engineering","service mesh","centralized authentication"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Introducing an API Gateway",description:"Keplars integrated Apache APISIX as its central API gateway for request routing, rate limiting, and security.",image:"https://cdn.keplersmail.com/blogs/apigateway%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2025-12-10",dateModified:"2025-12-10",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/introducing-an-api-gateway"}}},{id:"2",title:"Moving to a Semi-Microservices Architecture",slug:"moving-to-a-semi-microservices-architecture",excerpt:"As Keplars Mail Service continues to grow, we recently completed a major architectural milestone: transitioning from a monolithic application to a selective, semi-microservices architecture.",date:"Dec 15, 2025",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/semi_microservices%40300x.png",content:`As Keplars Mail Service continues to grow, we recently completed a major architectural milestone: transitioning from a monolithic application to a selective, semi-microservices architecture. 58 59This wasn't a decision driven by trend or hype. It was driven by real operational needs we began to encounter as usage increased and the platform matured. 60 61Why move away from a monolith? 62 63In the early stages, a monolith served us well. It allowed us to move fast, iterate quickly, and validate the product with minimal overhead. But as we started preparing Keplars for higher throughput and more complex workflows, certain limitations became clear. 64 65By breaking out critical parts of the system into focused services, we gained: 66 67- Better fault isolation â issues in one component no longer r
67isk cascading across the entire system 68- Clearer service ownership â each service has a well-defined responsibility 69- Faster and safer deployments â changes can be shipped independently 70- Targeted scalability â we can scale only what needs to scale, not everything 71 72This shift gives us much more control over how the platform behaves under load and how we evolve it over time. 73 74--- 75 76Why "semi" microservices? 77 78We're intentionally not going all-in on microservices everywhere. 79 80Microservices come with real operational complexity: distributed debugging, network overhead, and higher coordination costs. At this stage, a fully decomposed system would slow us down more than it would help. 81 82Instead, we've taken a pragmatic approach: 83 84- Core, high-impact components are isolated into services 85- Simpler, tightly-coupled logic remains consolidated 86- Boundaries are introduced only where they provide clear value 87 88This keeps the system flexible without making it fragile. 89 90--- 91 92What this enables going forward: 93 94This architectural change lays the groundwork for: 95 96- Higher email throughput with predictable performance 97- Safer experimentation and feature development 98- Cleaner integrations between internal systems 99- Easier onboarding for new team members with clearer system boundaries 100 101--- 102 103Conclusion: 104 105Moving to a semi-microservices architecture represents a thoughtful evolution of Keplars' technical foundation. We're not chasing architectural purity-we're solving real problems as they emerge. 106 107This approach gives us the benefits of service isolation where it matters most, without the overhead of managing dozens of independent services prematurely. It's about finding the right balance between flexibility and simplicity. 108 109As Keplars continues to scale, this foundation allows us to grow the platform sustainably while maintaining the reliability and performance that our users depend on. 110 111The goal remains the same: build infrastructure that works predictably, scales thoughtfully, and stays out of your way.`,seoTitle:"From Monolith to Semi-Microservices: How Keplars Scaled Its Architecture",seoDescription:"Keplars migrated from a monolithic app to a selective semi-microservices architecture for better fault isolation, independent deployments, and scalable infrastructure.",seoKeywords:["semi-microservices architecture","monolith to microservices","fault isolation","independent deployments","scalable architecture","Keplars engineering","email infrastructure","service boundaries","distributed systems","software architecture migration"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Moving to a Semi-Microservices Architecture",description:"Keplars migrated from a monolithic app to a selective semi-microservices architecture for better fault isolation, independent deployments, and scalable infrastructure.",image:"https://cdn.keplersmail.com/blogs/semi_microservices%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2025-12-15",dateModified:"2025-12-15",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/moving-to-a-semi-microservices-architecture"}}},{id:"3",title:"Switching from NGINX to Traefik",slug:"switching-from-nginx-to-traefik",excerpt:"For over a decade, NGINX has been my default choice for reverse proxies. But as Keplars Mail Service continued to evolve, we reached a point where the routing layer needed to become more dynamic and developer-friendly.",date:"Dec 20, 2025",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/traefik%40300x.png",content:`For over a decade, NGINX has been my default choice for reverse proxies. It's battle-tested, reliable, and has powered countless production systems. So switching away from it wasn't something I took lightly. 112 113But as Keplars Mail Service continued to evolve, especially with our move toward a semi-microservices architecture, we reached a point where the routing layer needed to become more dynamic, flexible, and developer-friendly. 114 115That's when we decided to migrate to Traefik by Traefik Labs. 116 117Why reconsider the routing layer? 118 119In a growing system, routing stops being "just configuration." It becomes part of the developer workflow. 120 121With NGINX, even small routing changes often meant: 122 123- Editing configuration files 124- Managing reloads carefully 125- Coordinating changes across environments 126- Being extra cautious in production 127 128While this is manageable, it introduces friction as the number of services and routes increases. 129 130--- 131 132The Traefik difference: 133 134Traefik's dynamic, service-aware routing model immediately stood out. 135 136Routes update automatically as services change. No manual reloads. No juggling multiple config files. No interruption to traffic. Everything reacts in real time. 137 138The experience feels noticeably smoother: 139 140- Routing rules stay close to the services themselves 141- Configuration changes propagate instantly 142- The system feels lighter and easier to reason about 143 144Honestly, the first few days felt almost too smooth. Once you experience routing that "just flows," it's hard to go back. 145 146--- 147 148Why this matters for Keplars: 149
150This switch gives us: 151 152- Greater flexibility as services grow and evolve 153- Cleaner separation between infrastructure and application logic 154- Faster iteration without operational overhead 155- A routing layer that scales naturally with our architecture 156 157As Keplars handles more traffic and more internal services, having a routing system that adapts dynamically is a major win. 158 159--- 160 161Conclusion: 162 163Infrastructure should stay out of the way. 164 165Moving from NGINX to Traefik wasn't about chasing new technology-it was about removing friction from our workflow and making the routing layer adapt to our needs, not the other way around. 166 167NGINX will always have a place in production infrastructure. It's proven, reliable, and will continue to power systems for years to come. But for where Keplars is headed-dynamic services, rapid iteration, and a focus on developer experience-Traefik is the better fit. 168 169The result is a routing layer that feels invisible in the best way: it works, it adapts, and it doesn't slow us down. 170 171As always, infrastructure decisions aren't about what's "best" in the abstract. They're about what solves the problem you actually have, right now, as clearly as possible.`,seoTitle:"NGINX vs Traefik: Why Keplars Switched to Traefik for Dynamic Routing",seoDescription:"Keplars moved from NGINX to Traefik for automatic service-aware routing. Learn how Traefik eliminated manual reloads and improved deployment speed across our growing service mesh.",seoKeywords:["NGINX vs Traefik","Traefik reverse proxy","dynamic routing","service-aware routing","Traefik Labs","NGINX alternative","Keplars engineering","infrastructure routing","automatic service discovery","microservices reverse proxy"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Switching from NGINX to Traefik",description:"Keplars moved from NGINX to Traefik for automatic service-aware routing, eliminating manual reloads and improving deployment speed.",image:"https://cdn.keplersmail.com/blogs/traefik%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2025-12-20",dateModified:"2025-12-20",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/switching-from-nginx-to-traefik"}}},{id:"4",title:"Why Transactional Email Latency Matters: The Architecture Behind Sub-Second Delivery",slug:"why-transactional-email-latency-matters",excerpt:"Most people think email is slow by nature. But in transactional email, latency doesn't behave like that. It can't. Latency is not a number - it's a user experience.",date:"Dec 25, 2025",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/email_latency%40300x.png",content:`Most people think email is slow by nature. A few seconds here, a minute there - it's "just how email works." But in transactional email, latency doesn't behave like that. It can't. 172 173A verification code arriving 5 seconds late feels fine. Arriving 15 seconds late feels broken. Arriving 30 seconds late feels like the product doesn't work. 174 175Latency is not a number - it's a user experience. 176 177And in a world where authentication, account access, and alerts depend on email, latency becomes one of the most important engineering problems to solve. 178 179What Actually Happens When You Send a Transactional Email? 180 181Behind a simple "send email" API call, several things occur: 182 183- The request enters the platform 184- It is validated, normalized, and queued 185- Routing logic decides the best path (provider â region â MTA) 186- The sending server establishes a connection 187- The email is handed off to the receiving mail server 188- The receiving system evaluates reputation, headers, content 189- Inbox filters make final placement decisions 190 191Each of these steps can introduce delay. 192 193Most traditional SMTP-based systems don't optimize these stages - they rely on best-effort routing. That's why "fast" and "email" rarely appear in the same sentence. 194 195--- 196 197Where Latency Is Lost (And Why Most Systems Miss It): 198 199A. Cold SMTP connections â Each new connection adds hundreds of milliseconds. 200
201B. Slow or overloaded MTAs â Shared infrastructure = shared slowdowns. 202 203C. No local/regional routing â Sending everything from one location increases global delay. 204 205D. Provider throttling â If emails spike, the provider slows down delivery automatically. 206 207E. No prioritization â A reset email should not wait behind 200 other queued messages. 208 209Most platforms don't address these because they were originally built for marketing emails - not transactional events. 210 211--- 212 213How Keplars Reduces Latency at Every Layer: 214 215Keplars Mail Service wasn't built from a marketing-email mindset. From day one, the question was: 216 217"How fast can we make transactional delivery without compromising reliability?" 218 219Here's how we approach it: 220 221A. Persistent, warm connections â We maintain optimized SMTP/MTA connections to avoid cold-start delays. 222 223B. Priority-based queues â OTPs and reset links skip ahead of lower-priority messages. 224 225C. Geo-aware routing â Keplars Mail Service chooses the most optimal path based on: 226 227- Sender domain 228- User's region 229- Provider behavior 230- Load distribution 231 232This cuts unnecessary hops. 233 234D. Multi-path delivery logic â If one path is slow or throttled, another provider takes over instantly. 235 236Your email should not wait for a slow server - it should move. 237 238E. Predictive throttling avoidance â Instead of reacting to throttling, Keplars Mail Service predicts it based on: 239 240- Traffic patterns 241- Provider behavior 242- Historical latencies 243- Upcoming spikes 244 245This keeps throughput stable even at peak load. 246 247--- 248 249Why Sub-Second Delivery Matters More Than Ever: 250 251Modern product flows depend on speed: 252 253- Login 254- 2FA 255- Onboarding 256- Password recovery 257- Security alerts 258- Real-time notifications 259 260A slow email creates hesitation and hesitation creates churn. 261 262For many users, their first impression of your product is not the UI, the dashboard, or onboarding flow. 263 264It is the time between clicking "Request OTP" and checking their inbox. 265 266That small duration decides whether the product feels fast or frustrating. 267 268--- 269 270The Real Goal: Predictability, Not Just Speed: 271 272Fast delivery is good. Consistent delivery is better. 273 274Keplars Mail Service is engineered so: 275 276- OTPs arrive in the same amount of time every time 277- Resets behave predictably 278- Messages don't randomly fluctuate in latency 279- Global users get equal performance 280 281This consistency builds trust the core factor behind authentication-driven workflows. 282 283--- 284 285Conclusion: 286 287Latency may look like a small metric on an engineering dashboard, but it has an outsized effect on user experience. It's the difference between a login that feels instant and one that feels broken. 288 289Keplars Mail Service focuses on transactional email and optimizing latency is one of the reasons why. 290 291Fast email isn't magic. It's architecture. It's warm connections, smart routing, predictive queuing, and infrastructure designed specifically for the workflows that matter most: authentication, alerts, and real-time communication. 292 293Speed isn't a feature. It's the foundation of trust in transactional email. 294 295And at Keplars, that's exactly what we're building: email infrastructure that doesn't make users wait.`,seoTitle:"Why Transactional Email Latency Matters and How to Fix It",seoDescription:"Transactional email latency directly impacts user experience. Learn how Keplars uses warm SMTP connections, priority queues, and geo-aware routing to achieve consistent sub-second delivery.",seoKeywords:["transactional email latency","email delivery speed","sub-second email delivery","SMTP warm connections","priority email queues","geo-aware email routing","OTP email speed","email infrastructure performance","Keplars email","time to inbox"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Why Transactional Email Latency Matters: The Architecture Behind Sub-Second Delivery",description:"Transactional email latency directly impacts user experience. Learn how Keplars uses warm SMTP connections, priority queues, and geo-aware routing for sub-second delivery.",image:"https://cdn.keplersmail.com/blogs/email_latency%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2025-12-25",dateModified:"2025-12-25",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/why-transactional-email-latency-matters"}}},{id:"5",title:"Building Spam Protection into Transactional Email",slug:"building-spam-protection-into-transactional-email",excerpt:"Transactional email isn't just about sending messages quickly. It's also about making sure the platform can't be misused for spam, phishing, or malicious content, intentionally or otherwise.",date:"Dec 30, 2025",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/spamprotection%40300x.png",content:`When I
295started building a transactional mail platform, I expected the hard parts to be performance, scalability, and deliverability. 296 297What I didn't fully appreciate early on was how many layers of protection are required behind the scenes. 298 299Transactional email isn't just about sending messages quickly. It's also about making sure the platform can't be misused for spam, phishing, or malicious content, intentionally or otherwise. As soon as you allow programmatic sending and custom domains, abuse prevention becomes just as critical as throughput. 300 301Thinking beyond delivery: 302 303As Keplars grew, we began actively modeling abuse scenarios, especially around custom domains. We asked questions like: 304 305- What happens if a domain is compromised? 306- How do we detect harmful or suspicious sending patterns early? 307- How do we stop abuse before it affects deliverability or user trust? 308 309These questions pushed us to strengthen our spam-prevention and abuse-detection systems, with a focus on early signals, not reactive cleanup. 310 311The goal is simple: flag potential issues quickly and act before they turn into real problems. 312 313--- 314 315Balancing security and startup realities: 316 317One of the harder challenges here is balancing capability, cost, and complexity. 318 319Commercial email filtering and abuse-detection services are powerful, but they often come with significant pricing and integration overhead. For a growing platform, it's easy to end up over-engineering or locking yourself into expensive dependencies too early. 320 321We wanted to be thoughtful about how we approached this. 322 323--- 324 325A layered approach: 326 327To ensure reliability and fast delivery for our current customers, we've already implemented paid, battle-tested solutions where it matters most. This guarantees that security and deliverability are not compromised while the platform continues to scale. 328 329At the same time, we've been evaluating several promising open-source tools that could complement or replace parts of this stack over time. These tools give us more control, transparency, and flexibility, especially as our needs evolve. 330 331The key areas we're focusing on: 332 333- Content filtering â Scanning for spam patterns, phishing attempts, and malicious links 334- Domain reputation monitoring â Tracking custom domain health and detecting compromised domains 335- Behavioral analysis â Identifying unusual sending patterns that might indicate account compromise 336- Rate limiting and throttling â Preventing abuse through programmatic controls 337- Real-time blocking â Stopping suspicious emails before they leave our infrastructure 338 339This hybrid approach allows us to maintain high security standards today while building toward a more flexible, cost-effective system tomorrow. 340 341--- 342 343Why this matters: 344 345Spam protection isn't just about stopping bad actors. It's about protecting the entire platform's reputation. 346 347If even a small percentage of emails sent through Keplars are flagged as spam or phishing, it can hurt deliverability for everyone. Mail providers penalize domains and IP addresses based on behavior patterns, and those penalties can cascade quickly. 348 349By investing in strong abuse prevention early, we're protecting: 350 351- Platform reputation with mail providers 352- Deliverability rates for all users 353- Trust in the Keplars brand 354- The long-term sustainability of the service 355 356--- 357 358Conclusion: 359 360Building spam protection into a transactional email platform is not a one-time project. It's an ongoing commitment to balancing security, usability, and cost. 361 362At Keplars, we're taking a pragmatic approach: use proven commercial solutions where they provide immediate value, while actively exploring open-source alternatives that give us more control and flexibility as we grow. 363 364The goal isn't just to prevent spam-it's to build a platform that users can trust, that mail providers respect, and that stays resilient as abuse tactics evolve. 365 366Transactional email is about reliability. And reliability includes making sure the platform can't be turned into a tool for harm. 367 368That's the kind of infrastructure we're building at Keplars: fast, secure, and thoughtfully designed for the long term.`,seoTitle:"How Keplars Protects Transactional Email from Spam and Abuse",seoDescription:"Keplars takes a layered approach to email security - combining content filtering, domain reputation monitoring, behavioral analysis, and real-time blocking to maintain high deliverability.",seoKeywords:["email spam protection","transactional email security","email abuse prevention","content filtering email","domain reputation monitoring","email deliverability","real-time email blocking","phishing email prevention","Keplars security","email platform protection"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Building Spam Protection into Transactional Email",description:"Keplars uses content filtering, domain reputation monitoring, behavioral analysis, and real-time blocking to protect transactional email infrastru
368cture from spam and abuse.",image:"https://cdn.keplersmail.com/blogs/spamprotection%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2025-12-30",dateModified:"2025-12-30",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/building-spam-protection-into-transactional-email"}}},{id:"6",title:"Moving from JSON to gRPC for Faster Internal Communication",slug:"moving-from-json-to-grpc-for-faster-internal-communication",excerpt:"While building Keplars Mail Service, latency quickly became a priority. As we benchmarked internal service-to-service communication, the results made one thing clear: JSON over REST was becoming a bottleneck.",date:"Jan 5, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/grpc%40300x.png",content:`For a long time, JSON has been our default choice for API responses. It's simple, widely understood, and works well for many use cases. 369 370However, while building Keplars Mail Service, latency quickly became a priority, especially as our architecture evolved into a semi-microservices setup. As we began benchmarking internal service-to-service communication using Apache JMeter, the results made one thing clear: JSON over REST was becoming a bottleneck. 371 372When simplicity meets scale: 373 374In a monolithic system, JSON-based APIs are often "good enough." But as services become more distributed, the cost of serialization, payload size, and network overhead starts to add up. 375 376Our benchmarks showed higher-than-expected response times between internal services. While nothing was broken, the system didn't feel as fast or efficient as we wanted it to be, especially for an infrastructure product where predictable performance matters. 377 378That pushed us to explore alternatives. 379 380--- 381 382Experimenting with gRPC and Protobuf: 383 384We started experimenting with gRPC and Protocol Buffers for internal APIs. The goal wasn't to replace everything overnight, but to validate whether a different communication model could meaningfully improve performance. 385 386The results were better than expected: 387 388- Latency dropped significantly 389- Payload sizes became much smaller 390- Serialization and deserialization overhead was reduced 391- Service-to-service communication felt noticeably faster and more consistent 392 393Even with a partial migration, the improvement was clear. 394 395--- 396 397A measured rollout: 398 399Not all internal APIs have been migrated yet, and that's intentional. gRPC introduces its own trade-offs, including tooling, debugging complexity, and stricter contracts. 400 401For Keplars, the current approach is pragmatic: 402 403- Use gRPC where performance and efficiency matter most 404- Keep simpler interfaces where JSON remains sufficient 405- Avoid unnecessary complexity unless there's a clear benefit 406 407This balance allows us to improve performance without sacrificing developer productivity. 408 409--- 410 411What this means for Keplars users: 412 413These changes happen entirely behind the scenes, but they directly support our core goals: 414 415- Faster internal processing 416- More predictable system behavior 417- Better performance as traffic grows 418 419It's another step toward keeping Keplars fast, reliable, and boring in the best possible way. 420 421--- 422 423Conclusion: 424 425Switching from JSON to gRPC for internal communication wasn't something we initially planned, but it's turned out to be a meaningful improvement. The performance gains, even from a partial adoption, have already justified the change. 426 427As we continue to evolve Keplars' architecture, we're staying focused on pragmatic improvements: migrate where it matters, keep things simple where possible, and always measure the impact. 428 429gRPC won't solve every performance problem, and it's not the right choice for every API. But for high-frequency, low-latency internal communication between services, the benefits are real and measurable. 430 431We'll continue expanding gRPC usage where it makes sense, while staying intentional about where complexity is introduced. 432 433We'd also love to hear from others who've made a similar move from JSON/REST to gRPC for internal systems. Learning from real-world experiences is always valuable. 434 435More engineering updates coming soon as we continue refining Keplars' core infrastru
435cture.`,seoTitle:"Why Keplars Switched from REST JSON to gRPC for Internal Service Communication",seoDescription:"Keplars replaced JSON over REST with gRPC and Protocol Buffers for internal APIs, delivering lower latency, smaller payloads, and faster service-to-service communication.",seoKeywords:["gRPC vs REST","gRPC Protocol Buffers","internal service communication","JSON to gRPC migration","microservices performance","low latency API","Keplars engineering","protobuf serialization","service-to-service communication","email infrastructure optimization"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Moving from JSON to gRPC for Faster Internal Communication",description:"Keplars replaced JSON over REST with gRPC and Protocol Buffers for internal APIs, delivering lower latency, smaller payloads, and faster service-to-service communication.",image:"https://cdn.keplersmail.com/blogs/grpc%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-01-05",dateModified:"2026-01-05",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/moving-from-json-to-grpc-for-faster-internal-communication"}}},{id:"7",title:"Launching an MVP: What to Build, What to Skip, and How Transactional Email Should Actually Be Handled",slug:"launching-an-mvp-what-to-build-what-to-skip",excerpt:"Launching an MVP is not about building everything. It is about building just enough to validate a real problem with real users. One of the most common examples of wasted effort? Transactional email infrastructure.",date:"Jan 10, 2026",author:"Ananya Singha RM",authorImage:"https://cdn.keplersmail.com/awesome-ananya.jpg",authorGithub:"https://github.com/awesome-ana",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/Asset%20145%40270x.png",content:`Launching an MVP is not about building everything. It is about building just enough to validate a real problem with real users. 436 437Yet many MVPs fail not because the idea was wrong, but because teams spent time and energy on things that were not critical at that stage. 438 439One of the most common examples of this is transactional email. 440 441What an MVP Should Optimize For (Technically): 442 443At an MVP stage, technical decisions should prioritize: 444 445- Speed of iteration 446- Low operational overhead 447- Clear failure visibility 448- Minimal setup cost 449- Easy rollback and change 450 451An MVP is not a production-scale system. It is a learning system. Anything that slows learning down should be questioned. 452 453--- 454 455Where Transactional Email Fits in an MVP? 456 457Transactional emails are unavoidable, even in the simplest MVP: 458 459- Signup confirmations 460- OTP or verification emails 461- Password reset emails 462- Account notifications 463 464These emails sit directly in the critical path of user experience. 465 466If they fail: 467 468- Users cannot log in 469- Users cannot recover accounts 470- Trust is lost immediately 471 472So transactional email cannot be ignored. 473 474But here's the key insight: 475 476Transactional email is critical, but email infrastructure management is not an MVP problem. 477 478--- 479 480The Common Mistake MVP Teams Make: 481 482Most teams treat transactional email as a one-time setup task. 483 484In reality, traditional platforms turn it into an infrastructure project: 485 486- DNS configuration (SPF, DKIM, DMARC) 487- SMTP tuning 488- Deliverability debugging 489- Rate limits and throttling 490- Spam classification issues 491- Reputation warm-up 492 493This work is: 494 495- Time-consuming 496- Hard to validate 497- Not core to product learning 498 499And worst of all, it does not help validate the MVP. 500 501--- 502 503The Right MVP Approach to Transactional Email: 504 505A technically sound MVP approach should: 506 507- Work immediately 508- Fail visibly 509- Require minimal configuration 510- Avoid coupling with marketing traffic 511- Allow deeper control later 512 513In other words: Start simple, scale responsibly. 514 515--- 516 517Where Keplars Fits (and Where It Doesn't)? 518 519Keplars Mail Service is designed specifically for transactional email, not marketing campaigns. 520 521What Keplars is good for at MVP stage: 522 523- Sending OTPs and auth emails immediately 524- Avoiding mandatory DNS setup on day one 525- Clean API and SMTP integration 526- Transactional-first routing 527- Predictable behavior under low to moderate volume 528- Clear error responses when something fails 529 530This aligns well with MVP needs: 531 532- Fast setup 533- Low cognitive load 534- No deliverability guesswork early on 535 536What Keplars does not force you to do: 537 538- You are not forced to configure custom domains upfront 539- You are not required to manage SPF/DKIM/DMARC on day one 540- You are not mixing transactional and marketing traffic 541 542Those controls are available when you need them, not before. 543 544--- 545 546Is It Good or Bad to Use Keplars Mail Service for an MVP? 547 548Short answer: Yes, it is good - if your goal is to move fast without sacrificing reliability. 549 550Long answer: Using Keplars during an MVP is a strategic decision, not a shortcut. 551 552It lets teams: 553
554- Defer infrastructure complexity 555- Validate product flows first 556- Introduce deeper email controls only after traction 557 558This approach reflects a core MVP principle: solve the problem first, optimize the solution later. 559 560--- 561 562Conclusion: 563 564Building an MVP is about validating assumptions as quickly as possible. Every hour spent on infrastructure that doesn't directly support that validation is a distraction. 565 566Transactional email is critical to user experience, but managing email infrastructure is not an MVP-stage problem worth solving yourself. 567 568Keplars Mail Service exists specifically to handle this: give you reliable transactional email without forcing you into infrastructure management prematurely. 569 570Use it to ship faster. Validate your product. Add complexity only when it serves your users, not before. 571 572The best MVP decisions are the ones that let you focus on what actually matters: learning whether your product solves a real problem. 573 574Everything else can wait.`,seoTitle:"Transactional Email for MVPs: What to Build, What to Skip",seoDescription:"Building an MVP? Transactional email is critical but managing email infrastructure isn't. Learn why Keplars helps fast-moving teams ship reliable email without the setup complexity.",seoKeywords:["transactional email MVP","startup email infrastructure","email API for startups","MVP email setup","fast email integration","OTP email startup","Keplars email API","email without SMTP","ship fast email","developer email tools"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Launching an MVP: What to Build, What to Skip, and How Transactional Email Should Actually Be Handled",description:"Building an MVP? Transactional email is critical but managing email infrastructure isn't. Learn why Keplars helps fast-moving teams ship reliable email without setup complexity.",image:"https://cdn.keplersmail.com/blogs/Asset%20145%40270x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-01-10",dateModified:"2026-01-10",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/launching-an-mvp-what-to-build-what-to-skip"}}},{id:"8",title:"Making Database Migrations Predictable",slug:"making-database-migrations-predictable",excerpt:"As Keplars Mail Service moves deeper into a semi-microservices architecture, some challenges show up faster than expected. One of the earliest and most persistent ones for us was database migrations.",date:"Jan 12, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/bytebase%40300x.png",content:`As Keplars Mail Service moves deeper into a semi-microservices architecture, some challenges show up faster than expected. One of the earliest and most persistent ones for us was database migrations. 575 576In the early days, we shared a single database instance across services. That approach worked while the system was small and tightly coupled. But as services grew and responsibilities became clearer, managing ORMs, schema ownership, and migrations across multiple services quickly became painful. 577 578Coordinating schema changes was slow, error-prone, and difficult to reason about. Small changes required careful sequencing, cross-team awareness, and too much manual verification. Over time, migrations became a source of friction rather than a routine operation. 579 580Rethinking how migrations are handled: 581 582It became clear that database migrations needed the same level of structure and ownership as application code. 583 584After exploring different approaches, we decided to separate database migrations into a dedicated service and introduce a more disciplined workflow around schema changes. This led us to adopt Bytebase to manage database migrations and access control. 585 586--- 587 588Why this approach worked: 589 590Treating database changes like code turned out to be a game changer. 591 592With a Git-like workflow for migrations, we gained: 593 594- Clear ownership of schema changes 595- Auditability of every migration 596- Safer coordination across services 597- Predictable rollout of database updates 598 599Instead of migrations being a high-stress event, they became reviewable, traceable, and repeatable. 600 601--- 602 603Impact on our architecture: 604 605This change brought much-needed clarity to how schemas evolve as services change. Each service now interacts with a well-defined database layer, and migrations follow a controlled, observable process. 606 607Most importantly, it removed a major source of operational uncertainty as the system continues to grow. 608 609--- 610 611A note on tooling: 612 613To be clear, we're not affiliated with Bytebase in any way, nor is this a promotion. It simply solved a specific problem we had: making database changes predictable and safe in a distributed system. 614 615Other tools exist that solve similar problems. The key insight isn't the specific tool, but the principle: 616 617Database migrations should be treated with the same rigor as application deployments. 618 619--- 620 621Conclusion: 622 623As systems move from monoliths to distributed architectures, database migrations often become a bottleneck. What used to be a simple script run by one person becomes a coordination problem across teams and services. 624 625At Keplars, making migrations predictable meant treating them as first-class infrastru
625cture concerns, not afterthoughts. 626 627By introducing structured workflows, version control, and clear ownership, we turned migrations from a source of anxiety into a routine, reliable process. 628 629If you're building a system that's growing beyond a single database, invest in migration discipline early. The coordination overhead only gets worse as the system scales. 630 631Infrastructure should be boring. Migrations are no exception.`,seoTitle:"Making Database Migrations Safe and Predictable at Keplars | Engineering",seoDescription:"Keplars adopted Bytebase to bring Git-like workflows to database migrations, improving schema ownership, auditability, and safe deployment across a distributed architecture.",seoKeywords:["database migrations","Bytebase","database schema management","Git-like migrations","safe database deployments","schema ownership","distributed database","Keplars engineering","migration workflow","database auditability"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Making Database Migrations Predictable",description:"Keplars adopted Bytebase to bring Git-like workflows to database migrations, improving schema ownership, auditability, and safe rollout across a distributed architecture.",image:"https://cdn.keplersmail.com/blogs/bytebase%40300x.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-01-12",dateModified:"2026-01-12",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/making-database-migrations-predictable"}}},{id:"9",title:"Why We're Moving from Redis to Valkey at Keplars",slug:"moving-from-redis-to-valkey-at-keplars",excerpt:"At Keplars, performance and reliability are not optional. We've decided to migrate from Redis to Valkey - a deliberate step based on performance, architecture, and long-term ecosystem alignment.",date:"Apr 19, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/redistovalkeyblog.png",content:`At Keplars, performance and reliability are not optional. 632They are core to how we build our email infrastructure. 633 634Over the past few months, we've been re-evaluating parts of our stack to ensure we're aligned with long-term scalability, performance, and openness. One of those decisions was around our in-memory data layer. 635 636We've decided to migrate from Redis to Valkey. 637 638This wasn't a reactive decision. It was a deliberate step based on performance, architecture, and long-term ecosystem alignment. 639 640The Context 641 642Redis has been a foundational technology for years. 643It's fast, reliable, and deeply integrated into modern systems. 644 645However, recent changes around licensing and governance have shifted how teams evaluate its long-term fit, especially for infrastru
645cture-heavy products. 646 647At the same time, Valkey has emerged as a strong alternative. 648 649What is Valkey? 650 651Valkey is a fully open-source fork of Redis, released under the BSD 3-Clause license and backed by a growing open-source community. 652 653It maintains compatibility with Redis APIs, which makes migration straightforward, while introducing improvements in performance and system efficiency. 654 655Why We're Choosing Valkey 656 6571. Multi-threaded Architecture 658 659One of the biggest limitations of Redis is its single-threaded execution model for command processing. 660 661Valkey introduces multi-threaded I/O and execution capabilities, allowing better utilization of modern multi-core systems. 662 663For a system like Keplars, where throughput and concurrency matter, this directly translates to: 664 665- Higher parallel processing capacity 666- Better CPU utilization 667- Improved scalability under load 668 6692. Better Memory Efficiency 670 671Memory management plays a critical role in systems handling high-volume, real-time workloads. 672 673Valkey brings improvements in how memory is handled internally, resulting in: 674 675- More efficient memory usage 676- Reduced overhead under heavy workloads 677- Better predictability in performance 678 679This is especially important for us as we scale email events, delivery states, and real-time tracking data. 680 6813. Open Licensing & Long-Term Flexibility 682 683Redis has transitioned to a more restrictive, commercial-friendly license model. 684 685While it remains usable, the shift introduces considerations around: 686 687- Vendor lock-in 688- Contribution model changes 689- Long-term ecosystem control 690 691Valkey, on the other hand, is: 692 693- Fully open-source (BSD 3-Clause) 694- Community-driven 695- Self-host friendly without restrictions 696 697For Keplars, this aligns better with how we think about infrastructure: open, flexible, and not dependent on licensing constraints. 698 6994. Higher Throughput, Lower Latency 700 701Performance benchmarks show that Valkey can achieve: 702 703- Up to ~230% higher throughput 704- Lower latency under concurrent workloads 705 706For an email infrastructure platform, this matters directly: 707 708- Faster event processing 709- More reliable delivery pipelines 710- Better real-time analytics 711 712This allows us to maintain responsiveness even as usage scales. 713 714What This Means for Keplars 715 716This migration is not just a backend change. It directly impacts the experience we provide: 717 718- More consistent performance under load 719- Faster processing of email events 720- Better scalability as we grow 721- Stronger alignment with open infrastructure 722 723Most importantly, it ensures that we are building on a foundation that is both technically robust and future-proof. 724 725Final Thoughts 726 727Redis has played a significant role in shaping modern infrastructure, and it continues to be a strong technology. 728 729But as systems evolve, so do the requirements around performance, scalability, and openness. 730 731Valkey represents a direction that aligns closely with how we want to build Keplars: 732 733- High-performance 734- Transparent 735- Community-driven 736- Built for long-term scale 737 738We're excited about this shift and what it enables going forward.`,seoTitle:"Why Keplars Is Migrating from Redis to Valkey | Engineering at Keplars",seoDescription:"Keplars is moving from Redis to Valkey for multi-threaded performance, better memory efficiency, BSD 3-Clause licensing, and up to 230% higher throughput in our email infrastructure.",seoKeywords:["Redis to Valkey migration","Valkey vs Redis","Valkey BSD 3-Clause","open source Redis alternative","Valkey multi-threaded","email infrastructure performance","Keplars engineering","in-memory data store","Redis licensing","Valkey throughput"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Why We're Moving from Redis to Valkey at Keplars",description:"Keplars is migrating from Redis to Valkey for multi-threaded performance, better memory efficiency, BSD 3-Clause open-source licensing, and up to 230% higher throughput.",image:"https://cdn.keplersmail.com/blogs/redistovalkeyblog.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-04-19",dateModified:"2026-04-19",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/moving-from-redis-to-valkey-at-keplars"}}},{id:"10",title:"Why We Built Our Own Email Validator: Introducing Pluto",slug:"why-we-built-our-own-email-validator-introducing-pluto",excerpt:"Poor email data quality quietly destroys deliverability before a single message is sent. After testing numerous third-party validators that couldn't reliably confirm mailbox existence, we built our own - Pluto.",date:"May 30, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/pluto.png",content:`Email deliverability starts long before an email is sent. 739
740Most teams focus on infrastructure, domain reputation, authentication records, and content optimization. While those are all important, there's another problem that quietly destroys deliverability and campaign performance: 741 742**Poor email data quality.** 743 744At Keplars, email validation is a critical part of our communication infrastructure. Before building our own validator, we evaluated and used multiple third-party validation providers. They worked reasonably well for basic checks, but we consistently ran into the same challenge - many platforms were unable to reliably determine whether an email address was actually capable of receiving mail. 745 746For us, that wasn't good enough. 747 748When sending transactional emails, onboarding sequences, marketing campaigns, or automated workflows, every invalid email address affects several areas. 749 750- Deliverability rates 751- Sender reputation 752- Bounce rates 753- Campaign performance 754- Infrastructure costs 755 756After testing numerous solutions and validation approaches, we decided to build our own. 757 758That project eventually became **Pluto**. 759 760The Problem with Traditional Validation: 761 762Most email validation tools stop at basic checks such as email format validation, domain existence, MX record lookup, and disposable email detection. 763 764While useful, these checks alone don't provide enough confidence that an address is truly valid. The format may be correct, the domain may exist, and MX records may be configured correctly - but none of those checks guarantee that the mailbox itself is valid or deliverable. 765 766We needed something more comprehensive. 767 768Building Pluto: 769 770Pluto was developed internally using Go to provide fast, scalable, and highly accurate email validation. 771 772The objective was simple: validate email addresses as thoroughly as possible before they ever enter our sending pipeline. 773 774Rather than relying on a single signal, Pluto combines multiple validation layers into a unified scoring and verification process. 775 776 777 778What Pluto Checks: 779 780RFC Compliance: 781 782Every email address is validated against RFC standards to ensure it follows proper formatting rules, including local-part validation, domain validation, character restrictions, and length requirements. 783 784--- 785 786Length Limit Validation: 787 788Many validation systems ignore practical mailbox limitations. Pluto verifies local-part length, domain length, and overall email length against accepted standards. 789 790--- 791 792Internationalized Domains (IDN): 793 794Modern email systems increasingly support internationalized domain names. Pluto validates Unicode domains, IDN domains, and Punycode conversions, ensuring compatibility across global email providers. 795 796--- 797 798DNS and MX Validation: 799 800A valid domain should be capable of receiving mail. Pluto performs DNS lookups, MX record validation, and domain routing verification before proceeding further. 801 802--- 803 804Disposable Email Detection: 805 806Temporary email services create significant challenges for many applications. Pluto maintains a database of **5,000+ known disposable and throwaway email providers** and continuously checks addresses against them. 807 808--- 809 810Role-Based Email Detection: 811 812Role accounts often indicate shared inboxes rather than actual users. Pluto identifies and flags these addresses appropriately. 813 814\`\`\`text 815admin@ 816support@ 817sales@ 818contact@ 819info@ 820\`\`\` 821 822--- 823 824Free Provider Detection: 825 826We also identify major consumer providers including Gmail, Outlook, Yahoo, iCloud, ProtonMail, and many others. This allows systems to distinguish between business and personal email addresses when necessary. 827 828--- 829 830Alias Normalization: 831 832Email aliases create another layer of complexity. For example, the following addresses often resolve to the same mailbox. 833 834\`\`\`text 835[email protected] 836[email protected] 837[email protected] 838\`\`\` 839 840Pluto performs provider-specific normalization for Gmail dot aliases, Gmail plus tags, Yahoo aliases, iCloud aliases, and additional provider-specific behaviors. This significantly improves duplicate detection and data cleanliness. 841 842--- 843 844Typo Detection: 845 846A surprisingly high percentage of invalid emails are caused by simple typing mistakes. Pluto automatically identifies common domain typos and provides suggested corrections. 847 848\`\`\`text 849gmai.com 850gmial.com 851outlok.com 852yahho.com 853\`\`\` 854 855--- 856 857Reputation Analysis: 858 859Beyond mailbox validation, Pluto evaluates domain reputation signals including SPF records, DMARC records, DNS reputation indicators, DNSBL checks, and DBL checks. This provides additional insight into the overall quality of the sender domain. 860 861--- 862 863Batch Domain Validation: 864 865For larger datasets, Pluto performs validation at scale, enabling bulk email verification, lead list cleaning, campaign preparation, and data quality audits without sacrificing accuracy. 866 867 868 869--- 870 871SMTP Mailbox Verification: 872 873One of the most important layers. Pluto performs mailbox-level SMTP verification where supported, helping determine whether the destination mailbox actually exists and is capable of receiving mail. 874 875While no validation system can guarantee 100% accuracy due to provider-specific protections and anti-abuse mechanisms, mailbox verification dramatically improves confidence compared to format-only validation. 876 877The Results: 878 879After implementing Pluto into our internal workflows, validation accuracy improved significantly. We became far more confident in the quality of email data entering our communication infrastru
879cture. 880 881This translated into several key benefits. 882 883- Better deliverability 884- Lower bounce rates 885- Cleaner datasets 886- Improved sender reputation 887- More reliable automation workflows 888 889Today, Pluto helps us achieve over **90% validation accuracy** across our internal validation pipeline. 890 891Why the Name Pluto? 892 893At Keplars, many of our internal systems follow a space-themed naming convention. Since this validator quietly operates in the background while helping navigate email quality across the ecosystem, Pluto felt like the perfect fit. Small. Fast. Reliable. And constantly working behind the scenes. 894 895What's Next? 896 897Today, Pluto remains an internal tool used by the Keplars team. We continue improving validation accuracy, detection systems, reputation analysis, disposable provider coverage, and mailbox verification logic. 898 899As our email infrastructure platform grows, Pluto continues to play a critical role in helping maintain high-quality communication data. 900 901Because in email infrastructure, what happens before sending is often just as important as what happens after.`,seoTitle:"Why We Built Our Own Email Validator: Introducing Pluto | Keplars Engineering",seoDescription:"Keplars built Pluto, an internal Go-based email validator covering RFC compliance, disposable detection, alias normalization, SMTP mailbox verification, and more - achieving 90%+ validation accuracy.",seoKeywords:["email validator","email validation","Pluto email validator","disposable email detection","SMTP mailbox verification","alias normalization","RFC email compliance","typo detection email","domain reputation email","Go email validation"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Why We Built Our Own Email Validator: Introducing Pluto",de
901scription:"Keplars built Pluto, an internal Go-based email validator with RFC compliance, disposable detection, alias normalization, SMTP mailbox verification, and 90%+ validation accuracy.",image:"https://cdn.keplersmail.com/blogs/pluto.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-30",dateModified:"2026-05-30",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/why-we-built-our-own-email-validator-introducing-pluto"}}},{id:"11",title:"We Didn't Replace BullMQ Because It Was Bad. We Replaced It Because We Outgrew It.",slug:"we-didnt-replace-bullmq-because-it-was-bad-we-replaced-it-because-we-outgrew-it",excerpt:"BullMQ powered our email pipeline reliably for years, but as Keplars grew into a distributed systems problem, we found ourselves building more infrastructure around the queue than the queue itself. Here's why we migrated to Restate.dev.",date:"Aug 3, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Engineering",image:"https://cdn.keplersmail.com/blogs/restateblog_thumbnail.png",content:`When engineers talk about scaling systems, the conversation usually revolves around databases, caches, or Kubernetes. 902 903Rarely does anyone talk about the queue. 904 905But if you're building an email platform, the queue **is** the product. 906 907Every OTP, password reset, invoice, notification, or marketing campaign eventually becomes a queued job. And once you're processing thousands-or millions-of these jobs, reliability stops being a feature and becomes the entire business. 908 909At **Keplars**, our email delivery pipeline has been powered by **BullMQ** for a long time. 910 911It's fast, mature, reliable, and honestly one of the best queueing libraries in the Node.js ecosystem. 912 913So why are we migrating to **Restate.dev**? 914 915The answer isn't because BullMQ failed us. 916 917It's because our architecture evolved. 918 919--- 920 921## BullMQ Was Never the Problem 922 923BullMQ solved exactly what it promised to solve. 924 925It gave us queues, retries, delayed jobs, priorities, concurrency controls, and a robust execution engine that helped us build a reliable email pipeline. 926 927For many applications, that's more than enough. 928 929But building an email infrastructure platform introduces challenges that aren't really "queue problems." 930 931They're **distributed systems problems.** 932 933As our platform grew, our queue slowly became surrounded by infrastructure. 934 935We started building systems for: 936 937* Retry policies 938* Crash recovery 939* Idempotency 940* Stateful workflows 941* Long-running executions 942* Scheduled operations 943* Provider failover 944* Duplicate prevention 945* Distributed coordination 946 947None of those features were technically part of BullMQ. 948 949They were things **we** had to build around it. 950 951And eventually, we realized something. 952 953We were spending almost as much time building the infrastructure **around** the queue as we were building the actual email platform. 954 955--- 956 957## The Moment It Clicked 958 959One question kept coming up during architecture discussions: 960 961"If this worker crashes halfway through the workflow... what happens?" 962 963It sounds like a simple question. 964 965But answering it isn't. 966 967You have to know: 968 969* Which steps already completed 970* Which API calls succeeded 971* Which emails were already sent 972* Which database writes happened 973* Which retries are still pending 974* Whether we can safely resume 975* Whether this creates duplicate emails 976 977Every distributed system eventually has to answer these questions. 978 979We just realized we didn't want to answer them manually anymore. 980 981--- 982 983## Why Restate.dev Felt Different 984 985When we started experimenting with Restate, what stood out wasn't performance. 986 987It was the programming model. 988 989Instead of thinking in terms of queue jobs, retries, timers, distributed state, and recovery mechanisms... 990 991...you simply write a workflow. 992 993Every step is durably persisted. 994 995If a process crashes after step seven out of ten, execution doesn't restart from the beginning. 996 997It simply continues from step eight. 998 999No custom recovery code. 1000 1001No rebuilding state. 1002 1003No "did this already execute?" logic scattered throughout the application. 1004 1005That changes how you design software. 1006 1007--- 1008 1009## Our Email Pipeline Looks Different Now 1010 1011Instead of individual jobs triggering other jobs, we can express the entire lifecycle as a single durable workflow. 1012 1013Something like this: 1014 1015\`\`\`text 1016Receive Email Request 1017 â 1018Validate Payload 1019 â 1020Render Template 1021 â 1022Resolve Assets 1023 â 1024Choose Provider 1025 â
1026Send Email 1027 â 1028Wait for Delivery Events 1029 â 1030Update Status 1031 â 1032Retry (if needed) 1033 â 1034Trigger Automations 1035\`\`\` 1036 1037Each step becomes durable. 1038 1039Each transition is tracked. 1040 1041Recovery is automatic. 1042 1043The workflow itself becomes the source of truth. 1044 1045--- 1046 1047## Less Infrastructure. More Product. 1048 1049One of the biggest benefits isn't speed. 1050 1051It's simplicity. 1052 1053Previously, we spent engineering effort on questions like: 1054 1055* How retries should be stored 1056* How to resume interrupted jobs 1057* How to prevent duplicate execution 1058* How to coordinate workers across multiple instances 1059* How to maintain workflow state during failures 1060 1061Those are important problems. 1062 1063They're also problems we'd rather not own. 1064 1065Restate moves many of those responsibilities into the runtime. 1066 1067That means our engineering team spends more time improving email infrastructure and less time maintaining workflow infrastructure. 1068 1069--- 1070 1071## What This Means for Our Customers 1072 1073Most Keplars users probably won't notice this migration. 1074 1075And honestly... 1076 1077That's exactly how infrastructure should work. 1078 1079There won't be a shiny new dashboard. 1080 1081There won't be a flashy button. 1082 1083Instead, they'll experience: 1084 1085* Better reliability 1086* More predictable email processing 1087* Improved recovery from failures 1088* Fewer duplicate sends 1089* Faster rollout of new platform capabilities 1090 1091Sometimes the biggest improvements are completely invisible. 1092 1093--- 1094 1095## The Bigger Lesson 1096 1097One thing I've learned while building infrastructure products is this: 1098 1099The tools that get you from **0 to 1** aren't always the tools that get you from **1 to 100**. 1100 1101BullMQ helped us build an incredible foundation. 1102 1103We're grateful for it. 1104 1105But architecture isn't about choosing the "best" technology. 1106 1107It's about choosing the right abstraction for where your product is today. 1108 1109For us, durable workflows have become a better abstraction than traditional queue jobs. 1110 1111--- 1112 1113## Looking Ahead 1114
1115Infrastructure migrations rarely make headlines. 1116 1117Customers don't wake up excited because you replaced your queue engine. 1118 1119But these are often the decisions that determine whether a platform can scale for the next five years. 1120 1121BullMQ helped us build a reliable foundation. 1122 1123Restate.dev gives us a simpler model for building resilient, stateful workflows while reducing the operational complexity that comes with managing distributed systems. 1124 1125We're excited to build the next generation of Keplars on top of it. 1126 1127If you're building distributed systems, workflow engines, or large-scale queueing infrastructure, I'd love to hear what challenges you've faced and whether you've explored durable execution models like Restate.`,seoTitle:"Why Keplars Migrated From BullMQ to Restate.dev for Durable Workflows",seoDescription:"Keplars moved its email delivery pipeline from BullMQ to Restate.dev, replacing custom retry, recovery, and idempotency infrastructure with durable workflow execution.",seoKeywords:["BullMQ","Restate.dev","durable execution","workflow engine","distributed systems","queue infrastructure","email infrastructure engineering","idempotency","workflow orchestration","Node.js queues"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"We Didn't Replace BullMQ Because It Was Bad. We Replaced It Because We Outgrew It.",description:"Keplars moved its email delivery pipeline from BullMQ to Restate.dev, replacing custom retry, recovery, and idempotency infrastructure with durable workflow execution.",image:"https://cdn.keplersmail.com/blogs/restateblog_thumbnail.png",author:{"@type":"Person",name:"Debojyoti Singha",url:"https://www.linkedin.com/in/debojyoti452/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-08-03",dateModified:"2026-08-03",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/we-didnt-replace-bullmq-because-it-was-bad-we-replaced-it-because-we-outgrew-it"}}}],m=[{id:"c1",title:"Stop Rebuilding Contact Forms in Every Next.js Project",slug:"stop-rebuilding-contact-forms-nextjs",excerpt:"If you've ever started a new Next.js project and thought, \"I just need a simple contact form,\" you know it's really never that simple. That's why I built the Keplars Next.js Contact Form Starter.",date:"Jan 15, 2026",author:"Joseph Jonah",authorImage:"https://cdn.keplersmail.com/keplars-testimonials/jonah.png",authorLink:"https://www.linkedin.com/in/inalegwu-joseph-jonah/",authorGithub:"https://github.com/JOSEPH-Inalegwu/kepler-nextjs-starter",category:"Community",image:"https://pub-db75309f5c8c45f9baccc2b225afc7ad.r2.dev/blogs/communityblog_one_image.png",content:`If you've ever started a new Next.js project and thought, "I just need a simple contact form," you know it's really never that simple. 1128 1129You end up rebuilding the same stuff every time: the form UI, loading states, success messages, validation, and a way to actually send emails without exposing your API keys. 1130 1131That's why I built the Keplars Next.js Contact Form Starter. 1132 1133You copy a few files, add your Keplars API key, and you're done. After that, you can tweak the UI to match your style without dealing with form libraries you don't need. 1134 1135- [Live demo](https://keplars-nextjs-starter.vercel.app/) 1136- [Keplars](https://keplars.com/) 1137 1138--- 1139 1140**Why I used Keplars for this starter** 1141 1142Keplars is built for developers who want to send emails without the complex setup. 1143 1144But here's the real reason I picked it for this starter: if you can build a contact form with Keplars, you already know how to handle all your product emails. 1145 1146Once you get this working, you can use the same approach for: 1147 1148- OTP codes and verification emails 1149- Password resets 1150- Order confirmations 1151- Welcome emails 1152- Notifications 1153 1154The integration is smooth, and you're not locked into some complicated email service. You learn it once with this contact form, then you use it everywhere in your product. 1155 1156Plus, Keplars gives you email templates you can customize, or you can just describe what you want in natural language, and AI drafts the template for you. No more writing HTML emails from scratch. 1157 1158And with built-in analytics and reporting, you can easily confirm your emails are going through while you're testing. 1159 1160--- 1161 1162**What we're building** 1163 1164By the end of this, you'll have a working contact form in your Next.js App Router project that sends emails using Keplars. 1165 1166You'll also get: 1167
1168- Loading states and success/error feedback 1169- Basic bot protection (honeypot field) 1170- No heavy form libraries 1171 1172Most importantly, you own the code. You can copy it into your next project and restyle it however you want. 1173 1174--- 1175 1176**What you need before starting** 1177 1178- A Next.js project (App Router) 1179- A Keplars account + API key 1180- Node.js installed 1181- A .env.local file in your project 1182 1183**Optional**: A Discord webhook URL, if you want instant notifications when someone submits the form 1184 1185--- 1186 1187Step 1: Get your Keplars API key 1188 1189To send emails, you need a Keplars account and an API key. 1190 1191We'll store it server-side so it never gets exposed to the browser. 1192 1193**What to do:** 1194 11951. Go to [keplars.com](https://keplars.com/) and create an account 11962. Generate an API key from your dashboard 11973. Copy the key somewhere safe, as you'll need it in the next step 1198 1199**Why this matters:** This API key is how your Next.js server talks to Keplars to send the email after someone submits your form. 1200 1201--- 1202 1203Step 2: Add your environment variables 1204 1205Now we'll store your Keplars API key and the email that should receive contact messages in a .env.local file. 1206 1207This keeps your secrets safe and makes it easy to swap keys later without touching your code. 1208 1209**Create .env.local:** 1210 1211In your project root (same level as package.json), create a file named .env.local and add your KEPLARS_API_KEY and CONTACT_EMAIL. 1212 1213**Quick checks:** 1214 1215- Restart your dev server after adding these 1216- Don't commit .env.local to GitHub 1217- Make sure CONTACT_EMAIL is a real inbox you can test 1218 1219--- 1220 1221Step 3: Copy the starter files into your project 1222 1223Now you'll copy the starter kit files into your Next.js project. 1224 1225No package installs, no setup, just code you can read and edit. 1226 1227**Copy these files from the starter repo:** 1228 1229**Logic (server + types):** 1230- types/index.ts 1231- lib/keplars.ts 1232- app/actions.ts 1233 1234**UI components:** 1235- components/keplars/ (the contact form, submit button, and toast UI) 1236 1237**What each part does:** 1238- app/actions.ts: Server Actions that handle the submit and call Keplars 1239- lib/keplars.ts: Simple Keplars API wrapper 1240- components/keplars/*: The UI you'll customize 1241 1242--- 1243 1244Step 4: Drop the form into your page 1245 1246Create a page (or use an existing one) and render the form component. 1247 1248 1249 1250**Note:** If your project doesn't use the @/ import alias, just use a relative path like ../../components/keplars/contact-form. 1251 1252--- 1253 1254Step 5: Test it locally 1255 1256Time to make sure everything works. 1257 1258**Checklist:** 1259 12601. Start your dev server 12612. Open the contact page in your browser 12623. Submit a test message 12634. Confirm: 1264 - You see a success message 1265 - The email arrives at your CONTACT_EMAIL 1266 1267**If it fails, check these:** 1268 1269- KEPLARS_API_KEY is missing or wrong in .env.local 1270- You didn't restart the server after adding the env vars 1271- CONTACT_EMAIL isn't a real inbox 1272 1273--- 1274 1275Optional: Add Discord/Slack notifications 1276 1277If you want instant notifications when someone submits the form, add a webhook. 1278 1279**Steps:** 1280 12811. Create a webhook in Discord (or Slack) and copy the URL 12822. Add it to .env.local as DISCORD_WEBHOOK_URL 12833. Submit the form again and confirm that you get the notification 1284 1285--- 1286 1287**How spam protection works** 1288 1289This starter uses a honeypot. It's a hidden field that real people won't fill, but bots will. 1290 1291If that hidden field has a value, we treat it as spam. No annoying CAPTCHA needed. 1292 1293--- 1294 1295**Make it match your style** 1296 1297This is where form libraries usually get annoying. With this starter, it's simple. 1298 1299**Easy changes:** 1300 1301- Update Tailwind classes in components/keplars/contact-form.tsx to match your brand or project 1302- Add or remove fields and update the types in types/index.ts 1303- Don't want toast notifications? Remove them and show inline success/error text instead 1304 1305**One rule:** Never move the email-sending logic to the client-keep it in the server action so your API key stays private. 1306 1307--- 1308 1309**Deploying** 1310 1311When you deploy (Vercel or wherever), add the same environment variables in your hosting dashboard. 1312 1313After deploying, submit a test message to confirm production delivery works. 1314 1315**Demo Mode (for public demos):** 1316 1317I added a Demo Mode feature to the starter so my live demo doesn't flood my inbox with test submissions. 1318 1319When NEXT_PUBLIC_DEMO_MODE is set to "true", the form pretends to send the email (with a fake 1-second delay) but doesn't actually call Keplars. 1320 1321 1322**To enable Demo Mode on Vercel (or your hosting platform):** 1323 13241. Go to your project settings 13252. Add NEXT_PUBLIC_DEMO_MODE as an environment variable 13263. Set it to "true" 13274. Redeploy 1328 1329You'll see this in the code. Remove it for your actual projects (or just don't set the env var) or you'll wonder why emails aren't sending. 1330 1331I only use it for the [live demo](https://keplars-nextjs-starter.vercel.app/), so random people testing it don't spam my inbox. 1332 1333--- 1334 1335That's it 1336 1337You now have a production-ready contact form you can reuse by copying a few files, adding your Keplars key, and styling it however you want. 1338 1339**Ideas for later:** 1340 1341- Add rate limiting for extra bot protection 1342- Store submissions in a database 1343- Add file upload support 1344 1345If this helped you ship faster, leave a star on [GitHub](https://github.com/JOSEPH-Inalegwu/kepler-nextjs-starter) - it helps more people find it.`,seoTitle:"Reusable Next.js Contact Form with Keplars Email API | Open Source Starter",seoDescription:"Stop rewriting contact forms in every Next.js project. This open-source Keplars starter gives you a production-ready form with email sending, bot protection, and Discord notifications.",seoKeywords:["Next.js contact form","email form Next.js","Keplars API integration","reusable contact form","Next.js App Router email","open source email starter","honeypot spam protection","send email Next.js","contact form template","developer email tools"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Stop Rebuilding Contact Forms in Every Next.js Project",description:"A reusable Next.js contact form starter powered by the Keplars email API, with bot protection, Discord notifications, and zero heavy depen
1345dencies.",image:"https://pub-db75309f5c8c45f9baccc2b225afc7ad.r2.dev/blogs/communityblog_one_image.png",author:{"@type":"Person",name:"Joseph Jonah",url:"https://www.linkedin.com/in/inalegwu-joseph-jonah/"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-01-15",dateModified:"2026-01-15",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/stop-rebuilding-contact-forms-nextjs"}}}],d=[{id:"p1",title:"Introducing Multi-Region Email Sending in Keplars",slug:"multi-region-email-sending",excerpt:"Email delivery is now processed across multiple geographic regions, helping reduce latency, improve reliability, and provide stronger infrastructure resilience for applications sending email globally.",seoTitle:"Multi-Region Email Sending in Keplars | Faster Global Email Delivery",seoDescription:"Keplars now supports multi-region email sending with regions in Singapore, Cape Town, and North Virginia, improving latency, reliability, and global email delivery performance.",seoKeywords:["multi-region email sending","global email delivery","email latency reduction","Singapore email region","Cape Town email region","North Virginia email","email infrastructure regions","Keplars multi-region","transactional email global","email delivery performance"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Multi-Region Email Sending Is Now Available in Keplars",description:"Keplars now supports multi-region email sending with regions in Singapore, Cape Town, and North Virginia, improving latency and global email delivery reliability.",image:"https://keplars.com/images/blog/multi-region-email.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-03-01",dateModified:"2026-03-01",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/multi-region-email-sending"}},date:"Mar 1, 2026",author:"Ananya Singha RM",authorImage:"https://cdn.keplersmail.com/awesome-ananya.jpg",authorGithub:"https://github.com/awesome-ana",category:"Product",image:"https://cdn.keplersmail.com/blogs/muti-region-demo-screenshot4.png",content:`We're introducing multi-region email sending in Keplars. 1346 1347Email delivery is now processed across multiple geographic regions, helping reduce latency, improve reliability, and provide stronger infrastructure resilience for applications sending email globally. 1348 1349For many products, email is part of critical workflows. Authentication links, password resets, notifications, and transactional updates often need to arrive instantly. When email infrastructure is located far from users, network latency can increase and delivery performance may suffer. 1350 1351Multi-region email sending helps solve this by allowing email traffic to be processed closer to where applications and users are located. 1352 1353--- 1354 1355Multi-Region Configuration in the Dashboard: 1356 1357Keplars allows developers to configure email delivery regions directly from the dashboard. 1358 1359This makes it possible to route email traffic through the region closest to your users or application infrastructure, improving overall delivery performance. 1360 1361 1362 1363--- 1364 1365Available Regions: 1366 1367Keplars currently supports email delivery through the following regions: 1368 1369- APAC (Singapore) 1370- Africa (Cape Town) 1371- US (North Virginia) 1372 1373These regions allow Keplars to process email delivery closer to global user bases, helping reduce network distance between sending infrastructure and receiving mail servers. 1374 1375As a result, emails can reach inboxes faster and more consistently. 1376 1377--- 1378 1379Why Multi-Region Email Sending Matters: 1380 1381Lower latency: 1382 1383When emails are sent from infrastructure closer to the recipient, network latency decreases. This improves time-to-inbox, which is especially important for time-sensitive workflows like authentication or verification emails. 1384 1385Greater reliability: 1386
1387Multi-region infrastructure reduces dependency on a single geographic location. Distributing email traffic across regions improves platform resilience and helps maintain consistent delivery performance. 1388 1389Global scalability: 1390 1391Modern applications serve users across continents. Multi-region email sending ensures your email infrastructure can support globally distributed users and workloads without performance bottlenecks. 1392 1393 1394 1395--- 1396 1397Designed for Global Applications: 1398 1399Applications today are rarely limited to a single region. SaaS platforms, consumer applications, and developer tools often serve users worldwide. 1400 1401Multi-region email sending in Keplars ensures that email delivery infrastructure can scale with global applications while maintaining strong performance and reliability. 1402 1403--- 1404 1405Continuing to Improve the Platform: 1406 1407Multi-region support is part of our ongoing work to strengthen the infrastructure powering Keplars. 1408 1409We'll continue investing in platform improvements that enhance performance, reliability, and developer experience while helping teams send both transactional and marketing emails at global scale. 1410 1411--- 1412 1413Try Multi-Region Email Sending: 1414 1415Multi-region email sending is now available in Keplars. 1416 1417You can configure regions directly from the dashboard and begin optimizing email delivery for your global users.`},{id:"p2",title:"Keplars Is Now Available on the Vercel Marketplace",slug:"keplars-vercel-marketplace-email-infrastructure",excerpt:"Developers building and deploying applications on Vercel can now integrate Keplars directly into their workflow to power both transactional and marketing emails with a developer-first email infrastructure.",seoTitle:"Keplars on Vercel Marketplace | Email Infrastructure for Vercel Apps",seoDescription:"Keplars is now available on the Vercel Marketplace. Send transactional and marketing emails from Vercel apps with OAuth domains, templates, and scalable email infrastructure.",seoKeywords:["vercel email","vercel email sending","email api for vercel","transactional email vercel","send email from vercel","vercel serverless email","email infrastructure","email api","keplars","oauth email sending","email templates","email delivery service","marketing email api","developer email tools"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Keplars Is Now Available on the Vercel Marketplace",description:"Developers building and deploying applications on Vercel can now integrate Keplars directly into their workflow to power both transactional and marketing emails with a developer-first email infrastructure.",image:"https://cdn.keplersmail.com/blogs/vercel-keplars-banner.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-03-10",dateModified:"2026-03-10",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/keplars-vercel-marketplace-email-infrastructure"}},date:"Mar 10, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/vercel-keplars-banner.png",content:`Keplars is now available on the Vercel Marketplace. 1418 1419Developers building and deploying applications on Vercel can now integrate Keplars directly into their workflow to power both transactional and marketing emails with a developer-first email infrastructure. 1420 1421Modern applications rely on email for critical workflows - authentication, password resets, notifications, and product communication. By joining the Vercel Marketplace, Keplars becomes easier to discover and integrate for teams building on Vercel. 1422 1423 1424 1425--- 1426 1427Email Infrastructure for Vercel Applications: 1428 1429Applications deployed on Vercel often require a reliable way to send emails from serverless functions, APIs, and backend services. 1430 1431Keplars provides a complete platform for creating, managing, and delivering emails with a focus on simplicity and scalability. 1432 1433With Keplars, developers can: 1434 1435- Send transactional and marketing emails 1436- Build emails using drag-and-drop templates, AI-generated templates, or code editors
1437- Start quickly with OAuth email domains (Gmail, Google Workspace, Outlook) 1438- Configure custom domains with SPF, DKIM, and DMARC 1439- Schedule emails and manage delivery workflows 1440- Integrate via APIs, SMTP, or webhooks 1441 1442This allows teams to go from setup to sending quickly, while maintaining the flexibility needed as their products grow. 1443 1444--- 1445 1446Built for Modern Developer Workflows: 1447 1448Vercel enables teams to build and deploy modern applications quickly. Keplars complements this workflow by providing an email infrastructure layer that integrates naturally into serverless and API-driven architectures. 1449 1450Instead of managing complex email setups, developers can focus on building their product while Keplars handles email delivery and infrastructure. 1451 1452--- 1453 1454Designed for Global Applications: 1455 1456As applications scale, email delivery becomes more critical. 1457 1458Keplars is designed to support global applications with infrastructure built for reliability, performance, and scalability. Whether you are sending authentication emails or running marketing campaigns, consistent delivery is essential. 1459 1460--- 1461 1462Get Started on Vercel: 1463 1464Keplars is now available on the Vercel Marketplace. 1465 1466Explore and integrate Keplars into your Vercel applications: [Keplars on Vercel Marketplace](https://vercel.com/marketplace/keplars)`},{id:"p3",title:"Adding Email to Lovable Applications with Keplars",slug:"lovable-email-integration-keplars",excerpt:"We've introduced a new Keplars integration for Lovable.dev, making it simple to add reliable, production-ready email functionality without slowing down development or introducing unnecessary complexity.",seoTitle:"Lovable Email Integration with Keplars | Add Email to Lovable Apps",seoDescription:"Add email functionality to Lovable apps with Keplars. Send transactional and scheduled emails using Supabase Edge Functions with production-ready infrastructure.",seoKeywords:["lovable email integration","lovable.dev email","keplars lovable","email for lovable apps","supabase edge functions email","transactional email lovable","email api for lovable","keplars","email infrastructure","react email components","developer email tools","marketing email api","email hooks typescript","production email setup"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Adding Email to Lovable Applications with Keplars",description:"Add email functionality to Lovable apps using Keplars and Supabase Edge Functions with production-ready email delivery.",image:"https://keplars.com/images/lovable-integration.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-03-05",dateModified:"2026-03-05",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/lovable-email-integration-keplars"}},date:"Mar 5, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/keplars_loveable.png",content:`Lovable apps need email you actually love. 1467 1468We've introduced a new Keplars integration for Lovable.dev, making it simple to add reliable, production-ready email functionality without slowing down development or introducing unnecessary complexity. 1469 1470Lovable is designed to help you build full-stack applications quickly using AI-generated code. Keplars complements this workflow by providing an email infrastructure layer that fits naturally into how Lovable apps are built and deployed. 1471 1472--- 1473 1474Email That Fits Your Build Flow: 1475 1476Modern applications rely on email for critical workflows - onboarding, authentication, notifications, and user communication. Adding email should feel like a natural extension of your product, not a separate system to manage. 1477 1478With the Keplars integration, email functionality works the same way your Lovable app does: 1479 1480- Simple to set up 1481- Predictable in behavior 1482- Ready for production from day one 1483 1484You can send emails instantly or schedule them as part of your application logic, without needing to build or maintain a custom backend. 1485 1486--- 1487 1488Built on Supabase Edge Functions: 1489 1490The integration uses Supabase Edge Functions, allowing email logic to run server-side without exposing sensitive credentials or requiring additional infrastru
1490cture. 1491 1492This approach enables: 1493 1494- Secure handling of API keys 1495- Scalable execution at the edge 1496- Minimal setup with production-ready defaults 1497 1498Developers can deploy a working email system in just a few steps and integrate it directly into their application flows. 1499 1500--- 1501 1502Flexible Ways to Send Emails: 1503 1504Keplars supports multiple ways to create and send emails, depending on your use case: 1505 1506- Template-based emails with dynamic variables 1507- HTML and plain text emails for full control 1508- Scheduled emails for campaigns and workflows 1509- Instant delivery for time-sensitive actions 1510 1511This flexibility allows teams to handle both transactional and marketing emails within the same system. 1512 1513--- 1514 1515Pre-Built Components and Hooks: 1516 1517To simplify development further, the integration includes: 1518 1519- Pre-built React components (contact forms, newsletter signup) 1520- Custom hooks with loading states and error handling 1521- Ready-to-use TypeScript utilities 1522- AI prompts tailored for Lovable 1523 1524These components can be directly added to your project, reducing the time required to build common email-driven features. 1525 1526--- 1527 1528Designed for Real Use Cases: 1529 1530The integration supports common product workflows out of the box: 1531 1532- Welcome emails during user signup 1533- Contact form submissions 1534- Password reset flows 1535- Newsletter subscriptions 1536- Scheduled email campaigns 1537 1538Everything is designed to work reliably in production without requiring additional configuration. 1539 1540--- 1541 1542Production-Ready from Day One: 1543 1544Keplars is built with a focus on: 1545 1546- Reliable delivery
1547- Secure infrastructure 1548- Scalable email workflows 1549 1550From early-stage projects to growing applications, the integration ensures that email functionality remains consistent and dependable as your product evolves. 1551 1552--- 1553 1554Getting Started: 1555 1556To start using Keplars with Lovable: 1557 1558- Create a Keplars account and generate an API key 1559- Deploy the Supabase Edge Function 1560- Integrate the provided components or use direct API calls 1561 1562Detailed setup instructions are available in the documentation: [Keplars Lovable Integration Docs](https://docs.keplars.com/integrations/lovable)`},{id:"p4",title:"Integrating Keplars with PocketBase for Production-Ready Email Workflows",slug:"pocketbase-email-integration-keplars",excerpt:"PocketBase gives you auth, database, realtime, and file storage in a single executable. Keplars adds scalable email infrastructure on top - transactional emails, automations, tracking, and more - with minimal setup.",seoTitle:"PocketBase Email Integration with Keplars | Production-Ready Email Workflows",seoDescription:"Learn how to integrate PocketBase with Keplars to build scalable email workflows. Send transactional emails, trigger automations from hooks, and track delivery in production.",seoKeywords:["pocketbase email","pocketbase email integration","keplars pocketbase","transactional email pocketbase","send email from pocketbase","pocketbase hooks email","email infrastructure pocketbase","pocketbase sdk email","email api pocketbase","email automation pocketbase","pocketbase saas email","keplars","developer email tools","email delivery service"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Integrating Keplars with PocketBase for Production-Ready Email Workflows",description:"Learn how to integrate PocketBase with Keplars to build scalable email workflows including transactional emails, automations, tracking, and webhook sync.",image:"https://cdn.keplersmail.com/blogs/pocketbasethumbnail.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-24",dateModified:"2026-05-24",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/pocketbase-email-integration-keplars"}},date:"May 24, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/pocketbasethumbnail.png",content:`PocketBase has quickly become one of the most loved backend solutions for developers building lightweight SaaS products, internal tools, MVPs, and modern applications. 1563 1564It gives you: 1565 1566- Authentication 1567- Database 1568- Realtime APIs 1569- File storage 1570- Admin dashboard 1571 1572â¦all in a single executable. 1573 1574But once your app starts growing, email infrastructure becomes painful surprisingly fast. 1575 1576You suddenly need: 1577 1578- transactional emails 1579- onboarding flows 1580- OTP/password reset emails 1581- marketing campaigns 1582- tracking 1583- automations 1584- domain management 1585- analytics 1586- scalable delivery 1587 1588Most developers end up stitching together SMTP providers, templates, tracking systems, and automation tools separately. 1589 1590That's exactly why we built the official PocketBase integration for Keplars. 1591 1592In this guide, we'll walk through how to integrate PocketBase with Keplars to build scalable email workflows with minimal setup. 1593 1594--- 1595 1596What is Keplars? 1597 1598[Keplars](https://keplars.com) is a developer-first email infrastructure platform designed to simplify: 1599 1600- transactional emails 1601- marketing emails 1602- automations 1603- real-time tracking 1604- OAuth sending 1605- custom domains 1606- email APIs 1607- SDK integrations 1608 1609The goal is simple: reduce infrastructure friction so developers can focus more on building products instead of maintaining email systems. 1610 1611--- 1612 1613Why Use Keplars with PocketBase? 1614 1615PocketBase is extremely lightweight and developer-friendly. 1616 1617Keplars complements that philosophy by making communication infrastructure equally simple. 1618 1619Together, you get: 1620 1621- Transactional emails 1622- Marketing campaigns 1623- Real-time email tracking 1624- Automations 1625- OAuth-based sending 1626- Custom domains 1627- Sandbox email testing 1628- Webhooks 1629- SDKs across 11 languages 1630 1631--- 1632 1633Architecture Overview: 1634 1635Here's the typical flow: 1636 1637\`\`\`text 1638PocketBase App 1639 â 1640Business Logic / Hooks 1641 â 1642Keplars Email API 1643 â 1644Email Delivery + Tracking + Automations 1645 â 1646Webhook Events â PocketBase 1647\`\`\` 1648 1649--- 1650 1651Step 1: Create a Keplars Account 1652 1653Start by creating an account at [keplars.com](https://keplars.com). 1654 1655Once logged in: 1656 16571. Create a project 16582. Generate an API key 16593. Configure your sender/domain 16604. Enable tracking 1661 1662--- 1663 1664Step 2: Install PocketBase 1665 1666If you don't already have PocketBase running: 1667 1668\`\`\`bash 1669# Download PocketBase 1670https://pocketbase.io/docs/ 1671 1672# Run PocketBase 1673./pocketbase serve 1674\`\`\` 1675 1676PocketBase will start locally at \`http://127.0.0.1:8090\`. 1677 1678--- 1679 1680Step 3: Install Keplars SDK 1681 1682Example using Node.js: 1683 1684\`\`\`bash 1685npm install keplars 1686\`\`\` 1687 1688--- 1689 1690Step 4: Configure Environment Variables 1691 1692Create a \`.env\` file: 1693 1694\`\`\`env 1695KEPLARS_API_KEY=your_api_key 1696[email protected] 1697\`\`\` 1698 1699--- 1700 1701Step 5: Send Your First Email 1702 1703Example using the Keplars SDK: 1704 1705\`\`\`ts 1706import { Keplars } from "keplars"; 1707 1708const keplars = new Keplars({ 1709 apiKey: process.env.KEPLARS_API_KEY, 1710}); 1711 1712await keplars.emails.send({ 1713 from: process.env.KEPLARS_FROM_EMAIL, 1714 to: "[email protected]", 1715 subject: "Welcome to PocketBase", 1716 html: \` 1717 <h1>Welcome!</h1> 1718 <p>Your account has been created successfully.</p> 1719 \`, 1720}); 1721\`\`\` 1722 1723That's it. You now have email sending, delivery handling, tracking, and analytics running on top of your PocketBase app. 1724 1725--- 1726 1727Step 6: Add Email Tracking 1728 1729Keplars supports sent, delivered, open, and click tracking. 1730 1731Example response: 1732 1733\`\`\`json 1734{ 1735 "id": "email_123", 1736 "status": "sent", 1737 "tracking": true 1738} 1739\`\`\` 1740 1741This allows you to build user engagement analytics, onboarding metrics, and email performance dashboards directly into your PocketBase application. 1742 1743--- 1744 1745Step 7: Build Automations 1746 1747Keplars Automations allow you to create onboarding sequences, drip campaigns, inactivity reminders, OTP workflows, welcome emails, and follow-up emails. 1748
1749Explore automations: [Keplars Automations Docs](https://docs.keplars.com/automations) 1750 1751--- 1752 1753Step 8: Use PocketBase Hooks 1754 1755PocketBase hooks make email workflows extremely clean. 1756 1757Example: 1758 1759\`\`\`js 1760onRecordAfterCreateSuccess((e) => { 1761 // Send onboarding email 1762}); 1763\`\`\` 1764 1765You can trigger welcome emails, verification emails, alerts, reports, and notifications automatically after database events. 1766 1767--- 1768 1769Step 9: Configure Webhooks 1770 1771Keplars supports webhooks for delivered events, opened events, bounced emails, clicked links, and failures. This makes it easy to sync communication data back into PocketBase. 1772 1773Example: 1774 1775\`\`\`json 1776{ 1777 "event": "email.opened", 1778 "emailId": "123" 1779} 1780\`\`\` 1781 1782--- 1783 1784Step 10: Add Sandbox Testing 1785 1786Testing emails safely during development is critical. 1787 1788Keplars Sandbox Mode helps you validate templates, test flows, debug automations, and preview email events without accidentally emailing real users. 1789 1790--- 1791 1792Real Use Cases: 1793 1794Here are some common PocketBase + Keplars workflows: 1795 1796SaaS Applications: 1797 1798- onboarding flows 1799- billing reminders 1800- trial expiry emails 1801 1802Internal Tools: 1803 1804- alerts 1805- approval workflows 1806- notifications 1807 1808AI Applications: 1809 1810- AI-generated reports 1811- summaries 1812- asynchronous workflows 1813 1814E-commerce Apps: 1815 1816- order confirmations 1817- abandoned cart emails 1818- shipping notifications 1819 1820--- 1821 1822Why Developers Like This Stack: 1823 1824PocketBase gives developers a fast backend. Keplars gives developers scalable communication infrastructure. 1825 1826Together: setup stays lightweight, integrations stay simple, workflows stay scalable - without managing multiple disconnected tools. 1827 1828--- 1829 1830Final Thoughts: 1831 1832The goal behind this integration was simple: make production-grade email infrastructure feel as developer-friendly as PocketBase itself. 1833 1834We're excited to see what developers build with this stack. 1835 1836Useful Links: 1837 1838- [Keplars Platform](https://keplars.com) 1839- [PocketBase Integration Docs](https://docs.keplars.com/integrations/pocketbase) 1840- [Keplars Automations](https://docs.keplars.com/automations) 1841- [Keplars CLI Docs](https://docs.keplars.com/docs/cli)`},{id:"p5",title:"Integrating Keplars with Payload CMS for Scalable Email Infrastructure",slug:"payload-cms-email-integration-keplars",excerpt:"Payload CMS gives you a powerful backend, admin panel, and content management system. Keplars adds scalable email infrastructure on top - transactional emails, automations, tracking, and more - with minimal setup.",seoTitle:"Payload CMS Email Integration with Keplars | Scalable Email Infrastructure",seoDescription:"Learn how to integrate Payload CMS with Keplars to build scalable email workflows. Send transactional emails, trigger automations, and track delivery in production.",seoKeywords:["payload cms email","payload cms email integration","keplars payload cms","transactional email payload cms","send email from payload cms","payload cms hooks email","email infrastructure payload","payload sdk email","email api payload cms","email automation payload","payload cms saas email","keplars","developer email tools","email delivery service"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Integrating Keplars with Payload CMS for Scalable Email Infrastructure",description:"Learn how to integrate Payload CMS with Keplars to build scalable email workflows including transactional emails, automations, tracking, and webhook sync.",image:"https://cdn.keplersmail.com/blogs/payloadcrm.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-25",dateModified:"2026-05-25",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/payload-cms-email-integration-keplars"}},date:"May 25, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/payloadcrm.png",content:`Modern CMS platforms have become incredibly powerful. 1842 1843With tools like Payload CMS, developers can now build: 1844 1845- backend systems 1846- admin panels 1847- APIs 1848- authentication 1849- content-driven applications 1850 1851â¦faster than ever. 1852 1853But there's still one part of the stack that becomes messy surprisingly quickly: 1854
1855Email infrastructure. 1856 1857Most projects start with basic SMTP. 1858 1859Then eventually need: 1860 1861- transactional emails 1862- onboarding workflows 1863- email tracking 1864- marketing campaigns 1865- custom domains 1866- automations 1867- analytics 1868- scalable delivery systems 1869 1870At that point, developers usually end up stitching together multiple disconnected tools. 1871 1872That's exactly why we built the official Payload CMS integration for Keplars. 1873 1874In this guide, we'll walk through how to integrate Keplars with Payload CMS to build production-ready communication workflows with minimal setup. 1875 1876--- 1877 1878What is Keplars? 1879 1880[Keplars](https://keplars.com?utm_source=chatgpt.com) is an email infrastructure platform focused on making setup and tracking much simpler for modern applications and teams. 1881 1882Keplars unifies: 1883 1884- transactional emails 1885- marketing emails 1886- automations 1887- real-time tracking 1888- OAuth sending 1889- custom domains 1890- APIs 1891- SDKs 1892- SMTP 1893- Webhooks 1894 1895â¦into a single platform built for both tech and non-tech users. 1896 1897Setup takes just a few clicks. 1898 1899--- 1900 1901Why Payload CMS + Keplars? 1902 1903Payload CMS already gives developers an amazing developer experience for backend and content management. 1904 1905Keplars complements that by simplifying communication infrastructure. 1906 1907Together, you get: 1908 1909- scalable email workflows 1910- tracking 1911- automation 1912- delivery infrastructure 1913- domain management 1914- developer-friendly integrations 1915 1916without needing to manage multiple email services separately. 1917 1918--- 1919 1920Common Problems Developers Face: 1921 1922As Payload apps scale, email workflows usually become fragmented. 1923 1924Typical setup: 1925 1926- SMTP provider 1927- separate tracking platform 1928- automation tool 1929- template builder 1930- analytics service 1931- webhook handling 1932 1933This creates: 1934 1935- infrastructure complexity 1936- delivery inconsistencies 1937- maintenance overhead 1938- poor visibility into email performance 1939 1940Keplars simplifies this entire layer. 1941 1942--- 1943 1944What You Can Build: 1945 1946Using Payload CMS + Keplars, you can easily build: 1947 1948Transactional Emails: 1949 1950- signup emails 1951- password resets 1952- OTP verification 1953- notifications 1954- order confirmations 1955 1956Marketing Workflows: 1957 1958- newsletters 1959- campaigns 1960- onboarding sequences 1961- follow-up emails 1962 1963Automated Workflows: 1964 1965- inactivity reminders 1966- event-based triggers 1967- user lifecycle communication 1968 1969Real-Time Tracking: 1970 1971Track: 1972 1973- sent events 1974- delivery status 1975- open rates 1976- click events 1977- failures 1978 1979--- 1980 1981Integration Features: 1982 1983The Payload CMS integration supports: 1984 1985- â Email APIs 1986- â SMTP support 1987- â Webhooks 1988- â OAuth-based sending 1989- â Custom domains 1990- â Real-time tracking 1991- â Automations 1992- â SDKs across 11 languages 1993- â Sandbox testing 1994- â CLI support 1995 1996--- 1997 1998Architecture Overview: 1999 2000Typical workflow: 2001 2002\`\`\`text 2003Payload CMS 2004 â 2005Application Logic / Hooks 2006 â 2007Keplars API 2008 â 2009Email Delivery + Tracking + Automations 2010 â 2011Webhook Events Back to Payload 2012\`\`\` 2013 2014--- 2015 2016Step 1: Create a Keplars Account 2017 2018Start by creating an account: [Create Keplars Account](https://keplars.com?utm_source=chatgpt.com) 2019 2020After signup: 2021 2022- Create a project 2023- Generate an API key 2024- Configure your sender domain 2025- Enable tracking 2026 2027--- 2028 2029Step 2: Install the Keplars SDK 2030 2031Example using Node.js: 2032 2033\`\`\`bash 2034npm install keplars 2035\`\`\` 2036 2037--- 2038 2039Step 3: Configure Environment Variables 2040 2041Create a \`.env\` file: 2042 2043\`\`\`env 2044KEPLARS_API_KEY=your_api_key 2045[email protected] 2046\`\`\` 2047 2048--- 2049 2050Step 4: Send Your First Email 2051 2052Example using the Keplars SDK: 2053 2054\`\`\`ts 2055import { Keplars } from "keplars"; 2056 2057const keplars = new Keplars({ 2058 apiKey: process.env.KEPLARS_API_KEY, 2059}); 2060 2061await keplars.emails.send({ 2062 from: process.env.KEPLARS_FROM_EMAIL, 2063 to: "[email protected]", 2064 subject: "Welcome to Payload CMS", 2065 html: \` 2066 <h1>Welcome!</h1> 2067 <p>Your account has been created successfully.</p> 2068 \`, 2069}); 2070\`\`\` 2071 2072That's it. 2073 2074You now have: 2075 2076- email sending 2077- tracking 2078- delivery infrastructure 2079- analytics 2080 2081running alongside your Payload CMS app. 2082 2083--- 2084 2085Step 5: Add Real-Time Tracking 2086 2087Keplars supports: 2088 2089- sent tracking 2090- delivered tracking 2091- open tracking 2092- click tracking 2093 2094Example response: 2095 2096\`\`\`json 2097{ 2098 "id": "email_123", 2099 "status": "sent", 2100 "tracking": true 2101} 2102\`\`\` 2103 2104This makes it easy to build: 2105 2106- engagement analytics 2107- campaign dashboards 2108- onboarding insights 2109- notification monitoring 2110 2111inside your application. 2112 2113--- 2114 2115Step 6: Build Automations 2116 2117Keplars Automations help simplify: 2118 2119- onboarding flows 2120- drip campaigns 2121- lifecycle emails 2122- reminders 2123- re-engagement campaigns 2124
2125Explore automations here: [Keplars Automations Docs](https://docs.keplars.com/automations?utm_source=chatgpt.com) 2126 2127--- 2128 2129Step 7: Configure Webhooks 2130 2131Keplars supports webhook events for: 2132 2133- email opened 2134- email delivered 2135- link clicked 2136- bounce events 2137- failures 2138 2139Example webhook payload: 2140 2141\`\`\`json 2142{ 2143 "event": "email.opened", 2144 "emailId": "123" 2145} 2146\`\`\` 2147 2148This allows Payload CMS applications to react to communication events in real time. 2149 2150--- 2151 2152Step 8: Use Sandbox Mode 2153 2154Testing email workflows safely during development is critical. 2155 2156Keplars Sandbox Mode allows developers to: 2157 2158- test email flows 2159- preview templates 2160- validate automations 2161- debug integrations 2162 2163without accidentally sending emails to real users. 2164 2165--- 2166 2167Integrations Ecosystem: 2168 2169Keplars also integrates with: 2170 2171- Firebase 2172- Supabase 2173- PocketBase 2174- React Email 2175- Vercel Marketplace 2176- Payload CMS 2177 2178â¦and more. 2179 2180--- 2181 2182Why We Built This Integration: 2183 2184Payload CMS developers care deeply about: 2185 2186- developer experience 2187- simplicity 2188- scalability 2189- flexibility 2190 2191We wanted email infrastructure to feel equally clean and developer-friendly. 2192 2193The goal with Keplars is simple: 2194 2195Reduce infrastructure friction so teams can spend more time building products instead of maintaining communication systems. 2196 2197--- 2198 2199Final Thoughts: 2200 2201Payload CMS is already one of the best modern backend/CMS platforms available today. 2202 2203Keplars helps extend that experience into scalable communication workflows. 2204 2205We're excited to see what developers build using Payload CMS + Keplars together. 2206 2207Useful Links: 2208 2209- [Keplars Platform](https://keplars.com?utm_source=chatgpt.com) 2210- [Payload CMS Integration Docs](https://docs.keplars.com/integrations/payload?utm_source=chatgpt.com) 2211- [Keplars Docs](https://docs.keplars.com?utm_source=chatgpt.com) 2212- [Keplars Automations](https://docs.keplars.com/automations?utm_source=chatgpt.com)`},{id:"p6",title:"Integrating Keplars with n8n for Automated Communication Workflows",slug:"n8n-email-integration-keplars",excerpt:"Automation platforms have completely changed how modern products operate. This guide walks through how to integrate Keplars with n8n to build scalable, automated communication workflows with much simpler setup.",seoTitle:"Keplars n8n Integration | Automated Email Communication Workflows",seoDescription:"Learn how to integrate Keplars with n8n to build scalable, automated email communication workflows. Send transactional emails, configure webhooks, and track delivery from n8n automations.",seoKeywords:["n8n email integration","n8n keplars","n8n email automation","n8n transactional email","send email from n8n","n8n workflow email","email automation n8n","keplars n8n","email infrastructure n8n","n8n http request email","workflow automation email","keplars","developer email tools","email delivery service"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Integrating Keplars with n8n for Automated Communication Workflows",description:"Learn how to integrate Keplars with n8n to build scalable automated email workflows including transactional emails, real-time tracking, and webhook-driven automations.",image:"https://cdn.keplersmail.com/blogs/n8nthumbnail.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-27",dateModified:"2026-05-27",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/n8n-email-integration-keplars"}},date:"May 27, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/n8nthumbnail.png",content:`Automation platforms have completely changed how modern products operate. 2213 2214Today, teams automate: 2215- onboarding flows 2216- notifications 2217- lead pipelines 2218- CRM updates 2219- support workflows 2220- AI agents 2221- internal operations 2222 2223And one of the most powerful workflow automation tools leading this shift is n8n. 2224 2225But while workflows are becoming easier to automate, communication infrastru
2225cture still often becomes fragmented across: 2226- SMTP providers 2227- marketing tools 2228- tracking systems 2229- webhook services 2230- automation platforms 2231 2232That's exactly why we built the official n8n integration for Keplars. 2233 2234In this guide, we'll walk through how to integrate Keplars with n8n to build scalable, automated communication workflows with much simpler setup. 2235 2236--- 2237 2238What is Keplars? 2239 2240[Keplars](https://keplars.com) is an email infrastructure platform focused on making setup and tracking much simpler for modern applications and teams. 2241 2242Keplars unifies: 2243- transactional emails 2244- marketing emails 2245- automations 2246- real-time tracking 2247- OAuth sending 2248- custom domains 2249- APIs 2250- SMTP 2251- Webhooks 2252- SDKs across 11 languages 2253 2254â¦into a single communication platform built for both tech and non-tech users. 2255 2256Setup takes just a few clicks. 2257 2258--- 2259 2260Why Use Keplars with n8n? 2261 2262n8n is incredibly powerful for workflow automation. 2263 2264But communication workflows often still require multiple disconnected services. 2265 2266Using Keplars with n8n helps centralize: 2267- email delivery 2268- tracking 2269- automations 2270- notifications 2271- campaigns 2272- reporting 2273 2274inside your automation stack. 2275 2276Together, n8n + Keplars makes it easier to build: 2277- AI workflows 2278- SaaS onboarding 2279- CRM automations 2280- lifecycle campaigns 2281- alerts and notifications 2282- asynchronous communication systems 2283 2284without complex infrastructure setup. 2285 2286--- 2287 2288What You Can Build: 2289 2290Using Keplars + n8n, you can automate: 2291 2292Transactional Workflows: 2293- welcome emails 2294- OTP verification 2295- password reset emails 2296- system notifications 2297- invoice emails 2298 2299Marketing Automations: 2300- drip campaigns 2301- follow-up sequences 2302- newsletters 2303- re-engagement campaigns 2304 2305AI + Agent Workflows: 2306- AI-generated reports 2307- async agent notifications 2308- summaries 2309- scheduled actions 2310- autonomous workflow updates 2311 2312Operational Workflows: 2313- internal alerts 2314- CRM events 2315- webhook-triggered notifications 2316- user lifecycle automation 2317 2318--- 2319 2320Integration Features: 2321 2322The Keplars + n8n integration supports: 2323- â Email APIs 2324- â SMTP support 2325- â Webhooks 2326- â OAuth-based sending 2327- â Custom domains 2328- â Real-time email tracking 2329- â Automations 2330- â SDKs across 11 languages 2331- â Sandbox testing 2332- â CLI support 2333 2334--- 2335 2336Architecture Overview: 2337 2338Typical workflow: 2339 2340\`\`\`text 2341n8n Workflow 2342 â 2343Trigger / Event 2344 â 2345Keplars Email API 2346 â 2347Email Delivery + Tracking 2348 â 2349Webhook Events Back to n8n 2350\`\`\` 2351 2352--- 2353 2354Step 1: Create a Keplars Account 2355 2356Start by creating an account on Keplars. 2357 2358After signup: 2359 23601. Create a project 23612. Generate an API key 23623. Configure your sender domain 23634. Enable tracking 2364 2365Platform: [keplars.com](https://keplars.com) 2366 2367--- 2368 2369Step 2: Set Up n8n 2370 2371If you don't already have n8n running: 2372 2373\`\`\`bash 2374npm install n8n -g 2375\`\`\` 2376 2377Start n8n: 2378 2379\`\`\`bash 2380n8n start 2381\`\`\` 2382 2383By default, n8n runs at http://localhost:5678. 2384 2385--- 2386 2387Step 3: Configure the Keplars API Request in n8n 2388 2389Inside n8n: 2390 23911. Create a new workflow 23922. Add a Trigger node 23933. Add an HTTP Request node 23944. Configure the request to Keplars API 2395 2396Example configuration: 2397 2398\`\`\`text 2399POST https://api.keplars.com/v1/email/send 2400\`\`\` 2401 2402Headers: 2403 2404\`\`\`json 2405{ 2406 "Authorization": "Bearer YOUR_API_KEY", 2407 "Content-Type": "application/json" 2408} 2409\`\`\` 2410 2411Body: 2412 2413\`\`\`json 2414{ 2415 "from": "[email protected]", 2416 "to": "[email protected]", 2417 "subject": "Welcome to Keplars", 2418 "html": "<h1>Hello from n8n + Keplars</h1>" 2419} 2420\`\`\` 2421 2422--- 2423 2424Step 4: Add Real-Time Tracking 2425 2426Keplars supports: 2427- sent tracking 2428- delivery tracking 2429- open tracking 2430- click tracking 2431 2432This makes it easy to automate workflows based on engagement events. 2433 2434Example: 2435- send follow-up email if unopened 2436- notify sales team after click 2437- trigger onboarding workflows after delivery 2438 2439--- 2440 2441Step 5: Configure Webhooks 2442 2443Keplars webhooks support: 2444- delivered events 2445- opened events 2446- clicked events 2447- bounce events 2448- failed delivery events 2449 2450Example webhook payload: 2451 2452\`\`\`json 2453{ 2454 "event": "email.opened", 2455 "emailId": "123" 2456} 2457\`\`\` 2458 2459These webhook events can directly trigger additional n8n workflows. 2460 2461--- 2462 2463Example Workflow Ideas: 2464 2465SaaS User Onboarding: 2466 2467Trigger: 2468- user signup 2469 2470Actions: 2471- send welcome email 2472- schedule onboarding sequence 2473- notify internal CRM 2474 2475AI Agent Notifications: 2476 2477Trigger: 2478- AI task completion 2479 2480Actions: 2481- generate report 2482- send user summary 2483- notify Slack/Discord 2484 2485Lead Nurturing: 2486 2487Trigger: 2488- new lead captured 2489 2490Actions: 2491- send introduction email 2492- schedule follow-ups 2493- track engagement 2494 2495--- 2496 2497Why This Stack Works Well: 2498 2499n8n handles automation extremely well. 2500
2501Keplars handles communication infrastructure extremely well. 2502 2503Together: 2504- workflows become easier to scale 2505- tracking becomes centralized 2506- setup becomes simpler 2507- automations become more reliable 2508 2509without stitching together multiple disconnected services. 2510 2511--- 2512 2513Sandbox Testing: 2514 2515Keplars Sandbox Mode helps developers: 2516- safely test workflows 2517- validate templates 2518- debug automations 2519- preview tracking events 2520 2521without emailing real users during development. 2522 2523--- 2524 2525Integrations Ecosystem: 2526 2527Keplars also integrates with: 2528- Firebase 2529- Supabase 2530- PocketBase 2531- Payload CMS 2532- Bubble.io 2533- React Email 2534- Vercel Marketplace 2535- n8n 2536 2537â¦and more. 2538 2539--- 2540 2541Final Thoughts: 2542 2543Automation is becoming the backbone of modern software. 2544 2545But automation workflows are only as good as the communication infrastructure behind them. 2546 2547With the n8n + Keplars integration, developers and teams can build scalable communication workflows with significantly less complexity. 2548 2549We're excited to see what builders create with this integration. 2550 2551Useful Links: 2552- [Keplars Platform](https://keplars.com) 2553- [n8n Integration Docs](https://docs.keplars.com/integrations/n8n) 2554- [Documentation](https://docs.keplars.com) 2555- [Automations](https://docs.keplars.com/automations)`},{id:"p7",title:"Keplars + Bubble.io: Bringing Scalable Email Infrastructure to No-Code Applications",slug:"bubble-email-integration-keplars",excerpt:"The official Bubble.io integration for Keplars is here. No-code builders can now add transactional emails, marketing campaigns, real-time tracking, and automations to Bubble apps from a single platform.",seoTitle:"Keplars + Bubble.io Integration | Scalable Email for No-Code Apps",seoDescription:"Add scalable email infrastructure to Bubble.io applications with Keplars. Send transactional emails, run marketing campaigns, track delivery, and automate workflows - all without leaving Bubble.",seoKeywords:["bubble.io email integration","keplars bubble","no-code email infrastructure","transactional email bubble","send email from bubble","bubble workflow email","email automation bubble","marketing email bubble","real-time email tracking bubble","no-code email platform"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Keplars + Bubble.io: Bringing Scalable Email Infrastructure to No-Code Applications",description:"The official Bubble.io integration for Keplars lets no-code builders add transactional emails, marketing campaigns, real-time tracking, and automations to Bubble apps from a single platform.",image:"https://cdn.keplersmail.com/blogs/bubble.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-30",dateModified:"2026-05-30",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/bubble-email-integration-keplars"}},date:"May 30, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/bubble.png",content:`The rise of no-code development has fundamentally changed how products are built. 2556 2557Today, founders, startups, agencies, and businesses can launch applications significantly faster without managing complex backend infrastructure from day one. 2558 2559One of the platforms leading that movement is Bubble.io. 2560 2561Bubble has enabled thousands of teams worldwide to build a wide range of applications. 2562 2563- SaaS platforms 2564- Marketplaces 2565- Internal tools 2566- AI applications 2567- Client portals 2568- MVPs 2569 2570without writing large amounts of code. 2571 2572But while building products has become easier, communication infrastructure still remains one of the most fragmented parts of the stack. 2573 2574Most Bubble applications eventually require several key capabilities. 2575 2576- Transactional emails 2577- Marketing campaigns 2578- User onboarding flows 2579- Notifications 2580- Email tracking 2581- Custom domains 2582- Automations 2583- Delivery analytics 2584 2585And this is where many teams end up stitching together multiple tools. 2586 2587At Keplars, we wanted to simplify that experience. 2588 2589That's why we're excited to announce the official Bubble.io integration for Keplars. 2590 2591Why We Built the Bubble Integration: 2592
2593While speaking with founders and teams building on Bubble, one common challenge kept appearing. 2594 2595The product itself could be launched quickly. 2596 2597But communication workflows became increasingly difficult as the application grew. 2598 2599Teams often found themselves managing multiple disconnected services. 2600 2601- SMTP providers 2602- Email APIs 2603- Marketing tools 2604- Tracking platforms 2605- Domain configuration 2606- Authentication records 2607- Automation systems 2608 2609across multiple disconnected services. 2610 2611The result was unnecessary complexity around something that should be straightforward. 2612 2613Our goal with Keplars has always been to make email infrastructure significantly easier for both technical and non-technical teams. 2614 2615The Bubble integration is another step toward that goal. 2616 2617Learn more at [keplars.com](https://keplars.com). 2618 2619What the Integration Supports: 2620 2621With the Bubble + Keplars integration, developers and no-code builders can now manage communication workflows from a single platform. 2622 2623Transactional Emails: 2624 2625Send critical application emails including welcome emails, password resets, OTP verification, account notifications, billing emails, and order confirmations directly from Bubble workflows. 2626 2627Marketing Emails: 2628 2629Manage newsletters, campaigns, product announcements, promotional emails, and re-engagement workflows without requiring separate email infrastructure. 2630 2631Real-Time Tracking: 2632 2633Visibility is a major part of modern communication systems. Keplars provides real-time tracking for sent emails, delivered emails, open events, and click events - allowing teams to understand exactly how users interact with every communication. 2634 2635OAuth-Based Sending: 2636 2637Managing email credentials can become difficult as products scale. Keplars supports OAuth-based sending, helping simplify authentication workflows while improving security and management. 2638 2639Custom Domains: 2640 2641Businesses need communication that reflects their brand. The integration supports custom domain configuration, allowing teams to send emails directly through their branded domains. 2642 2643APIs, SMTP, Webhooks, and SDKs: 2644 2645For teams extending beyond no-code workflows, Keplars provides Email APIs, SMTP support, Webhooks, and SDKs across 11 programming languages. This makes it possible to combine Bubble applications with more advanced backend workflows whenever needed. 2646 2647Common Bubble Use Cases: 2648 2649The integration is designed to support a wide range of Bubble applications. 2650 2651SaaS Products: 2652 2653Typical workflows include user onboarding, trial reminders, product notifications, subscription updates, and customer engagement campaigns. 2654 2655Marketplaces: 2656 2657Communication becomes critical between buyers, sellers, vendors, and service providers. Keplars helps automate these interactions reliably. 2658 2659AI Applications: 2660 2661Many AI-powered products require report delivery, async notifications, workflow updates, and user summaries. Email infrastructure often becomes a core part of the product experience. 2662 2663Internal Tools: 2664 2665Organizations frequently use Bubble for operations platforms, CRM systems, internal dashboards, and approval workflows. Automated communication plays an important role in these environments. 2666 2667Simplifying Infrastructure Complexity: 2668 2669One thing we've consistently observed while building Keplars is that most teams don't want to spend time managing communication infrastructure. 2670 2671They want to build products. 2672 2673Yet communication systems often require SMTP configuration, DNS records, tracking systems, automation tooling, and deliverability management - all spread across different services. 2674 2675The Bubble integration helps consolidate those workflows into a simpler experience. Instead of managing multiple providers separately, teams can centralize communication infrastructure through Keplars. 2676 2677Built for Both Technical and Non-Technical Teams: 2678 2679A core principle behind Keplars is accessibility. 2680 2681Many email platforms assume every user is highly technical. But modern products are increasingly built by founders, operators, agencies, growth teams, product teams, and no-code builders. 2682 2683The Bubble ecosystem reflects that shift. 2684 2685That's why Keplars focuses on reducing setup friction while still providing the flexibility needed for advanced communication workflows. 2686 2687Setup takes only a few clicks. Learn more about the platform at [keplars.com](https://keplars.com). 2688 2689Getting Started: 2690 2691Getting started with the Bubble integration is straightforward. 2692 2693Explore the complete integration documentation: [Bubble Integration Docs](
2693https://docs.keplars.com/integrations/bubble) 2694 2695Documentation covers the following areas. 2696 2697- Setup instructions 2698- API usage 2699- Workflow integration 2700- Authentication 2701- Tracking 2702- Domain configuration 2703 2704and more. 2705 2706Looking Ahead: 2707 2708The future of software is increasingly moving toward faster development cycles, no-code platforms, AI-assisted workflows, and lean product teams. 2709 2710Communication infrastructure needs to evolve alongside that shift. 2711 2712Our goal at Keplars is to make setup, sending, tracking, and automation significantly simpler - regardless of whether you're building with code or no-code tools. 2713 2714We're excited to support the Bubble community and help more builders launch scalable communication workflows without unnecessary infrastructure complexity. 2715 2716To learn more about Keplars, visit [keplars.com](https://keplars.com). 2717 2718Bubble Integration Documentation: [docs.keplars.com/integrations/bubble](https://docs.keplars.com/integrations/bubble)`},{id:"p8",title:"Keplars + Zapier: Connect Email Infrastructure to Thousands of Applications",slug:"zapier-email-integration-keplars",excerpt:"Keplars is now available on Zapier. Connect email infrastructure to thousands of applications and automate communication workflows without writing custom integrations.",seoTitle:"Keplars + Zapier Integration | Email Infrastructure for Thousands of Apps",seoDescription:"Keplars is now on Zapier. Connect email infrastructure to HubSpot, Stripe, Airtable, Shopify, and thousands more. Automate transactional and marketing emails without custom code.",seoKeywords:["zapier email integration","keplars zapier","zapier email automation","zapier transactional email","send email from zapier","zapier workflow email","email automation zapier","no-code email infrastructure","zapier email api","workflow automation email","keplars","developer email tools","email delivery service","stripe email zapier"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Keplars + Zapier: Connect Email Infrastructure to Thousands of Applications",description:"Keplars is now available on Zapier, allowing businesses, developers, and operations teams to connect email infrastructure to thousands of applications and automate communication workflows.",image:"https://cdn.keplersmail.com/blogs/zapier.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-31",dateModified:"2026-05-31",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/zapier-email-integration-keplars"}},date:"May 31, 2026",author:"Ananya Singha RM",authorImage:"https://cdn.keplersmail.com/awesome-ananya.jpg",authorGithub:"https://github.com/awesome-ana",category:"Product",image:"https://cdn.keplersmail.com/blogs/zapier.png",content:`Modern businesses run on dozens of tools. 2719 2720CRM platforms, payment processors, form builders, support systems, databases, spreadsheets, AI tools, and internal workflows all generate events that require communication. 2721 2722A new lead arrives. A customer completes a purchase. A user signs up. A payment succeeds. A support ticket is created. 2723 2724In almost every case, an email needs to be sent. 2725 2726That's why we're excited to announce that **Keplars is now available on Zapier**. 2727 2728This integration allows businesses, developers, and operations teams to connect Keplars email infrastructure to thousands of applications and automate communication workflows without writing custom integrations. 2729 2730## Why We Built the Zapier Integration 2731 2732At Keplars, our mission is simple: make email infrastructure easier. 2733 2734Many teams already use tools such as: 2735 2736* HubSpot 2737* Salesforce 2738* Airtable 2739* Stripe 2740* Google Sheets 2741* Notion 2742* Typeform 2743* Shopify 2744* Slack 2745 2746The challenge is that communication workflows often become fragmented. One platform stores the data. Another triggers the event. A third sends the email. A fourth handles tracking. A fifth manages automation. The result is unnecessary complexity. 2747 2748With the Zapier integration, Keplars becomes part of your existing workflow ecosystem, allowing you to trigger email actions directly from the tools your team already uses. 2749 2750Learn more about [Keplars](https://keplars.com). 2751 2752## What is Zapier? 2753 2754Zapier is one of the most widely adopted automation platforms, allowing users to connect thousands of applications through automated workflows known as "Zaps." These workflows use triggers and actions to move data between systems without requiring custom development. 2755 2756By connecting Keplars to Zapier, users can automate communication workflows across a large ecosystem of business applications. 2757 2758## What Can You Do With Keplars + Zapier? 2759 2760The integration opens up a wide range of use cases. 2761 2762### Send Transactional Emails 2763 2764Trigger emails whenever important events occur: user registrations, password resets, account verification, subscription updates, order confirmations, and payment receipts. Instead of building custom integrations, Zapier can trigger Keplars automatically. 2765 2766### Start Email Automations 2767 2768Use events from other applications to launch communication workflows. 2769 2770Examples include: 2771 2772* New lead captured 2773* Customer upgraded 2774* Trial started 2775* Demo booked 2776* Support request submitted 2777 2778The event happens in one platform and Keplars handles the communication. 2779 2780### Connect Existing Business Systems 2781 2782Many businesses already rely on operational tools for daily workflows. The Zapier integration allows Keplars to fit directly into existing processes without requiring engineering effort. 2783 2784### Reduce Development Overhead 2785 2786Without automation platforms, teams are often responsible for building API integrations, managing webhooks, handling retries, creating synchronization logic, and maintaining custom workflows. Zapier removes much of that complexity and allows teams to focus on business logic instead. 2787 2788## Example Workflows 2789 2790### Stripe â Keplars 2791 2792Trigger: New payment received. 2793 2794Action: Send a receipt email through Keplars. 2795 2796--- 2797 2798### Typeform â Keplars 2799 2800Trigger: New form submission. 2801 2802Action: Send a personalized follow-up email. 2803 2804--- 2805 2806### HubSpot â Keplars 2807 2808Trigger: New lead created. 2809 2810Action: Launch an onboarding sequence. 2811 2812--- 2813 2814### Airtable â Keplars 2815 2816Trigger: New row added. 2817 2818Action: Send a campaign or notification email. 2819 2820--- 2821 2822### Google Sheets â Keplars 2823 2824Trigger: Spreadsheet updated. 2825 2826Action: Send an automated communication workflow. 2827 2828--- 2829 2830### Shopify â Keplars 2831 2832Trigger: Order completed. 2833 2834Action: Send transactional updates and customer communications. 2835 2836## Why Keplars? 2837 2838While Zapier handles automation between applications, Keplars focuses on communication infrastru
2838cture. 2839 2840Keplars provides: 2841 2842* Transactional emails 2843* Marketing emails 2844* Email APIs 2845* SMTP 2846* Webhooks 2847* Email automations 2848* Real-time tracking 2849* OAuth sending 2850* Custom domains 2851* SDKs across 11 programming languages 2852 2853This allows teams to centralize communication workflows rather than managing multiple email tools. Explore the [Keplars platform](https://keplars.com). 2854 2855## Built for Developers and Non-Technical Teams 2856 2857One of the most exciting aspects of this integration is accessibility. 2858 2859Developers can use Keplars APIs and SDKs for advanced workflows. Operations teams can use Zapier to automate processes visually. Founders can connect business systems without engineering resources. Marketing teams can trigger communication based on customer actions. Everyone works from the same communication platform. 2860 2861## Getting Started 2862 2863Getting started takes only a few minutes. 2864 2865- Create a Keplars account. 2866- Connect Keplars in Zapier. 2867- Select your trigger application. 2868- Configure the Keplars action. 2869- Publish your workflow. 2870 2871Once connected, your workflows can automatically trigger email actions whenever events occur across your business systems. 2872 2873## The Future of Email Infrastructure 2874 2875Software teams are using more tools than ever before. The challenge is no longer collecting data. The challenge is connecting systems together in a reliable way. 2876 2877By bringing Keplars to Zapier, we're making it easier to connect communication infrastructure with the tools businesses already depend on every day. 2878 2879Whether you're sending onboarding emails, customer notifications, transactional messages, or marketing campaigns, Keplars can now become part of your automation stack with just a few clicks. 2880 2881Useful Links: 2882 2883- [Keplars Platform](https://keplars.com) 2884- [Documentation](https://docs.keplars.com) 2885- [Zapier Integration](https://docs.keplars.com/integrations/zapier)`},{id:"p9",title:"Send Emails with Firebase Cloud Functions Using Keplars",slug:"firebase-cloud-functions-email-keplars",excerpt:"Deploy a production-ready email endpoint inside your Firebase project and start sending transactional, HTML, and scheduled emails in minutes using Keplars.",seoTitle:"Send Emails with Firebase Cloud Functions | Keplars Integration Guide",seoDescription:"Learn how to send transactional, HTML, and scheduled emails from Firebase Cloud Functions using Keplars. Full setup guide with TypeScript examples, CORS, and Firebase Secrets.",seoKeywords:["firebase cloud functions email","send email firebase","keplars firebase","firebase transactional email","firebase email integration","cloud functions email api","firebase email typescript","send email from firebase functions","keplars","email infrastructure firebase","firebase serverless email","developer email tools"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Send Emails with Firebase Cloud Functions Using Keplars",description:"Deploy a production-ready email endpoint inside your Firebase project using Keplars. Supports template-based, HTML, plain-text, and scheduled email delivery.",image:"https://cdn.keplersmail.com/blogs/firebase.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-03-06",dateModified:"2026-03-06",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/firebase-cloud-functions-email-keplars"}},date:"Mar 6, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/firebase.png",content:`Firebase makes it easy to build and scale applications. From authentication and databases to serverless functions, it provides everything developers need to ship products quickly. 2886 2887However, when it comes to sending transactional emails such as verification emails, welcome messages, password resets, notifications, and newsletters, developers often need a reliable email delivery solution. 2888 2889That's where Keplars comes in. 2890 2891With the Keplars Firebase Cloud Functions integration, you can deploy a production-ready email endpoint inside your Firebase project and start sending emails in minutes. 2892 2893## Why Use Keplars with Firebase? 2894 2895The integration provides: 2896 2897* Template-based emails 2898* HTML and plain-text emails 2899* Scheduled email delivery 2900* Instant email delivery (0-5 seconds) 2901* TypeScript support 2902* Node.js 18 support 2903* Firebase-native deployment 2904 2905Whether you're building a SaaS platform, e-commerce store, mobile application, or internal business tool, Keplars helps you send emails directly from your Firebase environment. 2906 2907## Quick Setup 2908 2909### 1. Clone the Example Repository 2910 2911\`\`\`bash 2912git clone https://github.com/KeplarsHQ/firebase-cloud-functions-example.git 2913 2914cd firebase-cloud-functions-example 2915\`\`\` 2916 2917### 2. Configure Your Firebase Project 2918 2919Update your \`.firebaserc\` file: 2920 2921\`\`\`json 2922{ 2923 "projects": { 2924 "default": "your-firebase-project-id" 2925 } 2926} 2927\`\`\` 2928 2929Or connect your project using: 2930 2931\`\`\`bash 2932firebase use --add 2933\`\`\` 2934 2935### 3. Add Your Keplars API Key 2936 2937Navigate to the functions directory: 2938 2939\`\`\`bash 2940cd functions 2941 2942cp .env.example .env 2943\`\`\` 2944 2945Add your API key: 2946 2947\`\`\`env 2948KEPLARS_API_KEY=kms_your_actual_api_key_here 2949\`\`\` 2950 2951### 4. Install Dependencies 2952 2953\`\`\`bash 2954npm install 2955 2956cd .. 2957\`\`\` 2958 2959### 5. Start Firebase Emulator 2960 2961\`\`\`bash 2962firebase emulators:start 2963\`\`\` 2964 2965Your email endpoint will be available at: 2966 2967\`\`\`text 2968http://127.0.0.1:5001/your-project-id/us-central1/keplarsEmail 2969\`\`\` 2970 2971## Sending Your First Email 2972 2973Once your Cloud Function is running, you can send emails using a simple HTTP request. 2974 2975### Template-Based Email 2976 2977\`\`\`json 2978{ 2979 "to": ["[email protected]"],
2980 "template_id": "your_template_id", 2981 "params": { 2982 "user_name": "John Doe", 2983 "verification_code": "123456" 2984 }, 2985 "delivery_type": "instant" 2986} 2987\`\`\` 2988 2989This approach is ideal for: 2990 2991* Welcome emails 2992* OTP verification 2993* Password resets 2994* Transactional notifications 2995 2996### Plain Text Emails 2997 2998\`\`\`json 2999{ 3000 "to": ["[email protected]"], 3001 "subject": "Welcome!", 3002 "body": "Thanks for signing up. We're excited to have you.", 3003 "delivery_type": "instant" 3004} 3005\`\`\` 3006 3007### HTML Emails 3008 3009Need complete control over email design? 3010 3011\`\`\`json 3012{ 3013 "to": ["[email protected]"], 3014 "subject": "Welcome!", 3015 "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>", 3016 "is_html": true, 3017 "delivery_type": "instant" 3018} 3019\`\`\` 3020 3021This is perfect for: 3022 3023* Marketing campaigns 3024* Product announcements 3025* Rich onboarding emails 3026 3027### Scheduled Emails 3028 3029Keplars also supports scheduled delivery with timezone awareness. 3030 3031\`\`\`json 3032{ 3033 "to": ["[email protected]"], 3034 "subject": "Weekly Newsletter", 3035 "html": "<h1>This Week's Updates</h1>", 3036 "scheduled_at": "2026-01-25T10:00:00", 3037 "timezone": "America/New_York" 3038} 3039\`\`\` 3040 3041Common use cases include: 3042 3043* Newsletters 3044* Product launches 3045* Reminder emails 3046* Time-sensitive campaigns 3047 3048## Calling the Function from JavaScript 3049 3050Once deployed, sending emails from your frontend or backend is straightforward. 3051 3052\`\`\`typescript 3053const response = await fetch( 3054 'https://us-central1-your-project-id.cloudfunctions.net/keplarsEmail', 3055 { 3056 method: 'POST', 3057 headers: { 3058 'Content-Type': 'application/json', 3059 }, 3060 body: JSON.stringify({ 3061 to: ['[email protected]'], 3062 template_id: 'your_template_id', 3063 params: { 3064 user_name: 'John', 3065 verification_code: '123456' 3066 }, 3067 delivery_type: 'instant' 3068 }) 3069 } 3070); 3071 3072const data = await response.json(); 3073 3074console.log('Email sent!', data); 3075\`\`\` 3076 3077## React Integration Example 3078 3079For React applications, you can trigger emails like this: 3080 3081\`\`\`tsx 3082function WelcomeEmail() { 3083 const sendWelcome = async (email: string, name: string) => { 3084 await fetch( 3085 'https://us-central1-your-project-id.cloudfunctions.net/keplarsEmail', 3086 { 3087 method: 'POST', 3088 headers: {'Content-Type': 'application/json'}, 3089 body: JSON.stringify({ 3090 to: [email], 3091 template_id: 'your_welcome_template_id', 3092 params: {user_name: name} 3093 }) 3094 } 3095 ); 3096 }; 3097 3098 return ( 3099 <button onClick={() => sendWelcome('[email protected]', 'Jane')}> 3100 Send Welcome Email 3101 </button> 3102 ); 3103} 3104\`\`\` 3105 3106## Deploying to Production 3107 3108Before deploying, store your API key securely: 3109 3110\`\`\`bash 3111firebase functions:secrets:set KEPLARS_API_KEY 3112\`\`\` 3113 3114Deploy your Cloud Functions: 3115 3116\`\`\`bash 3117firebase deploy --only functions 3118\`\`\` 3119 3120Your endpoint will be available at: 3121 3122\`\`\`text 3123https://us-central1-your-project-id.cloudfunctions.net/keplarsEmail 3124\`\`\` 3125 3126## Security Best Practices 3127 3128For production deployments, we recommend the following. 3129 3130### Restrict CORS 3131 3132\`\`\`typescript 3133res.set( 3134 "Access-Control-Allow-Origin", 3135 "https://yourdomain.com" 3136); 3137\`\`\` 3138 3139### Add Firebase Authentication 3140 3141\`\`\`typescript 3142import * as admin from "firebase-admin"; 3143 3144const token = 3145 req.headers.authorization?.split("Bearer ")[1]; 3146 3147const decodedToken = 3148 await admin.auth().verifyIdToken(token); 3149\`\`\` 3150 3151### Protect Secrets 3152 3153Never commit API keys to Git. Use Firebase Secrets Manager: 3154 3155\`\`\`bash 3156firebase functions:secrets:set KEPLARS_API_KEY 3157\`\`\` 3158 3159## Email Delivery Response 3160 3161A successful API response returns the following delivery information. 3162 3163\`\`\`json 3164{ 3165 "id": "msg_...", 3166 "object": "email", 3167 "status": "queued", 3168 "created_at": "2026-01-22T22:14:04.470Z" 3169} 3170\`\`\` 3171 3172This makes it easy to track email activity inside your application. 3173 3174## Final Thoughts 3175 3176Firebase simplifies backend infrastructure. Keplars simplifies email infrastructure. 3177 3178Together, they provide a powerful solution for developers who need reliable transactional and scheduled email delivery without maintaining complex mail servers. 3179 3180If you're already using Firebase Cloud Functions, integrating Keplars takes only a few minutes and gives your application access to scalable, production-ready email delivery. 3181 3182Useful Links: 3183
3184- [Firebase Integration Docs](https://docs.keplars.com/integrations/firebase) 3185- [Keplars Platform](https://keplars.com) 3186- [Documentation](https://docs.keplars.com)`},{id:"p10",title:"Send Transactional Emails with Supabase Edge Functions Using Keplars",slug:"supabase-edge-functions-email-keplars",excerpt:"Deploy a production-ready Edge Function and send transactional, HTML, and scheduled emails directly from your Supabase project in minutes using Keplars.",seoTitle:"Send Emails with Supabase Edge Functions | Keplars Integration Guide",seoDescription:"Learn how to send transactional, HTML, and scheduled emails from Supabase Edge Functions using Keplars. Full setup guide with TypeScript, React, and Next.js examples.",seoKeywords:["supabase edge functions email","send email supabase","keplars supabase","supabase transactional email","supabase email integration","edge functions email api","supabase email typescript","send email from supabase functions","keplars","email infrastructure supabase","supabase serverless email","developer email tools"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Send Transactional Emails with Supabase Edge Functions Using Keplars",description:"Deploy a production-ready Edge Function inside your Supabase project using Keplars. Supports template-based, HTML, plain-text, and scheduled email delivery with Deno and TypeScript.",image:"https://cdn.keplersmail.com/blogs/integrate-supabase.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-03-11",dateModified:"2026-03-11",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/supabase-edge-functions-email-keplars"}},date:"Mar 11, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/integrate-supabase.png",content:`Supabase has become one of the most popular backend platforms for modern applications. With PostgreSQL, Authentication, Storage, Realtime, and Edge Functions built in, developers can build and scale products faster than ever. 3187 3188But when it comes to sending transactional emails such as welcome emails, password resets, verification codes, notifications, and newsletters, developers still need a reliable email infrastructure. 3189 3190That's where Keplars comes in. 3191 3192With the Keplars Supabase Integration, you can deploy a production-ready Edge Function and start sending emails directly from your Supabase project in just a few minutes. 3193 3194## Why Use Keplars with Supabase? 3195 3196The integration is built specifically for Supabase Edge Functions and provides: 3197 3198* Template-based emails 3199* HTML and plain-text emails 3200* Scheduled email delivery 3201* Instant email delivery (0-5 seconds) 3202* Deno + TypeScript support 3203* Optional JWT authentication 3204* Production-ready deployment 3205 3206Whether you're building a SaaS platform, marketplace, mobile application, AI product, or internal tool, Keplars makes email delivery simple and scalable. 3207 3208## Getting Started 3209 3210### 1. Clone the Example Repository 3211 3212Start by cloning the official example: 3213 3214\`\`\`bash 3215git clone https://github.com/KeplarsHQ/supabase-example.git 3216 3217cd supabase-example 3218\`\`\` 3219 3220### 2. Configure Your API Key 3221 3222Navigate to the Supabase folder: 3223 3224\`\`\`bash 3225cd supabase 3226 3227cp .env.local.example .env.local 3228\`\`\` 3229 3230Add your Keplars API key: 3231 3232\`\`\`env 3233KEPLARS_API_KEY=kms_your_actual_api_key_here 3234\`\`\` 3235 3236### 3. Start Supabase Locally 3237 3238Launch your local Supabase environment: 3239 3240\`\`\`bash 3241supabase start 3242\`\`\` 3243 3244Your Edge Function will be available at: 3245 3246\`\`\`text 3247http://127.0.0.1:54321/functions/v1/keplars-email-function 3248\`\`\` 3249 3250## Send Your First Email 3251 3252Once the function is running, sending emails is as simple as making an HTTP request. 3253 3254### Template-Based Email 3255 3256\`\`\`json 3257{ 3258 "to": ["[email protected]"], 3259 "template_id": "your_template_id", 3260 "params": { 3261 "user_name": "John Doe", 3262 "verification_code": "123456" 3263 }, 3264 "delivery_type": "instant" 3265} 3266\`\`\` 3267 3268Perfect for: 3269 3270* Welcome emails 3271* Email verification 3272* OTP delivery 3273* Password reset emails 3274* Transactional notifications 3275 3276### Plain Text Emails 3277 3278Need something simple? 3279 3280\`\`\`json 3281{ 3282 "to": ["[email protected]"], 3283 "subject": "Welcome!", 3284 "body": "Thanks for signing up. We're excited to have you.", 3285 "delivery_type": "instant" 3286} 3287\`\`\` 3288 3289### HTML Emails 3290 3291For complete control over your email design: 3292 3293\`\`\`json 3294{ 3295 "to": ["[email protected]"], 3296 "subject": "Welcome!", 3297 "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>", 3298 "is_html": true, 3299 "delivery_type": "instant" 3300} 3301\`\`\` 3302 3303HTML emails are ideal for: 3304 3305* Product announcements 3306* Marketing campaigns 3307* Customer onboarding 3308* Event invitations 3309 3310### Scheduled Emails 3311 3312Keplars also supports scheduled delivery with timezone support. 3313 3314\`\`\`json 3315{ 3316 "to": ["[email protected]"], 3317 "subject": "Weekly Newsletter", 3318 "html": "<h1>This Week's Updates</h1>", 3319 "scheduled_at": "2026-01-25T10:00:00",
3320 "timezone": "America/New_York" 3321} 3322\`\`\` 3323 3324Use scheduled delivery for: 3325 3326* Weekly newsletters 3327* Subscription reminders 3328* Product launches 3329* Time-based workflows 3330 3331## Calling Keplars from Supabase 3332 3333One of the biggest advantages of this integration is how naturally it fits into existing Supabase applications. 3334 3335### JavaScript / TypeScript Example 3336 3337\`\`\`typescript 3338import { createClient } from '@supabase/supabase-js' 3339 3340const supabase = createClient( 3341 'https://your-project-ref.supabase.co', 3342 'your-anon-key' 3343) 3344 3345const { data, error } = 3346 await supabase.functions.invoke( 3347 'keplars-email-function', 3348 { 3349 body: { 3350 to: ['[email protected]'], 3351 template_id: 'your_template_id', 3352 params: { 3353 user_name: 'John', 3354 verification_code: '123456' 3355 }, 3356 delivery_type: 'instant' 3357 } 3358 } 3359 ) 3360 3361if (error) { 3362 console.error(error) 3363} else { 3364 console.log(data) 3365} 3366\`\`\` 3367 3368This makes email delivery feel like a native part of the Supabase ecosystem. 3369 3370### React Example 3371 3372If you're building a React application, you can trigger emails like this: 3373 3374\`\`\`tsx 3375import { useSupabaseClient } 3376from '@supabase/auth-helpers-react' 3377 3378function WelcomeEmail() { 3379 const supabase = useSupabaseClient() 3380 3381 const sendWelcome = async ( 3382 email: string, 3383 name: string 3384 ) => { 3385 await supabase.functions.invoke( 3386 'keplars-email-function', 3387 { 3388 body: { 3389 to: [email], 3390 template_id: 3391 'your_welcome_template_id', 3392 params: { 3393 user_name: name 3394 } 3395 } 3396 } 3397 ) 3398 } 3399 3400 return ( 3401 <button 3402 onClick={() => 3403 sendWelcome( 3404 '[email protected]', 3405 'Jane' 3406 ) 3407 } 3408 > 3409 Send Welcome Email 3410 </button> 3411 ) 3412} 3413\`\`\` 3414 3415### Next.js Integration 3416 3417Using Supabase with Next.js? You can trigger emails directly from API routes. 3418 3419\`\`\`typescript 3420import { createClient } 3421from '@supabase/supabase-js' 3422 3423export async function POST( 3424 request: Request 3425) { 3426 const { email, name } = 3427 await request.json() 3428 3429 const supabase = createClient( 3430 process.env.NEXT_PUBLIC_SUPABASE_URL!, 3431 process.env.SUPABASE_SERVICE_ROLE_KEY! 3432 ) 3433 3434 const { data, error } = 3435 await supabase.functions.invoke( 3436 'keplars-email-function', 3437 { 3438 body: { 3439 to: [email], 3440 template_id: 3441 process.env.KEPLARS_TEMPLATE_ID, 3442 params: { 3443 user_name: name 3444 } 3445 } 3446 } 3447 ) 3448 3449 return Response.json({ 3450 success: !error, 3451 data 3452 }) 3453} 3454\`\`\` 3455 3456## Deploying to Production 3457 3458Once you're ready to go live, follow these steps. 3459 3460### Link Your Project 3461 3462\`\`\`bash 3463supabase link --project-ref your-project-ref 3464\`\`\` 3465 3466### Store Secrets Securely 3467 3468\`\`\`bash 3469supabase secrets set \\ 3470KEPLARS_API_KEY=kms_your_actual_api_key_here 3471\`\`\` 3472 3473### Deploy the Function 3474 3475\`\`\`bash 3476supabase functions deploy \\ 3477keplars-email-function 3478\`\`\` 3479 3480Your endpoint will be available at: 3481 3482\`\`\`text 3483https://your-project-ref.supabase.co/functions/v1/keplars-email-function 3484\`\`\` 3485 3486## Production Security 3487 3488For production deployments, we strongly recommend enabling JWT verification. 3489 3490Update your \`supabase/config.toml\`: 3491 3492\`\`\`toml 3493[functions.keplars-email-function] 3494verify_jwt = true 3495\`\`\` 3496 3497This ensures only authenticated users can invoke your email endpoint. 3498 3499## Email Delivery Response 3500 3501Successful requests return the following delivery metadata. 3502 3503\`\`\`json 3504{ 3505 "id": "msg_...", 3506 "object": "email", 3507 "status": "queued", 3508 "from": "[email protected]", 3509 "to": ["[email protected]"], 3510 "created_at": "2026-01-22T22:14:04.470Z" 3511} 3512\`\`\` 3513 3514This makes it easy to track and monitor email activity across your application. 3515 3516## Why Developers Choose This Integration 3517 3518Developers already use Supabase to simplify backend infrastructure. Keplars does the same for email infrastructure. 3519 3520Instead of managing SMTP servers, provider integrations, deliverability issues, retries, and email queues, you can deploy a single Edge Function and start sending production-ready emails immediately. 3521 3522## Final Thoughts 3523 3524Supabase Edge Functions provide a powerful serverless environment for modern applications. Combined with Keplars, they become a complete communication layer capable of sending transactional, marketing, and scheduled emails at scale. 3525 3526If you're already building with Supabase, integrating Keplars takes only a few minutes and gives your application access to reliable, developer-friendly email delivery from day one. 3527 3528Useful Links: 3529
3530- [Supabase Integration Docs](https://docs.keplars.com/integrations/supabase) 3531- [Keplars Platform](https://keplars.com) 3532- [Documentation](https://docs.keplars.com)`},{id:"p11",title:"Keplars SDKs Are Now Available in 11 Languages",slug:"keplars-sdks-11-languages",excerpt:"Official Keplars SDKs and examples are now available across 11 programming languages - from Node.js and Python to Go, Rust, Flutter, and Swift - making it easier than ever to integrate email delivery into any stack.",seoTitle:"Keplars SDKs in 11 Languages | Email Infrastructure for Every Stack",seoDescription:"Keplars now provides official SDKs and integration examples for Node.js, Python, Go, PHP, Ruby, Rust, Kotlin, Dart, Elixir, C++, and Swift. Get productive fast with native email delivery.",seoKeywords:["keplars sdk","email sdk nodejs","email sdk python","email sdk go","keplars nodejs","keplars python","keplars go sdk","transactional email sdk","email api sdk","keplars","developer email tools","email infrastructure sdk","multi-language email sdk"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Keplars SDKs Are Now Available in 11 Languages",description:"Official Keplars SDKs are now available across 11 programming languages including Node.js, Python, Go, PHP, Ruby, Rust, Kotlin, Dart, Elixir, C++, and Swift.",image:"https://cdn.keplersmail.com/blogs/all-sdks-banner.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-15",dateModified:"2026-05-15",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/keplars-sdks-11-languages"}},date:"May 15, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/all-sdks-banner.png",content:`When developers evaluate a platform, the first question is rarely about features. 3533 3534It's usually much simpler: 3535 3536**"How quickly can I integrate this into my stack?"** 3537 3538No matter how powerful a platform is, adoption becomes difficult if developers need to spend hours reading API documentation, writing custom wrappers, or handling low-level HTTP requests. 3539 3540At Keplars, we've always believed that email infrastructure should be easy to integrate, regardless of the language or framework you're using. 3541 3542That's why we're excited to announce the release of official Keplars SDKs and examples across **11 programming languages**, making it easier than ever for developers to integrate email delivery into their applications. 3543 3544## Why SDKs Matter 3545 3546Modern development teams work across a diverse ecosystem of languages and frameworks. Some teams build backend services in Go. Others rely on Node.js, Python, PHP, or Ruby. Mobile developers often work with Flutter or Swift, while performance-focused teams may prefer Rust or C++. 3547 3548While our REST API is available to everyone, developers shouldn't have to build custom integrations every time they want to send an email. 3549 3550A well-designed SDK provides: 3551 3552* Faster integration 3553* Better developer experience 3554* Strong typing and validation 3555* Cleaner codebases 3556* Easier maintenance 3557* Consistent implementation patterns 3558 3559In short, SDKs allow developers to focus on building products instead of infrastructure. 3560 3561## Official SDKs Available Today 3562 3563Keplars now provides SDKs and examples for: 3564 3565* Node.js 3566* Python 3567* Go 3568* PHP 3569* Ruby 3570* Rust 3571* Kotlin / Java 3572* Dart / Flutter 3573* Elixir / Phoenix 3574* C++ 3575* Swift (iOS) 3576 3577Whether you're building a SaaS platform, mobile application, AI product, marketplace, or internal business tool, there's now a native way to integrate Keplars into your workflow. 3578 3579## One Goal: Get Developers Productive Faster 3580 3581The purpose of these SDKs isn't simply to support more languages. The goal is to reduce the time between creating a Keplars account and sending your first email. 3582 3583Instead of spending hours configuring integrations, developers can install an SDK using their preferred package manager and begin sending emails within minutes. 3584 3585### Node.js 3586 3587\`\`\`bash 3588npm install keplars 3589\`\`\` 3590 3591### Python 3592 3593\`\`\`bash 3594pip install keplars 3595\`\`\` 3596 3597### Go 3598 3599\`\`\`bash 3600go get github.com/KeplarsHQ/go-sdk 3601\`\`\` 3602 3603### PHP 3604 3605\`\`\`bash 3606composer require keplars/email-sdk 3607\`\`\` 3608 3609This simple experience is something we wanted to provide consistently across every supported language. 3610 3611## More Than SDKs 3612 3613While SDKs are often the fastest path to integration, we understand that every team has different requirements. Some organizations prefer direct API calls. Others rely on SMTP-based workflows. Many teams work within established frameworks and want examples tailored to their environment. 3614 3615That's why we've also released a comprehensive collection of examples covering multiple integration patterns. 3616 3617Developers can find examples for: 3618 3619* Express.js 3620* Flask 3621* Laravel 3622* Rails 3623* Phoenix 3624* Flutter 3625* Kotlin 3626* Swift 3627* Native HTTP clients 3628* SMTP implementations 3629* REST API integrations 3630 3631The objective is simple: meet developers where they already are. 3632 3633## Supporting Modern Development Workflows 3634 3635Today's applications are built differently than they were a decade ago. A single product might include: 3636 3637* A React frontend 3638* A Node.js API 3639* Python AI services 3640* Mobile applications built with Flutter
3641* Background workers written in Go 3642* Internal tools running on PHP 3643 3644Email communication often spans all of these systems. By providing SDKs across multiple ecosystems, Keplars allows teams to maintain a consistent email infrastructure regardless of the technology stack behind each service. 3645 3646## Built for Production 3647 3648Developer experience is important, but reliability matters even more. 3649 3650Every SDK is designed to work seamlessly with the Keplars platform, enabling developers to build: 3651 3652* Transactional email systems 3653* Authentication workflows 3654* Verification emails 3655* Password reset flows 3656* Marketing campaigns 3657* Notifications and alerts 3658* Scheduled email workflows 3659 3660All while leveraging the same underlying infrastructure. 3661 3662## Why This Release Matters 3663 3664Email remains one of the most important communication channels on the internet. Yet integrating email into an application often involves dealing with multiple providers, authentication methods, API implementations, and framework-specific challenges. 3665 3666Our goal with these SDKs is to remove that complexity. Developers should be able to choose the tools they love and still have access to reliable email infrastructure without additional friction. 3667 3668This release is a significant step toward that vision. 3669 3670## What's Next 3671 3672Supporting 11 languages is not the finish line. We'll continue improving our SDKs, expanding examples, enhancing documentation, and building tools that make email infrastructure easier for developers around the world. 3673 3674Whether you're building your first side project or scaling a production platform serving millions of users, we want Keplars to be the easiest way to integrate email into your application. 3675 3676Useful Links: 3677 3678- [Keplars Platform](https://keplars.com) 3679- [Documentation](https://docs.keplars.com)`},{id:"p12",title:"Introducing Keplars Automations: Build Powerful Email Workflows in Minutes",slug:"keplars-automations-email-workflows",excerpt:"Keplars Automations is a visual workflow builder that lets you create intelligent email journeys including onboarding, trials, re-engagement, and more, triggered directly from your application.",seoTitle:"Keplars Automations | Build Email Workflows in Minutes",seoDescription:"Keplars Automations lets developers and teams build visual email workflows with event-based triggers, conditions, delays, and dynamic personalization, all in one platform.",seoKeywords:["email automation","keplars automations","email workflow builder","transactional email automation","email drip campaign","onboarding email workflow","event-driven email","keplars","email infrastructure automation","visual email workflow","developer email automation"],jsonLd:{"@context":"https://schema.org","@type":"BlogPosting",headline:"Introducing Keplars Automations: Build Powerful Email Workflows in Minutes",description:"Keplars Automations is a visual workflow builder for intelligent email journeys. Trigger workflows from your application via API, branch on user behavior, and personalize every message.",image:"https://cdn.keplersmail.com/blogs/automation_thumbnail.png",author:{"@type":"Organization",name:"Keplars"},publisher:{"@type":"Organization",name:"Keplars",logo:{"@type":"ImageObject",url:"https://keplars.com/logo.png"}},datePublished:"2026-05-20",dateModified:"2026-05-20",mainEntityOfPage:{"@type":"WebPage","@id":"https://keplars.com/blog/keplars-automations-email-workflows"}},date:"May 20, 2026",author:"Debojyoti Singha",authorImage:"https://cdn.keplersmail.com/deb.jpg",authorLink:"https://www.linkedin.com/in/debojyoti452/",authorGithub:"https://github.com/debojyoti452",category:"Product",image:"https://cdn.keplersmail.com/blogs/automation_thumbnail.png",content:`Sending emails is only one part of modern communication. 3680 3681The real challenge is delivering the right message at the right time based on what users do inside your product. 3682 3683A new user signs up. A customer completes a purchase. A trial account is about to expire. A user opens an email but doesn't take action. 3684 3685These moments are where automation becomes powerful. 3686 3687Today, we're excited to introduce **Keplars Automations**: a visual workflow builder that allows businesses and developers to create intelligent email journeys without building custom workflow infrastru
3687cture. 3688 3689Learn more at [keplars.com](https://keplars.com). 3690 3691--- 3692 3693## Why We Built Automations 3694 3695Most teams eventually need workflows such as: 3696 3697* Welcome email series 3698* User onboarding journeys 3699* Trial conversion campaigns 3700* Post-purchase follow-ups 3701* Re-engagement sequences 3702* Customer lifecycle communications 3703 3704The problem is that these workflows often require multiple tools. One platform stores contacts. Another sends emails. A third handles automation. A fourth tracks engagement. 3705 3706As products grow, communication becomes fragmented. We built Keplars Automations to bring everything together into a single platform. Emails, automations, tracking, templates, contacts, and workflows all in one place. 3707 3708--- 3709 3710## Built for Simplicity 3711 3712One of our goals was making automations feel intuitive. Creating a workflow is as simple as connecting visual blocks together. 3713 3714\`\`\`text 3715User Signs Up 3716 â 3717Send Welcome Email 3718 â 3719Wait 3 Days 3720 â 3721Email Opened? 3722 â â 3723 Yes No 3724 â â 3725 Add Tag Send Follow-up 3726 engaged 3727\`\`\` 3728 3729No workflow engine to build. No cron jobs to manage. No scheduling infrastructure to maintain. Simply create the workflow, activate it, and Keplars handles the execution automatically. 3730 3731--- 3732 3733## Trigger Automations From Your Application 3734 3735Keplars provides a public Automations API, allowing your application to trigger workflows whenever important events occur. 3736 3737For example, when a user signs up: 3738 3739\`\`\`bash 3740curl -X POST https://api.keplars.com/api/v1/public/automations/events/track \\ 3741 -H "Authorization: Bearer YOUR_ADMIN_KEY" \\ 3742 -H "Content-Type: application/json" \\ 3743 -d '{ 3744 "email": "[email protected]", 3745 "event_name": "user_signed_up", 3746 "properties": { 3747 "plan": "pro" 3748 } 3749 }' 3750\`\`\` 3751 3752If you have an automation configured with the trigger \`user_signed_up\`, Keplars automatically enrolls the contact and starts the workflow. A single API call can trigger an entire customer journey. 3753 3754--- 3755 3756## Direct Enrollment 3757 3758Need complete control over which workflow a user enters? 3759 3760You can directly enroll contacts into a specific automation: 3761 3762\`\`\`bash 3763curl -X POST https://api.keplars.com/api/v1/public/automations/add-automation/AUTOMATION_ID/enroll \\ 3764 -H "Authorization: Bearer YOUR_ADMIN_KEY" \\ 3765 -H "Content-Type: application/json" \\ 3766 -d '{ 3767 "email": "[email protected]" 3768 }' 3769\`\`\` 3770 3771This is ideal for onboarding flows, sales processes, customer success journeys, and enterprise workflows. 3772 3773--- 3774 3775## Built Around Communication 3776 3777Unlike generic automation platforms, Keplars Automations were designed specifically for email workflows. 3778 3779Everything is integrated: 3780 3781* Transactional emails 3782* Marketing emails 3783* Email templates 3784* Email automations 3785* Real-time tracking 3786* Contact management 3787* OAuth sending 3788* Custom domains 3789* APIs and SDKs 3790 3791Instead of connecting multiple products together, your communication stack lives in a single platform. 3792 3793--- 3794 3795## Smart Workflow Conditions 3796 3797Modern communication should react to user behavior. 3798 3799Keplars allows workflows to branch automatically based on: 3800 3801* Email opens 3802* Email clicks 3803* Delivery status 3804* Contact attributes 3805* Event properties 3806 3807\`\`\`text 3808Send Welcome Email 3809 â 3810Wait 3 Days 3811 â 3812Email Opened? 3813 â â 3814 Yes No 3815 â â 3816 Add Tag Send Reminder 3817\`\`\` 3818 3819Users who engage move into one journey while inactive users receive additional follow-ups. Everything happens automatically. 3820 3821--- 3822 3823## Dynamic Personalization 3824 3825Every email can be personalized using contact and event data. 3826 3827\`\`\`html 3828Hello {{firstName}}, 3829 3830Welcome to Keplars. 3831\`\`\` 3832 3833\`\`\`html 3834Your {{event.plan}} subscription is now active. 3835\`\`\` 3836 3837Templates, subjects, and workflow emails all support dynamic variables. 3838 3839--- 3840 3841## Common Use Cases 3842 3843### SaaS Onboarding 3844 3845\`\`\`text 3846user_signed_up 3847 â 3848Welcome Email 3849 â 38502 Day Delay 3851 â 3852Product Tips Email 3853\`\`\` 3854 3855### Trial Conversion 3856 3857\`\`\`text 3858trial_started 3859 â 3860Getting Started Email 3861 â 38625 Day Delay 3863 â 3864Upgrade Reminder 3865\`\`\` 3866 3867### Post-Purchase Workflow 3868 3869\`\`\`text 3870purchase_completed 3871 â 3872Thank You Email 3873 â 38747 Day Delay 3875 â 3876Review Request 3877\`\`\` 3878 3879### Re-Engagement Campaign 3880 3881\`\`\`text 3882inactive_user 3883 â 3884Come Back Email 3885 â 3886Wait 3887 â 3888Opened? 3889\`\`\` 3890 3891--- 3892 3893## Designed for Developers and Teams 3894 3895Developers get: 3896 3897* Event-driven APIs 3898* Direct enrollment APIs 3899* Contact management APIs 3900* Secure scoped API keys 3901* Dynamic variables 3902* Real-time workflow execution 3903 3904Marketing and operations teams get: 3905 3906* Visual workflow builder 3907* No-code automation creation 3908* Email templates 3909* Contact segmentation 3910* Behavioral workflows 3911
3912The result is a platform that works equally well for technical and non-technical users. 3913 3914--- 3915 3916## Why Teams Choose Keplars Automations 3917 3918Most automation platforms either focus on generic workflows or require multiple products to build a complete communication stack. 3919 3920Keplars combines all of the following into a single experience: 3921 3922- Email infrastructure 3923- Transactional emails 3924- Marketing emails 3925- Templates 3926- Tracking 3927- Contacts 3928- Automations 3929 3930That means fewer tools, simpler workflows, and faster execution. 3931 3932--- 3933 3934## Get Started 3935 3936Keplars Automations are available today. 3937 3938Useful Links: 3939 3940- [Automations Documentation](https://docs.keplars.com/automations) 3941- [API Reference](https://docs.keplars.com/docs/automations) 3942- [Keplars Platform](https://keplars.com)`}],p=[...c,...m,...d];var u=e.i(71645),h=e.i(77374);let g={fontFamily:"var(--font-merriweather), Georgia, serif"},y={paddingTop:"calc(var(--announcement-bar-height, 0px) + 68px + 3rem)"},f=new Set(["product","engineering","community"]),b=e=>new Date(e);e.s(["default",0,function(){let e=(0,a.useRouter)(),n=(0,a.useSearchParams)(),w=n.get("category"),v=(0,u.useMemo)(()=>{let e;return e=w?.toLowerCase()??"",f.has(e)?e.charAt(0).toUpperCase()+e.slice(1):"All"},[w]),k=(0,u.useMemo)(()=>[..."All"===v?p:"Product"===v?d:"Engineering"===v?c:m].sort((e,t)=>b(t.date).getTime()-b(e.date).getTime()),[v]),P=(0,u.useCallback)(t=>{let a=new URLSearchParams(n.toString());"All"===t?a.delete("category"):a.set("category",t.toLowerCase());let i=a.toString();e.push(`/blog${i?`?${i}`:""}`)},[e,n]),S=(0,u.useCallback)(t=>{e.push(`/blog/${t}`)},[e]);return(0,t.jsxs)("section",{className:"relative bg-background",style:{overflowX:"clip"},children:[(0,t.jsx)("div",{className:"relative overflow-hidden bg-lightblue px-4 lg:px-6",style:y,children:(0,t.jsxs)("div",{className:"max-w-4xl mx-auto pt-12 pb-12 md:pt-16 md:pb-16 text-center relative z-10",children:[(0,t.jsx)("h1",{className:"text-4xl xs:text-5xl sm:text-6xl lg:text-7xl font-bold text-appred mb-6 leading-[1.2] xs:leading-[1.15] sm:leading-[1.1] lg:leading-[1.05] tracking-tight",style:g,children:"Grab a Coffee, Read On"}),(0,t.jsx)("p",{className:"text-base sm:text-lg text-lightergrey max-w-2xl mx-auto",children:"Engineering deep-dives, product updates, and community tutorials on transactional email infrastructure, developer tools, and email deliverability."})]})}),(0,t.jsx)("div",{className:"px-4 lg:px-6 mt-10",children:(0,t.jsxs)("div",{className:"max-w-7xl mx-auto",children:[(0,t.jsx)("div",{className:"flex items-center gap-2 mb-8 overflow-x-auto pb-1 scrollbar-hide",children:["All","Product","Engineering","Community"].map(e=>{let a;return(0,t.jsx)("button",{onClick:()=>P(e),className:`${(a=v===e,`px-4 py-2 rounded-full text-xs font-medium transition-all duration-200 flex-shrink-0 ${a?"bg-appred text-verylightred border border-appdarkred":"bg-lightgrey border border-lightborder text-foreground hover:bg-[#e5e5e5]"}`)} select-none`,style:g,"aria-pressed":v===e,children:e},e)})}),(0,t.jsx)("div",{className:"grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-6",children:k.length>0?k.map((e,a)=>(0,t.jsxs)("article",{className:"group cursor-pointer",onClick:()=>S(e.slug),children:[(0,t.jsx)("div",{className:"relative w-full bg-lightgrey border border-lightborder rounded-lg overflow-hidden mb-4",children:(0,t.jsx)(i.default,{src:e.image,alt:e.title,width:1600,height:1e3,sizes:"(max-width: 640px) 100vw, (max-width: 1024px) 50vw, 33vw",className:"w-full h-auto block",priority:a<6})}),(0,t.jsx)("h3",{className:"text-base sm:text-lg font-bold text-foreground mb-3 line-clamp-2 leading-tight group-hover:text-appdarkred transition-colors",style:g,children:e.title}),(0,t.jsxs)("div",{className:"flex items-center gap-2 text-xs text-grey",children:[(0,t.jsx)(i.default,{src:e.authorImage,alt:e.author,width:24,height:24,className:"rounded-full object-cover"}),e.authorLink?(0,t.jsx)("a",{href:e.authorLink,target:"_blank",rel:"noopener noreferrer",className:"font-medium hover:text-appdarkred transition-colors",onClick:e=>e.stopPropagation(),children:e.author}):(0,t.jsx)("span",{className:"font-medium",children:e.author}),e.authorGithub&&(0,t.jsxs)(t.Fragment,{children:[(0,t.jsx)("span",{children:"·"}),(0,t.jsx)("a",{href:e.authorGithub,target:"_blank",rel:"noopener noreferrer",className:"hover:text-foreground transition-colors",title:"View GitHub Repository",onClick:e=>e.stopPropagation(),children:(0,t.jsx)(s.Github,{className:"w-3.5 h-3.5"})})]}),(0,t.jsx)("span",{children:"·"}),(0,t.jsx)("time",{children:e.date})]})]},e.id)):(0,t.jsx)("div",{className:"col-span-full text-center py-12",children:(0,t.jsx)("p",{className:"text-grey text-sm",children:"Community"===v?"Blogs from our community coming soon":"Product"===v?"Product blogs coming soon":"No blog posts yet. Check back soon!"})})})]})}),(0,t.jsx)("div",{className:"px-4 lg:px-6 mt-16",children:(0,t.jsx)(h.HatchedDivider,{className:"-mx-4 lg:-mx-6"})}),(0,t.jsx)("div",{className:"px-4 lg:px-6 py-16 overflow-hidden",style:{backgroundColor:"var(--veryverylightblue)",backgroundImage:"linear-gradient(var(--verylightblue) 1px, transparent 1px), linear-gradient(90deg, var(--verylightblue) 1px, transparent 1px)",backgroundSize:"10px 10px",backgroundPosition:"5px 5px"},children:(0,t.jsxs)("div",{className:"max-w-7xl mx-auto flex flex-col md:flex-row md:items-center md:justify-between gap-6",children:[(0,t.jsxs)("div",{children:[(0,t.jsx)("h2",{className:"text-2xl sm:text-3xl font-bold text-foreground mb-4",style:g,children:"Built something using Keplars?"}),(0,t.jsx)("p",{className:"text-base sm:text-lg text-lightergrey max-w-md",children:"Write us your blog and share your experience with the community. We'd love to feature your story."})]}),(0,t.jsxs)(o.default,{href:"/contact",className:"bg-appred border-2 border-appdarkred text-verylightred hover:bg-appdarkred px-7 py-4 min-[480px]:px-8 min-[480px]:py-3.5 rounded-md text-base font-medium transition-colors duration-300 inline-flex items-center gap-2 justify-center select-none whitespace-nowrap group flex-shrink-0",style:{fontFamily:"var(--font-inter), Inter, sans-serif"},children:[(0,t.jsx)(r,{className:"w-4 h-4 group-hover:hidden"}),(0,t.jsx)(l,{className:"w-4 h-4 hidden group-hover:block"}),"Write to us"]})]})})]})}],91475)}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.