<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Pipedrive R&amp;D Blog - Medium]]></title>
        <description><![CDATA[Stories from Pipedrive’s product, engineering, design, marketing, localization, and many other teams - Medium]]></description>
        <link>https://medium.com/pipedrive-engineering?source=rss----2bd16bce47da---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Pipedrive R&amp;amp;D Blog - Medium</title>
            <link>https://medium.com/pipedrive-engineering?source=rss----2bd16bce47da---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:53:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/pipedrive-engineering" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[The Cure for Bad Team Fit Interviews]]></title>
            <link>https://medium.com/pipedrive-engineering/the-cure-for-bad-team-fit-interviews-548c940131ea?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/548c940131ea</guid>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[job-hunting]]></category>
            <category><![CDATA[hiring]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[job-interview]]></category>
            <dc:creator><![CDATA[Joseph Haske]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 08:53:56 GMT</pubDate>
            <atom:updated>2026-08-31T08:53:54.988Z</atom:updated>
            <content:encoded><![CDATA[<h4>A team fit interview method designed to reduce costly hiring mistakes and repeat hiring cycles</h4><p>Do you have a structured process for team fit interviews? Do your employees know how to run them effectively? In many organizations, there’s little guidance beyond, “you’re supposed to assess the fit to the team, not the person’s competencies.” Given the stakes, this isn’t enough. According to <a href="https://www.forbes.com/councils/forbeshumanresourcescouncil/2024/03/29/what-leaders-get-wrong-about-hiring-and-why-it-matters/">a Forbes article</a>:</p><blockquote>A Harvard Business Review study found that 80% of employee turnover is due to bad hiring decisions, and 45% of bad hires are attributed to a lack of process. The cost of a poor hiring decision can be quite high, with estimates ranging from a low of $18,700 to hundreds of thousands of dollars in the case of executive-level positions.</blockquote><p>Let’s do some quick napkin math on what this translates to in a real-world situation.</p><h3>A Quick Cost Calculation</h3><p>We’ll use the numbers from the Forbes article, including the lowest cost estimate of $18,700, and <a href="https://recruitbpm.com/blog/new-hire-turnover-rate-understanding-the-impact-and-strategies-for-improvement#:~:text=One%2Dthird%20of%20new%20employees,is%20preventable%20through%20strategic%20intervention.">an average rate of new hire turnover in the first 90 days of around 33%</a>. The simplest estimate assumes the bad hiring decision rate applies to the new hire turnover rate.</p><ul><li>33% of new hires leave within 90 days</li><li>80% of this turnover is due to bad hiring decisions</li></ul><p>This suggests that ~26% of hires turn over early due to bad hiring decisions. Multiply this by the number of employees hired each year and a cost of $18,700 per bad hire to get an estimated total cost.</p><ul><li>10 hires per year → ~$49,000</li><li>20 hires per year → ~$97,000</li><li>50 hires per year → ~$243,000</li></ul><p>From this quick math, it’s clear that reducing early turnover due to bad hiring decisions will lead to cost savings. Each point in the hiring process represents a lever for improving decision-making. We chose to build a process around the lever we could pull: the team fit interview.</p><p>Initially, we had no reliable way to identify a bad team fit. But by developing this interview format, we’ve learned that it’s possible. We’ve gone from “seems like a reasonable person” to being able to have conversations about how each candidate could be expected to fare within our team’s dynamic. To get to this point, my co-author, <a href="https://medium.com/u/efb3efe2c242">Martha Peterson</a>, and I first defined what a “team fit” interview should accomplish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LVVSpfH05PjDWoG8qxRtKg.png" /></figure><h3>What is a Team Fit Interview?</h3><p>The team fit interview is a guided, two-way conversation to uncover how a candidate works. It moves beyond the resume, looking at topics like how they solve problems, their preferred work dynamics, and whether their strengths shore up the current weaknesses of the team.</p><p>Just as importantly, it gives the candidate the space to judge whether the team’s dynamic is one they’d thrive in. It should provide them the feeling that they can be themselves from day one, instead of working from a bag of pre-prepared “safe” answers.</p><p>Now that we had a common definition, we needed a structure that enabled us to perform the interviews to meet that definition. We ended up breaking it down into seven sections that help encourage the candidate to come out of their shell and enable us to determine if they’re a good fit for the team.</p><h3>The 7-Section Structure</h3><p>The overall flow of the interview is divided into seven sections:</p><ul><li>Introduction</li><li>Candidate Background &amp; Motivation</li><li>Team Fit &amp; Behavioral Questions Part 1</li><li>Candidate Questions Part 1</li><li>Team Fit &amp; Behavioral Questions Part 2</li><li>Candidate Questions Part 2</li><li>Closing</li></ul><h4>Introduction</h4><p><strong>Purpose:</strong> Open up the conversation, set expectations, and reduce initial tension.<br><strong>Suggested Time:</strong> ~5 minutes</p><p>One person takes the role of interview leader. They are responsible for opening the session, keeping it on track, and closing it out. The interview opens with mutual introductions and light personal context. This is not meant as filler. The goal is to signal that the interview is a two-way interaction, introduce a more relaxed feel, and create the conditions for a conversation. By starting with lighter material, we invite the candidate to show up as a person, not just as an applicant.</p><h4>Candidate Background &amp; Motivation</h4><p><strong>Purpose:</strong> Find out more about the candidate and their interest in the role.<br><strong>Suggested Time:</strong> ~10 minutes</p><p>From the introduction, instead of jumping straight into competency checks, we focus on the candidate’s background, motivations, and personal experiences. One thing we like to do is ask them a personal experience question that’s not directly work-related, such as reflecting on a cultural surprise or culture shock they’ve experienced.</p><p>These questions help surface values, curiosity, and self-reflection. They also give space for both sides to settle in before moving into more work-related questions. The more casual opening sections help set the tone that this is an opportunity for both sides to learn about each other rather than a gauntlet of questions that the candidate needs to endure.</p><h4>Team Fit &amp; Behavioral Questions Part 1</h4><p><strong>Purpose:</strong> Evaluate the candidate’s experience, value to the team, work style, and adaptability.<br><strong>Suggested Time:</strong> ~10 minutes</p><p>In this section, we aren’t evaluating the candidate’s hard skills for the listed job, but rather what other skills they bring to the team. If the team is bad at admin, it’d be helpful to bring in someone who loves it. If the team doesn’t market itself well, it’s good to bring in someone who can help with that.</p><p>This section explores how the candidate operates in real working environments. The focus is on how they contribute value; their relationship with leadership and autonomy; how they handle ambiguity, stress, and conflict; and the kind of team dynamics that bring out their best work. The questions should be intentionally open-ended and reflective. Rather than looking for “correct” answers, we’re interested in patterns, trade-offs, and preferences.</p><p>A good example of this is, “What does good mentoring look like to you?” This is a question with no objectively correct answer; it’s purely preference-based. One time, we had a candidate with strong domain knowledge who seemed like a strong hire based on their experience. However, while following up on their answer, it became clear that they were hoping to improve even further by having the team mentor them. Unfortunately, given their existing depth, the team simply couldn’t offer the level of mentorship they were looking for. This allowed us to identify that the candidate wasn’t a good fit for the team, in spite of having strong domain knowledge.</p><h4>Candidate Questions Part 1</h4><p><strong>Purpose:</strong> Ensure the candidate has time to ask questions about the role and team.<br><strong>Suggested Time:</strong> ~5 minutes</p><p>The interview intentionally pauses mid-way to give space for the candidate’s questions. This reinforces that the decision-making process is mutual, not one-sided. Putting it mid-interview gives it dedicated time and attention rather than being treated as an afterthought.</p><p>What a candidate asks also provides a meaningful signal. The direction of the questions tells you something about the type of company they’re looking to join. Are they asking questions related to the characteristics of a startup when you’re in an enterprise environment? Are they asking about remote work when your team works mostly from the office? Both of these questions give you insight into how happy the candidate will be with the company and the team. Once the candidate has asked a few questions, it’s time to proceed to the next section. They’ll have time to finish their questions after the next section.</p><h4>Team Fit &amp; Behavioral Questions Part 2</h4><p><strong>Purpose:</strong> Evaluate how the candidate handles challenges and finish any outstanding questions from other sections.<br><strong>Suggested Time:</strong> ~10 minutes</p><p>The second part of the team fit and behavioral questions is where the secret sauce of our interview lies: a small set of miscellaneous questions. One goal of these questions is to ask things that the candidate hasn’t prepared for and possibly doesn’t have an answer for. Most of the questions are fairly routine, for example, “How do you integrate continuous learning into your work?” However, one of these questions should be on an unexpected and uncontroversial topic that steers clear of protected characteristics such as age or nationality.</p><p>Examples of good questions:</p><ul><li>Which official language of our offices’ countries is your favorite and why?</li><li>What’s your favorite football team and why?</li><li>What’s your favorite Czech TV show and why?</li></ul><p>Examples of bad questions:</p><ul><li>Which Estonian political party is your favorite?</li><li>Which is the best religion?</li><li>What is your favorite movie from the decade you were born?</li></ul><p>The question we use is similar to the ones listed above. We’ve intentionally left it out since it only works as a surprise. Although it started as a joke, it quickly became an integral part of the interview due to the value it provides. In spite of being country-specific, it’s asked of every candidate — regardless of nationality, location, or role.</p><p>One important aspect of the question is that there is no objectively right or wrong answer. What we’re really observing is how people react to surprise. Some are genuinely confused, some already have an answer, and some shut down. However, one candidate admitted they didn’t know anything about the topic, but almost immediately asked if they could Google it. The way they worked through the question and the discussion that followed told us two things: they aren’t afraid to admit what they don’t know, and they react well to ambiguity. The fact that we got to this through a natural example rather than them telling us about how they’re a “motivated self-starter” made the fit clear.</p><p>While you’re asking the miscellaneous questions, be sure to sprinkle in some on how the candidate handles challenges. As time permits, you can also finish up questions from other sections that you haven’t had a chance to ask yet.</p><h4>Candidate Questions Part 2</h4><p><strong>Purpose:</strong> Allow the candidate to ask any remaining questions.<br><strong>Suggested Time:</strong> ~5 minutes</p><p>This section give the interviewee a chance to ask any remaining questions that they may have.</p><h4>Closing</h4><p><strong>Purpose:</strong> Ensure the candidate knows the next steps and feels their time was valued.<br><strong>Suggested Time:</strong> ~5 minutes</p><p>The interview leader closes out, thanking the candidate for their time and telling them the next steps. Optionally, you can ask for feedback on the interview process. If you get some, drop it in the comments.</p><p>The seven sections handle the <em>what</em>. But when you’re in the room with two or three interviewers, a candidate, and a clock running, coordination doesn’t happen on its own.</p><h3>Tracking Interview Progress</h3><p>Our template lives in a shared document, open on every interviewer’s screen while the interview is running. It contains the full question bank, grouped by section, with a clear visual distinction between primary questions and secondary ones. We use a system where the primary questions are in black and secondary questions are in a medium gray to de-emphasize them while leaving them available in case one fits the flow better than the primary ones.</p><p>The system during the interview is straightforward: highlight a question before you ask it so the other interviewers know what’s coming. After asking the question, cross it out to have a cleaner overview of what has been asked already.</p><p>That coordination is what makes the rest possible. Without it, there was no structure; questions came from all directions, and the whole thing ended up feeling like a rapid-fire interrogation. That was exactly the atmosphere we didn’t want when the point is to find out whether we’d enjoy working with this person.</p><h3>Assessing the Candidate</h3><p>The structure and the coordination make sure candidates get asked about the same topics, in a conversation that doesn’t fall into chaos. Consistency of topics ensures there is some basis for comparison. What they don’t do is tell you what a good answer looks like. At some point you have to decide what you’re actually looking for, a process that starts with being clear on what “right for the team” actually means.</p><p>There’s no fixed formula for that and it will depend on the specific role you’re hiring for. Sometimes it’s filling one specific, known gap. For example, the team is bad at project management, so you look for someone who’s good at it. Sometimes it’s subtler, like not stacking the team with five people who all prefer technical work, leaving a gap in preference for writing documentation. The only constant is always: does this person make the team stronger than it was before?</p><p>Company and team values sit in the background of that question too. We’re not running a values checklist question by question during the interview, but it’s part of what we’re weighing during the assessment, even if it never came up explicitly in the room.</p><p>It’s worth reiterating that this interview is not a competency review. Experience and competencies will come up along the way, but the angle of the question makes the difference. One thing this format enables you to get a better feel for is who’s trying to provide “correct” answers. The “right” answer to questions about on-call work is that the candidate is willing to do it. But “willing” is ambiguous. This format encourages them to express their real feelings about it, giving you a better understanding of what their relationship is with the work. For example: “Can you tell me about your experience with on-call work: what’s worked well and what’s been challenging?” We had one candidate be upfront about the fact that it’s an unpleasant job, but understood the need and was fully willing to take on the responsibility. This is the same topic with a deeper insight, unlocking a better assessment of team fit. In the end, this honesty gave us confidence that they knew what they were in for, and highlighted them as a better fit than some of the candidates who stuck closer to the “safe” answer. So how do you improve at unlocking these insights to hire better?</p><h3>Mastering the Process</h3><h4>Start Simple</h4><p>Getting there takes practice. If you’re new to this, keep it simple, script it, pre-set the order of the questions. While setting a rigid order can make the whole experience feel less smooth, trying to improvise the structure on the first try while also evaluating a candidate is a sure-fire way to make it apparent that you don’t know what you’re doing.</p><p>If you want to hear about a real situation, consider asking for the best, worst, first, or last example instead of the generic “tell me about a time when…” This small change helps break away from the feeling of a performance assessment. It also helps guide the candidate to keep it simple and home in on a specific story instead of choosing among many.</p><p>That being said, you don’t have to force everything into a story. Since we’re looking to assess fit within the team instead of knowledge and previous performance, most of our questions are not story-evoking. Ask about what you’re interested in, for example, “What mix of remote vs in-office work do you prefer?” Once their answer is out there, the group can have a short conversation about it while the next interviewer is getting ready to ask their question.</p><h4>Stay Present</h4><p>It might seem counterintuitive to suggest having the next interviewer prepare the next question while the candidate is still talking. After all, the most common mistake in interview panels is asking something the candidate already answered because interviewers were busy preparing the next question or had a lapse in concentration during the conversation about the previous one. This means that the interviewers need to have enough familiarity with the list that they can select the next one without much thought.</p><p>You can quickly build on this familiarity by starting with the set list of ordered questions. As you improve, you can start deviating from your set list of questions more freely. If a candidate says something interesting mid-answer, this is your opportunity to have a conversation. You can ask questions not on the list. React, discuss, have a conversation. This is often where the most useful information comes from.</p><p>While that conversation is going on, actually listen. Track not just the direct answers but the indirect ones too. If a candidate explains how they handle conflict while answering a question about team dynamics, don’t ask them how they handle conflict. They will notice, and it tells them something about how the team operates, which is not the impression you want to leave when you’re trying to get someone to want to join.</p><h4>Adapt the Structure in Real Time</h4><p>Once you’ve used the template enough times to feel comfortable with it, you no longer need the structure to feel in control. That’s when you can start bending it to fit what the interview itself calls for. Maybe the candidate needs a breather from a heavy line of questioning. Maybe their Q&amp;A time ran long. Maybe something they said is worth exploring even though it’s not in the template. The structure is there to serve the conversation, not the other way around.</p><p>At this point you’ve essentially mastered the process, but there’s one more skill you need to master to get to know some candidates as people, rather than as interviewees. That’s recognizing and eliminating “professional mode.”</p><h4>Recognize “Professional Mode”</h4><p>Coming to an interview with prepared questions and answers is completely normal. But interviews naturally put people into a more formal, professional state of mind. That’s fine for competency checks, but for a team fit interview, you need to create an environment where everyone can be themselves.</p><p>Some pieces are built into the interview, such as in the Introduction where we include a hobby-related question, in Candidate Background &amp; Motivation where we ask about a culture shock, and in Team Fit &amp; Behavioral Questions Part 2 where we suggest asking a few unexpected questions. These questions aren’t meant to catch anyone out. We ask them because we actually want to know who we’re talking to. They let the candidate be themselves, without falling back on the safer, rehearsed answers.</p><p>However, some candidates will resist moving out of their professional shell. This is when you have to adapt the structure and questions to provide further encouragement. Questions that tend to do this best are purely individual preference-based, where there’s no clear right answer and no way to hedge. Once you’ve mastered this, you’ll be able to get to know any candidate well enough to know what it’s like to work with them within an hour-long interview.</p><h3>Conclusion</h3><p>Every business problem needs a business case: ours is reducing the cost of bad hiring decisions. We picked the lever we could pull, put structure around it, and are now working to master it. The end result is a process that makes room for one thing — a real conversation. That should be the main focus of a team fit interview, and it’s what makes the decision a better one. Other dimensions, such as technical prowess, have been covered in other parts of the hiring process. In the end, you’re not hiring merely a set of competencies; you’re choosing someone to spend a significant part of your day with.</p><p>This is how we made it work for our team, but feel free to make it your own. While we’d love it if you used our format, the important part is having a repeatable structure that matches your team’s dynamics.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=548c940131ea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/the-cure-for-bad-team-fit-interviews-548c940131ea">The Cure for Bad Team Fit Interviews</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Pipedrive Integration in Seconds Instead of Days]]></title>
            <link>https://medium.com/pipedrive-engineering/building-a-pipedrive-integration-in-seconds-instead-of-days-5309071f9639?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/5309071f9639</guid>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Denis Dmitriev]]></dc:creator>
            <pubDate>Tue, 16 Jun 2026 09:58:48 GMT</pubDate>
            <atom:updated>2026-06-16T09:58:47.081Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z76IbDihRU6l1esSpTTK0A.png" /></figure><p>Every developer building a Pipedrive integration hits the same wall before writing a single line of business logic.</p><p>Before you can make a single <em>API</em> call, <em>OAuth 2.0</em> alone demands four moving parts: authorization redirects, callback handling, token exchange, and token refresh.</p><p>Then you need a database, an <em>ORM</em>, environment configuration, <em>TypeScript</em> setup, and a backend that survives <em>Docker</em> startup timing issues.</p><p>And finally, you need to wire the Pipedrive API client so every company gets the correct <em>OAuth</em> token automatically.</p><p>It’s the same boilerplate every single time.</p><p>So we built a tool to generate it for you.</p><pre>npx create-pipedrive-app my-app</pre><p>The goal was simple: <strong>Get developers from zero to a working Pipedrive integration in seconds, not days.</strong></p><h3><strong>What the CLI Generates</strong></h3><p>The CLI asks only three questions:</p><ol><li>Your project name</li><li>Which database you want: <em>PostgreSQL</em>, <em>MySQL</em>, <em>SQLite</em></li><li>Whether you want App Extensions: custom panels, modals, or both.</li></ol><p>After that, it generates a complete production-ready <em>Node.js</em> + <em>TypeScript</em> project.</p><p>Here’s what you get out of the box.</p><h3><strong>OAuth 2.0 Setup</strong></h3><p>The generated app includes a complete <em>OAuth</em> flow:</p><ul><li>redirect to Pipedrive,</li><li>callback handling,</li><li>token exchange,</li><li>token refresh.</li></ul><p>The <em>OAuth</em> state parameter is <em>HMAC</em>-signed with a <em>TTL</em> to prevent replay attacks and forgery. No need to build auth infrastructure yourself.</p><h3><strong>Database + Drizzle ORM</strong></h3><p>The project includes:</p><ul><li>schema definitions,</li><li>migrations,</li><li>driver configuration,</li><li>environment setup.</li></ul><p>Everything is preconfigured for your selected database.</p><p>Even better, the application code stays identical whether you choose <em>PostgreSQL</em>, <em>MySQL</em>, or <em>SQLite</em> because <em>Drizzle</em> provides the same <em>TypeScript</em> API everywhere.</p><h3><strong>Pipedrive API Client</strong></h3><p>The scaffold includes a wrapper around the official Pipedrive Node.js SDK.</p><pre>getClient(companyId)</pre><p>This automatically:</p><ul><li>loads the correct OAuth token,</li><li>configures token refresh,</li><li>updates stored credentials when tokens change.</li></ul><p>If you use the SDK, you never manually manage OAuth tokens.</p><h3>Resilient Server Startup</h3><p>One annoying issue in <em>Docker</em>-based development is service startup order. Sometimes the <em>API</em> server starts before the database is ready. The generated src/index.ts handles this automatically by retrying database connections during startup instead of crashing immediately.</p><p>Small detail. Big quality-of-life improvement.</p><h3><strong>App Extensions Support</strong></h3><p>If you choose App Extensions, the <em>CLI</em> generates a <em>React</em> + <em>Vite</em> frontend under:</p><pre>frontend/app-extension-ui/</pre><p>The setup already includes:</p><ul><li>@pipedrive/app-extensions-sdk,</li><li>theme synchronization,</li><li>resize handling,</li><li>snackbars,</li><li>confirmation dialogs.</li></ul><p>The Express backend serves the built frontend automatically at:</p><pre>/extensions/panel<br><br>/extensions/modal</pre><p>No extra frontend hosting setup required.</p><h3><strong>Docker Compose with Live Reloading</strong></h3><p>The generated project supports:</p><pre>docker-compose up --watch</pre><p>This starts:</p><ul><li>the backend,</li><li>the <em>Vite</em> dev server,</li><li>live file synchronization for both services.</li></ul><p>Expose the <em>Vite</em> server through a public <em>HTTPS</em> tunnel and configure the <em>URL</em> in the <a href="https://developers.pipedrive.com/">Pipedrive Developer Hub</a>.</p><p>That’s it. No manual rebuilds or container restarts.</p><h3>How We Built It</h3><p>Most scaffolding tools use template folders filled with static files. We intentionally avoided that approach. There are no template files in create-pipedrive-app. Every generated file is built dynamically inside TypeScript functions using:</p><ul><li>dedent() for readable multiline strings,</li><li>conditional interpolation for optional features.</li></ul><p>For example, this is the actual OAuth state generator:</p><pre>await writeFile(<br>  join(outputDir, &#39;src/oauth/state.ts&#39;),<br>  dedent`<br>    import { createHmac, randomBytes } from &#39;node:crypto&#39;;<br><br>    const STATE_TTL_MS = 5 * 60 * 1000;<br><br>    export function createState(): string {<br>      const payload = JSON.stringify({<br>        nonce: randomBytes(16).toString(&#39;hex&#39;),<br>        exp: Date.now() + STATE_TTL_MS,<br>      });<br><br>      const encoded = base64url(payload);<br><br>      const sig = createHmac(&#39;sha256&#39;, getClientSecret())<br>        .update(encoded)<br>        .digest(&#39;base64url&#39;);<br><br>      return \`\${encoded}.\${sig}\`;<br>    }<br>  `,<br>);<br></pre><p>Every generated file is automatically formatted with <em>Prettier</em> before being written to disk. The biggest advantage is maintainability. Because generated content lives in <em>TypeScript, </em>we get:</p><ul><li>autocomplete,</li><li>type safety,</li><li>compiler checks,</li><li>refactoring support.</li></ul><p>When something changes, the compiler tells us exactly where. Traditional template folders don’t give you that.</p><h3><strong>The Builder Pattern</strong></h3><p>The CLI uses a NodeProjectBuilder + BuildStep architecture.</p><p>Each feature is implemented as an isolated step:</p><pre>interface BuildStep {<br>  execute(outputDir: string, options: GeneratorOptions): Promise&lt;void&gt;;<br>}</pre><p>The builder composes features together:</p><pre>await new NodeProjectBuilder(outputDir, options)<br>  .addDatabase()<br>  .addCrypto()<br>  .addOAuth()<br>  .addApp()<br>  .when(options.appExtensions.length &gt; 0, (b) =&gt; b.addAppExtensions())<br>  .addPipedriveClient()<br>  .addServerEntry()<br>  .addPackageJson()<br>  .build();</pre><p>The interesting part is the when() method. Conditional logic lives entirely in the builder chain. Individual steps stay simple and focused. That makes every feature independently testable and easier to maintain.</p><h3><strong>App Extensions: Routing Instead of Merging</strong></h3><p>The App Extensions frontend is a single <em>React</em> + <em>Vite</em> application. It serves both panels and modals from the same bundle using React Router.</p><pre>&lt;Routes&gt;<br>  &lt;Route path=&quot;/extensions/panel&quot; element={&lt;Panel /&gt;} /&gt;<br>  &lt;Route path=&quot;/extensions/modal&quot; element={&lt;Modal /&gt;} /&gt;<br>&lt;/Routes&gt;</pre><p>If only one extension type is selected, only that route gets generated. Panel.tsx and Modal.tsx stay completely independent. Each initializes the <em>SDK</em> separately and knows nothing about the other component. The backend simply serves the same build output under different routes. Clean separation without duplicate infrastructure.</p><h3><strong>Getting Started</strong></h3><p>Creating a new integration takes only a few commands.</p><pre>npx create-pipedrive-app my-app</pre><p>Then:</p><pre>cd my-app<br>cp .env.example .env<br>docker-compose up --watch</pre><p>Add your credentials:</p><ul><li>PIPEDRIVE_CLIENT_ID</li><li>PIPEDRIVE_CLIENT_SECRET</li></ul><p>And your service is running.</p><p>If you selected App Extensions, expose your <em>Vite</em> dev server through <em>ngrok</em>, <em>Cloudflare Tunnel</em>, or another <em>HTTPS</em> tunnel, then paste that <em>URL</em> into the Pipedrive Developer Hub.</p><p>The generated frontend already handles: <em>SDK</em> initialization, resizing, theme switching, and extension-specific actions.</p><pre>npm run build</pre><p>This compiles both the backend and the <em>Vite</em> frontend bundle.</p><p>No separate frontend deployment required.</p><h3>AI Assistant Support</h3><p>The package includes <strong>four <em>Claude Code</em> and <em>Codex</em> skills</strong> that make your AI assistant a first-class member of your Pipedrive app development workflow:</p><ul><li><strong>pipedrive-new-app: </strong>Scaffolds a new integration from scratch by running npm create-pipedrive-app interactively.<br>The skill guides you through project setup, including the app name, database selection (<em>PostgreSQL, MySQL, or SQLite</em>), and optional App Extensions support.</li><li><strong>pipedrive-add-app-extension: </strong>Adds a custom panel or modal to an existing project. <br>The skill runs the appropriate CLI command, wires the generated Express router into src/app.ts, updates docker-compose.yml with the required <em>Vite</em> service, and tells you exactly which tunnel <em>URL</em> to register in the <em>Developer Hub</em>.</li><li><strong>pipedrive-api: </strong>Answers questions about working with the Pipedrive REST API and Node.js SDK inside generated projects.<br>It can help with authentication, getClient(companyId), working with deals, persons, organizations, activities, and other resources, handling pagination, and staying within rate limits.</li><li><strong>pipedrive-review-marketplace-readiness: </strong>Performs a pre-submission review of your codebase, checking for common Marketplace requirements and best practices, including token refresh handling, <em>HTTPS</em> enforcement, error handling, and rate-limit awareness. It reports only the issues that need attention.</li></ul><p>Each skill is a lightweight instruction set designed to work directly with your project. The scaffolding skills automate <em>CLI</em> workflows, while <strong>pipedrive-api</strong> and <strong>pipedrive-review-marketplace-readiness</strong> analyze your generated code, inspect files, run relevant checks, and guide you through the results.</p><h3>Ready to Build?</h3><ul><li>NPM:<a href="https://www.npmjs.com/package/create-pipedrive-app"> https://www.npmjs.com/package/create-pipedrive-app</a></li><li>GitHub:<a href="https://github.com/pipedrive/create-pipedrive-app"> https://github.com/pipedrive/create-pipedrive-app</a></li><li>Discussion thread:<a href="https://devcommunity.pipedrive.com/t/introducing-create-pipedrive-app-scaffold-a-production-ready-pipedrive-integration-in-one-command/20348"> https://devcommunity.pipedrive.com/t/introducing-create-pipedrive-app-scaffold-a-production-ready-pipedrive-integration-in-one-command/20348</a></li></ul><p>Whether you’re building your first Pipedrive integration or your tenth, we’d love for you to try <strong>create-pipedrive-app</strong> and share your thoughts in the comments below.</p><p>Our goal is simple: <strong>make the first hour of building a Pipedrive app as fast and frictionless as possible, and your feedback will help us get there.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5309071f9639" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/building-a-pipedrive-integration-in-seconds-instead-of-days-5309071f9639">Building a Pipedrive Integration in Seconds Instead of Days</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scooby: How I Taught an AI to Be Our On-Call Engineer]]></title>
            <link>https://medium.com/pipedrive-engineering/scooby-how-i-taught-an-ai-to-be-our-on-call-engineer-163e3b3662ab?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/163e3b3662ab</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Aleksandr Smirnov]]></dc:creator>
            <pubDate>Thu, 21 May 2026 09:04:13 GMT</pubDate>
            <atom:updated>2026-05-21T09:04:12.021Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a2ktEb-_HVIr8UlepBSHWw.jpeg" /></figure><p>There’s a specific kind of frustration that every on-call engineer knows. It’s 11 pm, an alert fires, and you open five dashboards in a panic. You’re pasting log queries from memory, squinting at a Grafana panel that may or may not be the right one, or trying to find the relevant playbook somewhere in Confluence. You know the answer is somewhere in there. You just have to go find it across a dozen different tools, while also trying to figure out if this is even a real issue or just noise.</p><p>That was the itch I wanted to scratch.</p><h3>A weekend in Claude Code</h3><p>A few months ago, a colleague, <a href="https://www.linkedin.com/in/moserss/">Stephane Moser</a>, basically encouraged me to try a CLI tool built for exactly this problem: an AI-powered root cause analysis tool called <a href="https://holmesgpt.dev/latest/">HolmesGPT</a>. Point it at an alert, let the AI do the dashboard-hopping, and get an explanation back. I really wanted to love it. But the developer experience just wasn’t there: manual token creation, YAML config changes, environment-specific tweaks, etc. And after going through all the trouble of getting it ready to run, its results were not that impressive. It had no idea how our infrastructure was set up. No domain knowledge, no institutional context. Technically, the tool did what it promised. Practically, it lacked the context that would make its answers useful to us. And if a tool was going to understand our specific architecture, we were going to have to build it.</p><p>I was spending most of my day inside Claude Code anyway. One weekend, I opened it and asked: <em>“Can we turn this into a Claude Code skill?”</em></p><p>The result was a plugin I called Scooby (Warner Bros., please don’t sue me). My first move was connecting our Internal MCP server to it, which gave access to Grafana, Loki, Tempo, company metadata, deployment history, Slack, Confluence, and more. Luckily, all our services send logs to Loki, including Kubernetes events, so Scooby can map the entire lifecycle of a pod just from logs without ever needing kubectl. That’s what made it zero friction: no tokens, no YAML, just the tools already there. I tested it on boring questions like “<em>Why is this pod crashlooping in the test region?”</em> and it got there. The basics worked. But it was a smart stranger: capable in the abstract, completely ignorant of Pipedrive. I had a tool that could technically do the job. I needed one I could trust in production.</p><h3>Teaching, not writing playbooks</h3><p>Every company has its own dialect, its own tribal knowledge. Ours has grown over years of infrastructure decisions, naming conventions, routing layers, and logging standards that made sense when someone made them, and are now just <strong>how things work</strong>. A generic AI investigator doesn’t know any of that. It doesn’t know that different environments have different Loki data sources. It doesn’t know our service naming patterns or which metadata APIs to call for company-level context. It doesn’t know that what shows up in one dashboard is actually fed by a completely different system than it appears.</p><p>Scooby could query things, but access to tools isn’t the same as knowing how to use them. It still had no instincts about <strong>where to look</strong>, <strong>in what order</strong>, or <strong>what the results actually meant</strong> in our context. It was the same gap I’d hit with the off-the-shelf tool, just one layer deeper: the friction was gone, but the ignorance wasn’t.</p><p>The obvious move is to start writing rules: if alert type X, query datasource Y. But that path leads to an ever-growing playbook that covers every incident you’ve already seen and is silent on anything new. You still need to tell the system where your data sources live, which labels matter, and how to route to the right domain. But there’s a difference between telling it where the data lives and telling it what every answer should be. I didn’t want to write playbooks. I wanted to teach.</p><p>Our alert channels already contained months of history: alerts, discussion threads, and engineer explanations of what went wrong and how it was fixed. That became the training material.</p><p>The methodology I landed on works like this. Take a solved alert, one where we already know the root cause. Feed Scooby just the alert description, nothing else. Watch what it does. When it fails, don’t edit the skill file yourself. Instead, give Scooby the actual resolution. Then ask Claude a specific question: <strong><em>“Looking at what you did, how would you rewrite your own instructions so you’d solve this properly next time?”</em></strong></p><p>After enough rounds of this, I stopped feeding alerts one by one. I pointed Scooby at the channel and told it to find those resolved threads itself. Same loop, just without me hand-picking every case.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QBs8ATTg2eKR5gKwXZmhZg.png" /><figcaption>Scooby’s self-improvement loop: from failed investigation to updated skills.</figcaption></figure><p>Claude analyzes its own reasoning gaps. It identifies what it missed, why it missed it, and what heuristics it should have applied. Then it rewrites its own <em>SKILL.md</em> files: the instruction documents that define how each investigation domain works.</p><p>To give a sense of what ends up in a skill file, here’s a rule from the Kubernetes skill:</p><pre>CRITICAL: &quot;Running&quot; does NOT mean &quot;Working.&quot;<br>ALWAYS check logs even if the pod reports a healthy status.<br>Application-level errors (permission denied, connection refused,<br>config errors) hide in logs.</pre><p>Simple, but this is the kind of hard-won knowledge that only comes from real incidents. Claude wrote this after an investigation that concluded a service was healthy because the pod was running, and missed the actual error sitting in the logs. It never made that mistake again.</p><p>My role in this process is essentially editor and safety filter. Claude has a tendency to be helpful in ways that are too specific. After one incident involving a misconfigured Redis instance, it might be tempted to write: <em>“Always check Redis first.”</em> My job is to push back: be generic, be pattern-oriented, capture the class of problem, not the specific instance. The goal is accumulated wisdom, not a bug report.</p><p>Here’s a concrete example of why this matters.</p><p>Early on, Scooby was completely lost when it came to log investigations involving our OpenTelemetry-instrumented services. The problem was subtle: OTel logs use the logfmt format and are labeled with <em>service_name</em>, while our standard application logs use JSON and are labeled with <em>facility</em>. Same for Loki, completely different query patterns, different label names, different parsing logic. Scooby kept applying one approach when it needed the other, and the investigations would either return nothing or return the wrong service’s logs entirely.</p><p>I showed it a failed investigation, then showed it the correct resolution: here’s the service, here’s the log format it uses, here’s the label that identifies it, here’s the query that actually works. I asked Claude to analyze what it had missed. The gap was obvious: it had been assuming a single logging paradigm. Claude rewrote the logs skill to handle both systems, added explicit detection logic for which format to expect based on service metadata, and documented the pitfall. That mistake has never recurred.</p><p>That’s the thing about building with this method: each solved incident doesn’t just close a ticket. It makes the system permanently smarter. The knowledge gets written into the skill files and stays there.</p><p>From the start, I had a clear architectural vision: a single orchestrator skill that acts as the brain, routing incoming problems to specialized domain skills. The teaching process is what fills those skills with actual intelligence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2edclgtKRuk49hZxg__V6g.png" /></figure><p>At the center is the <em>investigate</em> skill, the entry point for every investigation. The domain skills are where the hard-won knowledge lives: logs, metrics, Kubernetes, distributed traces, slowness investigation, CI/CD failures, dashboard analysis. 7 at launch. 17 now, because new investigation patterns kept appearing, and each one needed its own expert.</p><p>Each domain skill is essentially a knowledge base that Claude wrote and continues to refine. Which datasource to query for which environment? Which labels are meaningful and which are noise? What failure modes look like, and how to distinguish a symptom from a cause.</p><p>One rule is baked into every investigation: always follow the <a href="https://en.wikipedia.org/wiki/Five_whys">five whys</a>:</p><p>1. Why is this symptom happening? → immediate cause<br>2. Why does that cause exist? → deeper cause<br>3. Why does that condition persist? → code or config path<br>4. Why is the code or config that way? → specific line or condition<br>5. Why does that line or condition exist? → root cause</p><p>This matters more for an AI than it does for a human. An LLM will happily stop at “the pod is OOMKilled” and present it with full confidence. The five whys chain forces it past that first plausible signal, through the dependency, into the code path, until it lands on something an engineer can actually fix.</p><h3>Meeting engineers in their natural habitat</h3><p>I shared Scooby with the rest of the DevOps Tooling team first, then more broadly. Getting started took less than 5 minutes via the Claude Code plugin marketplace. The initial feedback arrived faster than I expected.</p><p>Engineers started using it for on-call shifts. Support escalations that used to require pulling someone technical off their current work started going through Scooby first for initial investigation. Deployment failures that previously required a 15-45-minute tour of dashboards were diagnosed in minutes. But the use cases turned out to be broader than alert triage: engineers started using it to debug their own services during development, run proactive checks after releases, or just go through logs when something felt off. It spread through word of mouth: engineers recommending Scooby to colleagues, posting investigations, and sharing results.</p><p>Then the feature requests started coming in, and they all pointed in the same direction: “<em>Can we use it directly in Slack?”</em></p><p>This made complete sense to me. When an incident is actually happening, engineers aren’t in their editor. They’re in Slack, in the incident channel, coordinating with other people. Sending them back to a separate tool to run an investigation is exactly the kind of friction I’d built Scooby to eliminate.</p><p>We already had HAL, our internal Slack bot. Integrating Scooby with HAL was the natural move. No onboarding, no setup, just ask. The result: mention <em>@hal scooby</em> in any Slack channel or DM HAL directly with a question or an alert description, and a full investigation runs automatically. Results come back in the thread: root cause assessment, supporting evidence, Grafana links, and suggested remediation steps.</p><p>Under the hood, HAL runs Scooby on Claude Opus 4.6 with max reasoning effort. We tried a few configurations, and this is the one that consistently produces the best investigations for us: the higher reasoning budget pays for itself when the model has to chain queries across logs, metrics, and traces to land on a real root cause.</p><p>Here’s what a typical Scooby result looks like in Slack. This one started with a customer bug report: <em>“my to-do activities are showing as completed.”</em> A vague complaint, no error codes, no logs attached.</p><pre>🐕 Scooby Investigation Results<br><br>## Root Cause<br>*Redis cache failures in activity-worker&#39;s no-retry Kafka handler caused <br>activity status events to be consumed but incompletely processed, leaving <br>activity feed entries permanently stuck as &quot;done&quot;*<br><br>On 2026–05–07 at 00:12:50 UTC, activity-worker experienced 19 Redis cache SET<br>failures for this customer:<br><br>| Error                                 | Count | Code path               |<br>| - - - - - - - - - - - - - - - - - - - | - - - | - - - - - - - - - - - - |<br>| Error setting process:status in cache | 14 | process-cache.js:20        |<br>| Error setting FF value in redis       | 3  | filters/common.js:36       |<br>| Error setting feedConfig in cache     | 2  | feed-config-cache.js:30    |<br><br>All failures share the same call chain: Kafka event → handler-no-retry.js:81 →<br>satisfiesAllFilters → processFilter → Redis SET → FAILURE<br><br>The critical detail: handler-no-retry.js commits the Kafka offset even when <br>processing fails - the event is consumed and never reprocessed. <br>The &quot;undone&quot; events were silently discarded. <br><br>Source code analysis reveals a deeper problem: a race condition in Kafka domain <br>event ordering. When an activity is marked done then quickly undone, two domain <br>events are produced. Both go through enrichment and are republished to an <br>internal topic. If the done=true event is processed AFTER the done=false event <br>(due to enrichment timing or partition ordering), the action row permanently <br>ends up with done=1. There is no idempotency or event timestamp ordering guard <br>to prevent a stale &quot;done&quot; event from overwriting the correct &quot;undone&quot; state.<br><br>The forced_done guard in event-handlers/common.ts should prevent this - but it <br>only works for UI clicks, not domain events.<br><br>## Five Whys<br>1. Why are activities shown as done? → Action rows have done=1 despite user <br>   undoing them<br>2. Why wasn&#39;t the &quot;undone&quot; state written? → Redis cache failures in the filter <br>   pipeline prevented state evaluation<br>3. Why didn&#39;t the event get retried? → handler-no-retry.js commits the offset <br>   on failure<br>4. Why does re-doing done/undone not fix it? → A race condition in event <br>   ordering means stale &quot;done&quot; events can overwrite correct &quot;undone&quot; state<br>5. Why is there no ordering guard? → forced_done only protects UI-initiated <br>   actions, not domain events - no idempotency check exists<br><br>## Impact<br>3 activities incorrectly stuck as &quot;done&quot; for one customer. All other app views<br>show the correct status - isolated to the activity feed&#39;s event processing path.<br><br>## Remediation<br>1. Manually fix the 3 affected activity rows (set done=0)<br>2. Add event timestamp ordering guard: reject updates where the event is older<br>   than the action&#39;s update_time<br>3. Add retry logic in handler-no-retry.js for transient Redis failures<br><br>## GitHub Links<br>- event-handlers/common.ts - forced_done guard (line 84)<br>- handler-no-retry.js - offset commit on failure (line 81)<br><br>## Grafana Links<br>- Redis cache SET failures for this customer (May 7, 00:12–00:13 UTC) - Loki query<br>- activity-worker Kafka consumer lag - Loki query<br><br>## ELI5<br>Imagine a restaurant where a waiter marks orders as &quot;served&quot; on a whiteboard. <br>When a customer says &quot;actually, I haven&#39;t received my food,&quot; the kitchen sends <br>a note to the waiter to erase the &quot;served&quot; mark. But the waiter&#39;s eraser (Redis <br>cache) broke at that exact moment. The waiter read the note, threw it away <br>(no-retry handler), but couldn&#39;t update the whiteboard. Now the board <br>permanently shows the order as served, even though the customer is still <br>waiting. Getting a new eraser doesn&#39;t help because the note is already gone.</pre><p><em>Note: Output lightly edited: service names and internal details replaced with generic equivalents. The structure and depth of the investigation are unmodified.</em></p><p>But we took it further than that. There are three trigger modes. The first is manual mentions, where someone explicitly asks Scooby to investigate. Keyword-triggered, where HAL watches alert channels for specific patterns (alert names, error strings, whatever the team configures) and kicks off an investigation on its own. And scheduled cron investigations for proactive monitoring, where Scooby checks things on a cadence even when nobody’s actively looking.</p><p>By the time the on-call engineer reads the alert, the investigation is already running in a thread. Often, by the time they catch up, it’s finished: hypothesis, evidence, and suggested next steps. Sometimes the thread just says “this is noise, here’s why,” which is, honestly, its own kind of valuable. Alert fatigue is a real problem, and a tool that can confidently say “nothing to see here” saves time just as much as one that finds the actual root cause.</p><h3>Adoption, numbers, and limits</h3><p>From the beginning, I wanted people not just to use Scooby but to make it smarter. And that’s exactly what happened.</p><p>Engineers from other teams started looking at the skill files. The structure is readable: here’s the domain knowledge, here’s what triggers this skill, here’s how to extend it. A team that owns a specific service area added its own troubleshooting patterns for its infrastructure. Another engineer contributed an entire CI/CD domain skill for deployment pipeline failures, a class of investigation I hadn’t built for. The architecture turned out to be legible enough that other people could contribute without my involvement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*3lSsWcWG_aA-nCP_e7Hgeg.png" /><figcaption>Cumulative investigations over time, growing from 0 in early March to over 1,700 by mid-May 2025.</figcaption></figure><p>In its first two months, Scooby has run over 1,200 investigations through HAL, with an average duration of 5 minutes at a cost of around $1.60 per investigation. In a recent developer survey (146 respondents), Scooby scored a CSAT of 90 out of 100. A weekend experiment became an org-wide tool in less than a month.</p><p>We don’t have formal accuracy metrics: no benchmark suite and no ground-truth dataset. The honest measure of quality is adoption: engineers keep using it, keep configuring it in new channels, and keep contributing to it. That’s a reasonable proxy.</p><p>Scooby is also not 100% accurate, and we don’t pretend it is. It can chase a red herring, anchor on the first plausible signal, and walk straight past the actual cause. It can miss things when the relevant domain knowledge isn’t in the skills yet, or when the infrastructure has shifted in ways the skills haven’t caught up with. It can sound confident about a wrong answer. An LLM’s tone is the same whether it’s right or wrong, which is why we treat the output as input to a human, not a final answer. We frame Scooby internally as a starting hypothesis, not a verdict. It tells you where to look first. The engineer still owns the call.</p><h3>Field notes</h3><p>The best measure of a tool isn’t what the builder thinks of it. Here’s what other engineers had to say.</p><p><a href="https://www.linkedin.com/in/rubensilvadev">Ruben Silva</a>, Software Engineer:</p><blockquote>“Scooby is amazing. We often make changes quite frequently, and it helps us find gaps in our monitoring. We currently have it as a daily digest that captures signals that otherwise we wouldn’t have noticed (i.e. some tenant is acting as a noisy neighbour, not enough to trigger thresholds but worth looking into).</blockquote><blockquote>And when alerts come, we dispatch an investigation there as well. My usual workflow consists of checking production logs, deployments, and getting the right people aware of the issue if need be. Sometimes the issue can only be detected if you look at the right panels or do the right queries, which can take time to write up and find out. By the time I am still investigating the root cause, Scooby already has a pretty good view of what the issue is about (more often than not!). Not only can it find the root cause, but it can also suggest mitigation ideas (sometimes in code suggestions). During on-call, this is vital in reducing MTTD and MTTR.</blockquote><blockquote>Scooby is proof that if you have a good agentic harness + good instructions (context OR where to fetch said context) + access to tools (acquire context), you can go far with AI troubleshooting.”</blockquote><p><a href="https://www.linkedin.com/in/vahidnegahdari/">Vahid Negahdari</a>, Senior Engineering Manager, SRE:</p><blockquote>“The rate of change is increasing day by day. Signals to handle are growing at the same time. We are all aware of the risks that AI-assisted development brings. Scooby has enabled us to keep up with what’s happening, even with little prior knowledge of the new functionality or the impacted systems. It was refreshing when the Scooby pinpointed the right root cause in an incident involving a 3rd-party service provider. Such an investigation would have taken us more than a few hours to understand, triage, and validate, but with Scooby, we got the initial lead in a few minutes and spent a short time verifying the findings. It was over in 20 minutes, which was a record for incidents of that kind for us.”</blockquote><p><a href="https://www.linkedin.com/in/moserss/">Stéphane Moser</a>, Senior DevOps Engineer:</p><blockquote>“I was deep into development when an on-call engineer called me in. During the day, we faced an outage in our Deployment Workflows, causing deployments to be blocked across regions, rate limits to be exhausted, and GitHub Actions to fail. Alerts kept firing repeatedly. A first fix was deployed, but didn’t last. By day’s end, the root cause was still unknown. I conducted a quick manual investigation; something seemed off about the webhook delivery system, but I couldn’t identify what. I had a gut feeling, but no proof. I explained the symptoms to Scooby, and after 10 minutes of searching logs across various services and regions, reviewing code, and running checks, I found the cause: DNS. If it’s DNS, it’s always DNS. I documented the investigation, let AI develop a plan, and then began applying a fix.”</blockquote><h3>What’s next</h3><p>A few things are on the roadmap.</p><p><strong>First:</strong> closing the feedback loop. Right now, when Scooby gets an investigation wrong, a human has to notice, provide the correct resolution, and guide the skill rewrite. We’re building automation that analyzes bad investigations, identifies the reasoning gaps, and prepares a pull request with the improved skill files. The teaching method stays the same; it just happens without someone sitting in the loop.</p><p><strong>Second:</strong> automatic post-deployment analysis. We already have a Scooby skill for this and a working POC that triggers an investigation after every live deployment. The idea is simple: don’t wait for an alert to tell you something broke. Check proactively, every time new code hits production. We’re fixing bugs and refining the workflow now, with a full release coming soon.</p><p><strong>Third:</strong> making Scooby more accessible to support engineers. Right now, the investigations are too technical. The output assumes you know what a pod is, what OOMKilled means, or how to read a Grafana panel. The goal is to refine Scooby so that support engineers can resolve customer cases themselves without escalating to developers.</p><p><strong>Fourth:</strong> perhaps open-sourcing it. The investigation framework and domain skill structure could be made generic, stripped of Pipedrive-specific knowledge, so anyone can install it and teach Scooby their own infrastructure dialect. No promises, but I’m looking into it.</p><h3>The itch, scratched</h3><p>It’s still 11 pm when the alert fires. But now there’s already a thread with a hypothesis before you pick up your phone.</p><p>Scooby isn’t a replacement for an engineer’s judgment. It’s the part of the job that shouldn’t require judgment: finding the right dashboard, querying the right logs, correlating the timeline. The boring, repetitive, high-pressure work that eats up the first 20 minutes of every incident while the actual thinking waits.</p><p>The thing I didn’t expect was how organically it grew. I built a tool for myself, shared it with my team, and watched it become something other people contributed to and relied on. Not because I marketed it, but because it solved a real problem.</p><p>Build it where people already are. Teach it with what has already happened. The rest takes care of itself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=163e3b3662ab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/scooby-how-i-taught-an-ai-to-be-our-on-call-engineer-163e3b3662ab">Scooby: How I Taught an AI to Be Our On-Call Engineer</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pipedrive Marketplace: Scaling App Adoption]]></title>
            <link>https://medium.com/pipedrive-engineering/pipedrive-marketplace-scaling-app-adoption-84c3fbcdde94?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/84c3fbcdde94</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[product]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Dmitrii Ziuzin]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 09:46:44 GMT</pubDate>
            <atom:updated>2026-03-17T09:46:43.305Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ymc30kvMf794rlW9OaKZw.png" /></figure><h4>Using data-driven design and trust patterns to bridge the discovery gap for trial users.</h4><p>The numbers are clear: Pipedrive users with at least one app installed close 1.5x more deals. While this is a massive win for our customers, we found that 75% of trial users were simply bypassing the Marketplace, failing to recognize how integrations could impact their success.</p><p>To help small and medium-sized businesses manage their sales, our marketplace of apps provides connections to tools like Trello, Google Meet, and Zendesk. This connectivity is key to making the CRM flexible and customizable for every user.</p><p>I’m <a href="https://www.linkedin.com/in/dmitriiziuzin/">Dmitrii</a>, a Senior Product Designer at Pipedrive. I took on this mission alongside <a href="https://www.linkedin.com/in/argo-rihkrand-721139178/">Argo</a>, our Data Analyst. Our partnership was essential: Argo’s insights into user behavior helped us pinpoint exactly where the friction was, allowing me to focus the design on what would actually move the needle for the business.</p><h3>The Problem</h3><p>Our analysis revealed a consistent trend: even among users with similar engagement levels, those trial users who integrated at least one app were much more likely to become paying customers. While app integration led to a major jump in conversion, only 25% of trial users were taking this step.</p><p>Looking at the old storefront below, the friction is evident. The only way to find an app was through a basic search with no room for exploration. If users wanted to see more, they had to leave Pipedrive for our public website. This added extra steps and, most importantly, forced users to drop their main working tool right at the moment they were ready to integrate.</p><p>This navigation wall was a huge opportunity. By bringing the full marketplace experience inside the app, we could keep users focused and drive growth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YanC-VOse7cKP6ht73Ri7Q.png" /><figcaption><em>The original storefront: A limited list that forced users to leave the Pipedrive web app to see the full library.</em></figcaption></figure><blockquote><strong>Our goal was to evolve the Marketplace from a passive library into a proactive driver of engagement, supporting our strategic target to increase the percentage of trial users who install at least one app.</strong></blockquote><h3>Insights</h3><p>To understand the issue from our customers’ point of view, we conducted a series of interviews. These conversations confirmed our suspicions: the limited in-app experience created a ‘navigation wall,’ forcing users to leave Pipedrive to browse the full library on our public website. This friction meant we were losing their momentum exactly when they were ready to integrate.</p><p>We also found that users struggled with comparison fatigue and a lack of trust in third-party tools. They specifically looked for “Officially Recommended” or “Made by Pipedrive” tags to feel confident about connecting their data. These insights made it clear: we needed to bring the full marketplace experience inside the app and lead with trust.</p><h3>Challenges &amp; Strategy</h3><p>By clustering our research findings and data, we identified three core barriers preventing trial users from discovering the Marketplace’s full potential.</p><ul><li><strong>Invisible Opportunities. </strong>Integrations weren’t prominent in the UI, making the Marketplace feel like a static list rather than a growth tool. Most users only found apps <em>by accident or through external searches</em> like Google.</li><li><strong>The Navigation Wall. </strong>Forcing users to leave the web app to browse categories caused a <em>major disruption</em> in the journey, leading to high drop-off rates at the most critical moment.</li><li><strong>Guidance Gap. </strong>Even when users reached the Marketplace, a lack of clear direction on how to use integrations led to uncertainty. Without guidance, users <em>naturally deprioritized apps</em> in favor of more “obvious” CRM features.</li></ul><blockquote>Our strategy was to choose evolution over revolution. Given the tight delivery timeframe, we focused on high-impact, targeted improvements rather than a total redesign. It was essential to maintain familiarity for existing users while striking a balance between business value, user comfort, and technical complexity.</blockquote><h3>The Process</h3><h4>Competitor Analysis</h4><p>I conducted a competitor analysis to identify how other top-tier CRM platforms handle ecosystem discovery. The goal was to find proven patterns that aligned with our research and could be implemented efficiently.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yRP_Y2GyWp3ctYMFwRCr3A.png" /><figcaption><em>Competitive analysis: Identifying trust patterns and goal-oriented navigation from top-tier marketplaces.</em></figcaption></figure><p>Key takeaways included:</p><ul><li><strong>Trust &amp; Transparency.</strong> High-performing marketplaces use “Certified by” badges and clear pricing tags, e.g., “Free plan available,” to reduce user hesitation.</li><li><strong>Search &amp; Navigation.</strong> Competitors prioritize prominent search bars and goal-oriented categories, e.g., Lead Gen, Communication, to help users find value quickly.</li><li><strong>Visual Recognition.</strong> Using familiar brand colors and simplified grids helps users recognize tools they already use, enabling them to borrow trust from the familiar.</li></ul><h4>Iterations &amp; Internal Feedback</h4><p>Moving into design, I explored several layouts to find the best balance between search and discovery. I tested different approaches — from sidebar navigation to centered search bars — and shared them for internal review with the design team.</p><p>Leveraging our in-house design expertise was crucial. Discussions with other product and content designers provided a fresh perspective and allowed us to fail fast — invalidating some hypotheses early on while identifying the strongest opportunities for improvement. For instance, collective feedback helped us realize that a clean, focused search area provided more value than complex filtering at this stage.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fwww.youtube.com%2Fembed%2FpoGEbMndzbc%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fwww.youtube.com%2Fwatch%3Fv%3DpoGEbMndzbc&amp;image=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fi.ytimg.com%2Fvi%2FpoGEbMndzbc%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/dc5edf3416f791d83b95467fc9aed436/href">https://medium.com/media/dc5edf3416f791d83b95467fc9aed436/href</a></iframe><h4>Design Strategy</h4><p>Our design wasn’t just about a new look; it was about removing friction. We focused on:</p><ul><li><strong>Decluttering. </strong>Simplifying the search area to reduce cognitive load.</li><li><strong>Bridging the Gap. </strong>Bringing full categories directly into the web app, so users no longer had to leave the Pipedrive web app to explore the library.</li><li><strong>Clearer Value. </strong>Refining the copy and layout of recommended apps to make their benefits instantly obvious.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xMg0kxTaLev-axyo7RePcQ.png" /><figcaption><em>Limited discovery: The initial experience offered only basic AI recommendations and a cluttered search area, forcing users to switch platforms to explore the full library.</em></figcaption></figure><h3>The Solution</h3><p>We transformed the Marketplace from a passive list into a functional dashboard, focusing on reducing cognitive load and building immediate trust.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HU6cNiiRZpXghQxQyhcBag.png" /><figcaption><em>Bringing the full Marketplace experience inside: Top-searched apps, categories, and ‘Made by Pipedrive’ tools now live within the Pipedrive web app.</em></figcaption></figure><h4>Optimized Search &amp; Management</h4><p>We simplified the search copy and stripped away redundant UI elements to reduce visual noise. By adding a clear “Manage installed apps” CTA, we turned the storefront into a practical tool for users to oversee their ecosystem, rather than just a directory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GOEWsYSidxzOs3Q9yKDgRw.png" /></figure><h4>Trust Through Familiarity</h4><p>To reduce hesitation, we introduced Top App Tiles featuring well-known brands. Since apps like Slack and Zoom are our most searched integrations, leading with these familiar logos builds borrowed trust, making new users feel safer exploring the rest of the ecosystem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yXdDEkvnaDhgGaBQvzY_Rw.png" /></figure><h4>In-App Category Exploration</h4><p>Instead of making users guess, we brought Categories (e.g., Lead Generation, Communication) directly into the Pipedrive web app. This mirrored our public marketplace, ensuring users no longer had to leave their active workspace to explore the full library.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YycBpTyszecPNFU4XsWOcg.png" /></figure><h4>The “Made by Pipedrive” Anchor</h4><p>Our research showed that users trust in-house apps the most. We gave these integrations a dedicated section on the home page to provide a safe starting point for skeptical trialists.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f0zKM3vcMda-KeNCk1iscg.png" /></figure><h4>Goal-Oriented Category Pages</h4><p>Beyond the home page, we introduced dedicated category views to eliminate analysis paralysis. By grouping tools by specific customer goals — such as Lead Generation or Communication — we transformed a generic search into a guided, problem-solving journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aLo8LYnGEQqiQaAnguXFAA.png" /><figcaption><em>Category-Specific Deep Dive: Users can now explore tools tailored to specific goals — like ‘Attract new leads’ — directly within the Pipedrive web app.</em></figcaption></figure><h3>Ecosystem Thinking</h3><p>To drive adoption, I looked beyond the Marketplace storefront to see how app discovery integrated into the broader user journey. Two key platform initiatives, managed by partner teams, provided essential data on how users find and install apps.</p><h4>Behavior-Based Dialogs</h4><p>In-app prompts are triggered by specific actions during the initial days of a trial. These are a massive traffic driver, accounting for 29% of all Marketplace visitors, with an installation rate of 5%.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OtxqCnU7VpSo1EKaKv9-OA.png" /><figcaption><em>Strategic in-app dialogs triggered by specific user actions, driving broad visibility and inviting users to explore the Marketplace at relevant moments.</em></figcaption></figure><h4>Personalized Onboarding Checklist</h4><p>A tailored checklist guides new customers through Pipedrive’s features based on their company profile. While it drives significantly less traffic, only 5.6%, the quality is remarkable; 40% of these users install at least one app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bWqJTOp-mUp6z0JiYHQAZw.png" /><figcaption><em>High-Intent Discovery: A personalized onboarding checklist that integrates Marketplace exploration into the user’s initial setup flow.</em></figcaption></figure><blockquote>Analyzing these cross-team initiatives revealed a powerful contrast. While broad dialogs are excellent for visibility, the onboarding checklist proved that high-intent, contextual guidance is nearly 8 times more effective at converting visitors into active users than raw traffic volume.</blockquote><h3>Lessons Learned</h3><p>This mission proved that the most impactful design results come from a tight synergy between qualitative research and data analysis. By aligning previous interview insights with competitive benchmarking, we prioritized an “evolution over revolution” approach, focusing on trust and goal-oriented discovery.</p><p>Analytical expertise was vital throughout the process. It allowed us to validate that personalized, high-intent entry points — like onboarding checklists — vastly outperform generic traffic drivers. Ultimately, this project reinforced that understanding the why behind user behavior is the only way to build a marketplace that truly drives platform adoption.</p><h3>Impact &amp; Results</h3><p>The data sent a clear signal: moving from a passive list to a guided, in-app journey was the right strategic move. By comparing our post-update performance to the previous year’s monthly averages, we saw a measurable shift across all core metrics.</p><h4>+54% Discovery Growth</h4><p>“App details” opens surged. Trial users saw a 54% increase in total views, while paying users increased engagement by 47%.</p><h4>+19.5% Adoption Efficiency</h4><p>The growth in average installs significantly outpaced the growth in active users, with a 19.5% lift for trial users and 6.5% for paying users.</p><h4>+43.8% Conversion Increase</h4><p>Our most critical metric — the visit-to-install conversion rate — saw a dramatic shift. Following the update, conversion jumped up by 43.8% for trial users and 34.4% for paying users compared to the previous one-year period.</p><p>Ultimately, this update directly supported our global company objective: increasing the percentage of trial customers who integrate at least one app. While we set an ambitious target of a <strong><em>15%</em></strong> relative increase, we achieved a consistent <strong><em>8.4%</em></strong> growth in successful trial installations.</p><p>Even against these high benchmarks, the results proved that a more guided, visible marketplace experience creates a measurable impact on how new users adopt the Pipedrive platform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84c3fbcdde94" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/pipedrive-marketplace-scaling-app-adoption-84c3fbcdde94">Pipedrive Marketplace: Scaling App Adoption</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From a teacherless coding school to Production in 5 Days: How I survived my DevOps Internship]]></title>
            <link>https://medium.com/pipedrive-engineering/from-a-teacherless-coding-school-to-production-in-5-days-how-i-survived-my-devops-internship-c551b3624cbb?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/c551b3624cbb</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[internships]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Even Luiv]]></dc:creator>
            <pubDate>Thu, 22 Jan 2026 09:41:03 GMT</pubDate>
            <atom:updated>2026-01-22T09:41:02.704Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vy5qFEBTgsEJyoaiAupp4A.png" /></figure><p>On my first day, I walked in expecting a sandbox. Instead, I got production access. Within my first week, I was shipping changes that could impact real users. That’s the moment you stop being a “student who codes” and become an engineer with consequences.</p><p>This is a story of migrating critical mobile infrastructure from Jenkins to GitHub Actions, learning how to operate safely under pressure, and realizing that senior engineers aren’t as scary as they look. If you’re stepping into your first serious engineering environment, here’s how to survive the pace and actually grow from it.</p><h3>1. The Foundation: How //kood Prepared Me</h3><p>Coming from <a href="https://kood.tech/en/"><strong>//kood</strong></a> (kood/Jõhvi), I was accustomed to a non-traditional learning environment. For those unfamiliar, //kood is a teacherless, peer-to-peer coding school in Estonia (similar to the <a href="https://www.42network.org/"><em>42 Network</em></a>) where students learn entirely through collaboration and self-study.</p><p>We didn’t have professors — we had peers. This mindset became my biggest asset during my internship at Pipedrive.</p><p>At school, if you were stuck, you turned to a peer. This seamlessly translated to the engineering culture at Pipedrive, where you are assigned a “buddy” from day one. I could ask them any question, whether it was programming-related or not.</p><p>The peer-to-peer environment at //kood gave me the necessary soft skills to be teachable and proactive. I wasn’t afraid to say “I don’t know,” and I knew how to work with a team rather than just sit next to them. Armed with this self-learning mindset, I felt ready. But I still walked in on day one expecting to be treated like a typical intern. I was wrong.</p><p><strong>💡 Tip: </strong>Soft skills are your safety net. In a new environment, the ability to admit what you don’t know and ask for help is just as valuable as your coding ability.</p><h3>2. Expectation vs. Reality: The “Sandbox” Myth</h3><p>I walked in on day one assuming I’d be placed in a ‘sandbox’ — working on throwaway code and slowly ramping up over months. <strong>The reality was drastically different.</strong> There were no training wheels, just trust and guidance.</p><p>Two days after finishing my first task, I joined my first <a href="https://medium.com/pipedrive-engineering/pipedrive-agile-framework-a-detailed-view-c0a9717f0c5a">mission</a>. This culture of trust accelerated my growth. Because I delivered on early tasks, I wasn’t just fixing bugs — I was handed a project that impacted every mobile engineer at the company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RKHiYg0fHt17EE1mldhRMw.png" /><figcaption>My first 7 days in the DevOps team</figcaption></figure><p>💡 <strong>Tip:</strong> Don’t fear the deep end. If you are offered responsibility early, take it. It is the fastest way to turn self-doubt into engineering confidence.</p><h3>3. The highlight: Mobile CI/CD from Jenkins to GitHub Actions</h3><p>My team of two (myself and a Senior Engineer) was assigned to migrate the mobile (iOS and Android) build systems from Jenkins to GitHub Actions. This wasn’t just a change of code or a config tweak — <strong>we rebuilt the mobile build infrastructure from the ground up</strong>.</p><p>We moved from static Jenkins servers to GitHub Actions using self-hosted runners on Amazon EKS (Elastic Kubernetes Service).</p><p>This shift gave us two massive wins:</p><ul><li><strong>Scalability</strong>: We replaced fixed-capacity servers with an elastic cluster that spins up pods on demand to handle heavy Android jobs/builds.</li><li><strong>Focus:</strong> We eliminated the need for manual server maintenance by moving IOS jobs to GitHub hosted macOS runners and Android jobs to our self-hosted runners, freeing the mobile team to stop worrying about infrastructure and shift back the focus on mobile (iOS and Android) application development.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DvAlgMwXJJLGnOk0IkwFpw.jpeg" /><figcaption>Migrating from Jenkins and Mac Minis to GitHub Actions and AWS EKS</figcaption></figure><p><em>(You can read more about the technical details of our switch in our previous articles </em><a href="https://medium.com/pipedrive-engineering/so-long-jenkins-hello-github-actions-pipedrives-big-ci-cd-switch-03be29c75f63"><em>So Long, Jenkins!</em></a><em> and </em><a href="https://medium.com/pipedrive-engineering/all-aboard-the-github-actions-express-pipedrives-big-ci-cd-switch-part-2-fcacf834afd2"><em>All Aboard the GitHub Actions Express</em></a><em>)</em></p><p>This experience taught me that at Pipedrive, your title doesn’t matter as much as your output. Even as an intern, I was entrusted to build and deploy critical production infrastructure that the entire mobile team relies on. Tackling critical infrastructure was technically demanding, but the technical side wasn’t the only thing I was nervous about. I still had to deal with the people who built it.</p><p><strong>💡 Learning Point:</strong> Infrastructure is about impact, not just code. When refactoring build systems, always measure the “human” gain — like how many hours developers save by not maintaining servers.</p><h3>4. Breaking Misconceptions: The “Friendly Giants”</h3><p>I held a common misconception: that senior engineers are scary, busy, and critical. To be honest, I feared them.</p><p>I couldn’t have been more wrong. The seniors I encountered were what I call “Friendly Giants” — sincere and incredibly helpful. They didn’t just correct my code, they took the time to point out what I was doing well and guided me on where to improve, turning code reviews into mentorship sessions. With the fear of senior engineers gone, I felt comfortable exploring tools to make my workflow faster and more efficient — including how Pipedrive handles the hot topic of AI.</p><p><strong>💡 Tip:</strong> Senior engineers are resources, not judges. Approach code reviews as a free mentorship session rather than a test of your worth.</p><h3>5. AI is a Tool, Not a Cheat Code</h3><p>A fascinating finding was the company’s stance on Artificial Intelligence.</p><p><strong>The Culture</strong>: AI isn’t just allowed, it’s encouraged. Pipedrive views using AI tools as a legitimate engineering skill. We saw this payoff firsthand when we utilized AI assistants (GitHub Copilot and Claude Code) during a complex service migration. The efficiency boost helped us deliver the mission a full week ahead of schedule.</p><p><strong>Experimentation</strong>: We are free to experiment with new tools as long as we document the findings. For example, when my teammate proposed using Claude Code for automated pull request reviews, we didn’t need to chase down countless approvals. We simply formed a team and were testing it out the very next week.</p><p>On a daily basis, I use Claude Code to understand foreign codebases and complete tedious tasks. Through this internship, I discovered something about myself: I love automating things away. Whether it’s a work task or a personal habit, the “click” of a successful automation fuels my internal drive.</p><p><strong>💡 Tip:</strong> Treat AI as a force multiplier. Don’t hide your use of AI tools — instead, learn to integrate them into your workflow to automate repetitive tasks, bridge knowledge gaps and focus on complex problem-solving.</p><h3>6. Hindsight: What I Wish I Knew</h3><p>Looking back, there are two things I would have done differently to prepare. These apply to anyone looking to break into modern Software/DevOps engineering:</p><p>1. <strong>Kubernetes (K8s) is King: </strong>Understanding the orchestration layer is crucial. I wish I had experimented with K8s earlier — it’s a highly valued skill regardless of the company you join.</p><p>2. “<strong>Hacking” Pet Projects:</strong> Whether it is DevOps or Software engineering, this job requires deep domain knowledge that is hard to learn just by reading docs. If I were applying again, I would take a common pain point in my field of interest and start solving it.</p><p>In my scenario, I would take one of my “pet” projects and just start hacking away at it — testing different CI/CD methods, breaking them, and fixing them. Hands-on failure is typically the best teacher.</p><p><strong>📚 Homework: The “Over-Engineering” Challenge</strong> <br>Don’t wait for a brilliant app idea. Take a simple “Hello World” script and treat it like mission-critical software. <strong>Overengineer it on purpose:</strong> Dockerize it, write a CI/CD pipeline to test it on every push, and try to deploy it to a local cluster. You will learn more about DevOps by building a complex pipeline for a simple app than by building a complex app with no pipeline.</p><h3>Conclusion</h3><p>I found my internship at Pipedrive a fun and rewarding challenge — putting my learnings from a coding school to the test and gaining a lot of knowledge on the way. I understood that learning DevOps in a classroom is like reading a manual to fly a plane. My internship was like I was handed the controls mid-flight — scary at first, but with my buddy and the “Friendly Giants” as co-pilots, I realized that I was ready to fly all along.</p><p>When looking for an internship yourself, seek out companies that actually excite you. Reach out to your network and come prepared with personal projects. For instance, my simple disc-golf score tracker became a major talking point during my interviews. It proved I wasn’t just looking for a job — I genuinely loved building software and systems to support it.</p><p><strong>💡Final tip:</strong> You are never fully “ready.” Real growth happens when you step out of the simulation and into production.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c551b3624cbb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/from-a-teacherless-coding-school-to-production-in-5-days-how-i-survived-my-devops-internship-c551b3624cbb">From a teacherless coding school to Production in 5 Days: How I survived my DevOps Internship</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software engineer Karina Freitas: “Some things start with a recipe. Others start with a feeling.”]]></title>
            <link>https://medium.com/pipedrive-engineering/software-engineer-karina-freitas-some-things-start-with-a-recipe-others-start-with-a-feeling-d959b9a31f25?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/d959b9a31f25</guid>
            <category><![CDATA[pipedrive]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[food]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Maie-Liisa Sildnik]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 10:26:48 GMT</pubDate>
            <atom:updated>2025-11-13T10:26:47.019Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Before Karina ever wrote a line of code, she was already building: meals that brought people together, travel experiences shaped by curiosity and a small business started from scratch. The ingredients have changed over time, but the mindset has remained: structure, patience, curiosity and creativity are the foundation of everything. This is how you build the joy of making something that works.</strong></p><p>Her biggest learning? You can follow a recipe and get a good result. But to create something memorable, you need to know when to improvise. This approach follows her into software development, where the real magic often lives between the lines of logic and the moments you trust your instincts. For Karina, building great products means balancing precision with creativity and structure with experimentation – just like in the kitchen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fXGiDfUMSx6cHfTOZMcRRg.jpeg" /><figcaption>Karina exploring local culture in Cambodia, one bite at a time</figcaption></figure><p>In the end, nothing really exists in isolation. A lesson or a habit, each experience leaves something behind to build new perspectives and connect all the dots. For Karina, it just happened to be software.</p><p>But to understand how it all came together, let’s rewind the story.</p><h4><strong>A dash of curiosity, a spoonful of code</strong></h4><p>You’ve probably figured this out by now – Karina didn’t start out in tech. Born in Brazil and trained as a chemical engineer, she spent 10 years working at a multinational chemical company, handling everything from product development to account management for large clients in the paper and packaging industry. But after a decade in corporate life, she and her husband were ready for a change.</p><p>They left their jobs, took a sabbatical and set off to explore Asia. What began as a break soon became something more: they started building a food tourism business, helping people experience local culture through food. That business eventually brought them to Portugal, where government support programs and visa opportunities made it an ideal place to build her next chapter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*gJ-2ntL76aie5UARdwGhaQ.jpeg" /><figcaption>Food, culture and street art in Asia</figcaption></figure><p>But when the pandemic hit, the tourism industry ground to a halt. Karina, still driven by curiosity and creativity, found herself spending more and more time building and optimizing the company’s website. With no tech background, she taught herself the basics through tutorials, building not just static content but e-commerce functionality and SEO improvements. The website ended up ranking really well in Google and it was her first real taste of web development.</p><h4><strong>Learning by building, teaching to learn</strong></h4><p>Her first website ready, Karina enrolled in a nine-week web development bootcamp in Lisbon. There, she got her first taste of structured software development: front-end, back-end and real-life projects. “<em>That was the moment I knew I was on the right path. I loved the experience of creating something from scratch and turning ideas into working code. After I completed the course, I was invited to stay on as a teaching assistant. This was an opportunity that helped me develop my skills and reinforce me continue learning. Teaching helped me gain confidence and it forced me to really understand the material,</em>” she explains.</p><p>Still, Karina knew that changing careers in her 30s would come with challenges. “<em>You’re starting over in a new industry, in a junior position, after years of experience in something completely different. That’s not easy. But I wanted to be prepared and the extra time as a teaching assistant gave me space to grow, learn and find the right company to begin my new career,</em>” she says.</p><h4><strong>A pinch of tech, a spoonful of passion: the recipe that led to Pipedrive</strong></h4><p>When Karina came across a job opening at <a href="https://www.pipedrive.com/">Pipedrive</a>, something clicked. She hadn’t used the platform before, but her background in sales, marketing and entrepreneurship gave her a strong understanding of CRM workflows and customer pain points. Karina joined as a junior developer in Pipedrive’s Lisbon office in 2022, and within a few months, was promoted to mid-level.</p><p>One of her proudest moments so far came from her first full product mission. It was the first time she worked closely with a full cross-functional team, including product managers, designers and fellow engineers. “<em>This experience was a turning point for me. It helped me grow as a developer, not just technically but in how I collaborate and think about the user experience</em>.”</p><p>She also got the chance to participate in customer interviews during that project. “<em>It’s amazing to hear real users talk about the product you’re helping build. Not all developers get to do that. At Pipedrive, we do, and I think it makes a big difference,</em>” she explains.</p><h4><strong>Chopping veggies, writing code</strong></h4><p>Karina still sees connections between her old life in food and her current one in tech. “<em>In food, two people can make the same dish in completely different ways. The goal is the same, but the process depends on background, tools, experience and culture. That’s true in software development, too.</em>”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zXKRqhou5g7kPEQ_H61ctQ.jpeg" /><figcaption>At the market in Valencia, where creativity starts witha good handful of the right ingredients</figcaption></figure><p>She also sees similarities in the balance between technical skill and creative thinking. “<em>You can follow a recipe exactly and get a decent meal. But to make it memorable, you need creativity. It’s the same with software development. Meeting requirements is one thing. But designing an experience that’s smooth, delightful and user-friendly takes creativity</em>,” she says.</p><p>This perspective helps her stay curious, empathetic and open to new ways of doing things. She believes that coding is not just about building tools, but also about shaping experiences.</p><h4><strong>What makes the Lisbon office special</strong></h4><p>Even though her team works mostly remotely, Karina makes a point of going into the Lisbon office every week. The office is cozy, social and gives her a chance to connect with people outside her team.</p><p>She appreciates the small traditions in the office – from the ping pong tournaments to meetups to the casual lunches that bring engineers from different tribes together. She also values Pipedrive’s international spirit. “<em>Even though most of my team is based in Lisbon, I collaborate with people from different offices. Keeping that global mindset is important to me. In June, we had our Summer Garage, a gathering where people come together to connect and celebrate. This year, it was a company-wide celebration, bringing together colleagues from all offices. Meeting people in person was really meaningful. It changes the way you collaborate,</em>” Karina explains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*03L7rUnWZMUHeY65z-S8hQ.jpeg" /><figcaption>A moment from team curling event in Estonia: Karina (on the left side, wearing a black jacket) and her team members trying something new on ice</figcaption></figure><p>Outside of work, Karina’s energy doesn’t slow down. She cooks, visits local food producers, takes spinning classes, does yoga, reads and travels as often as possible. Portugal is home now, but she still loves exploring as traveling gives her new references and new ways of seeing the world. But she’s not into just checking off landmarks. “<em>I’d rather skip the must-see and find a conversation with a local or a hidden restaurant that makes you feel like you’re part of the place.</em>” That spirit of curiosity and immersion follows her into work, too.</p><p>And this seems to be Karina’s secret formula for success – a mix of openness, drive and creativity that keeps things moving in the kitchen, in code and in life.</p><p><strong>Karina’s recipe for aspiring developers and career changers:</strong></p><ul><li>If you’re just starting out, really focus on the basics and build a strong foundation. Don’t be afraid of mistakes – that’s where the learning happens.</li><li>If you’re thinking about switching careers, it doesn’t matter how old you are or what you did before. If you’re genuinely excited and ready to put in the effort, go for it. Be honest about what you don’t know and ask questions – people are willing to help and this way everything will come together.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d959b9a31f25" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/software-engineer-karina-freitas-some-things-start-with-a-recipe-others-start-with-a-feeling-d959b9a31f25">Software engineer Karina Freitas: “Some things start with a recipe. Others start with a feeling.”</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How AI is helping Pipedrive teams move from ideas to impact]]></title>
            <link>https://medium.com/pipedrive-engineering/how-ai-is-helping-pipedrive-teams-move-from-ideas-to-impact-995b18aa399c?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/995b18aa399c</guid>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[collaboration]]></category>
            <category><![CDATA[engineering-culture]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[product-development]]></category>
            <dc:creator><![CDATA[Bruno Pinto]]></dc:creator>
            <pubDate>Tue, 28 Oct 2025 10:40:01 GMT</pubDate>
            <atom:updated>2025-10-28T10:58:01.443Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jhCys-Ium1PfvbshlzK6Wg.jpeg" /></figure><p>Product development has always been a game of telephone. Designers create specs, engineers implement them, PMs try to coordinate between both. Every handoff introduces friction: misaligned expectations, lost context, delayed feedback. You know the drill. The more boundaries between roles, the slower ideas move to implementation.</p><p>But what if those boundaries could blur? What if designers could express ideas through working prototypes, engineers could make UX decisions with confidence, and PMs could build flows that feel production-ready?</p><p>At Pipedrive, we’ve been exploring how AI can expand who gets to contribute to product development. The boundaries between roles are blurring and we’re learning what possibilities this brings.</p><p>I keep coming back to something Scott Belsky wrote in his essay: <a href="https://www.implications.com/p/insights-on-collapsing-the-talent"><em>Insights on Collapsing the Talent Stack</em></a>:</p><blockquote><em>“</em>When the lead designer was also the product leader, when the front-end engineer was also a designer, when the designer is also a great copywriter… tighter conduits for decision-making and synthesizing information are an incredible advantage when it comes to crafting products.<em>”</em></blockquote><p>That resonated. We wanted to see if AI could actually help us collapse these boundaries in practice, not just in theory.</p><h3>Starting with prototypes</h3><p>Here’s the thing about Pipedrive: many of us have been here for a while. We’ve shipped countless features, refined our processes, learned the hard way how things work. That accumulated context turns out to be a huge advantage. It means we can move fast and step into adjacent areas with confidence. We don’t just own our slice of the process but also the seams between them.</p><p>Modern prototyping tools can produce output that looks like your real app by using your actual Design System components, styles and interactions. When that works, discussions get focused, feedback loops tighten and people experiment across roles without waiting for formal handoffs.</p><p>Consider a practical example:<br>A PM has an idea for improving the deal pipeline view. Normally, that means writing a <a href="https://en.wikipedia.org/wiki/Product_requirements_document"><em>PRD</em></a>, waiting for design, then waiting again for engineering to build something you can click through.</p><p>Now, that same PM can spend an hour with an AI prototyping tool and create something that looks like our actual product. Real components, interactions in a fraction of time. Engineers can look at it, understand it and provide technical feedback immediately. No translation layer needed.</p><p>That kind of speed changes how ideas evolve. But… prototypes need to look like your app, not like generic AI slop. Otherwise you’re back to translation.</p><h3>Tool shopping &amp; finding what works</h3><p>We tried a bunch of tools before finding our groove. Each one had strengths but we kept hitting the same problem: it was hard to integrate our internal Design System. These tools could generate pretty interfaces, sure. But they didn’t know our components, our tokens, patterns…</p><p>Since we’re already deep in the <a href="https://www.figma.com/"><em>Figma</em></a> ecosystem, <a href="https://www.figma.com/make/"><em>Figma Make</em></a> was the obvious starting point.It integrated cleanly with our Design System and didn’t require much setup. That alone made it worth sticking with.</p><p>Through experimentation, we learned something that now feels obvious: <strong><em>the quality of the output depends less on the tool and more on how the prompt is structured and the context that is shared.</em></strong></p><p>We found a sweet spot for our prompts, in which we took inspiration from the <a href="https://en.wikipedia.org/wiki/Goldilocks_principle">Goldilocks principle</a>: Prompts should be clear enough to guide the model but loose enough to let it reason.</p><p>In the end, the goal isn’t to script every detail, it’s to give enough context to keep things aligned while leaving room for the model to reason.</p><p>This space is moving fast so what works today might be outdated in three months. But here’s the exciting part: these tools are probably as bad as they’ll ever be. It only gets better from here.</p><h3>Translating designs into code</h3><p>Once we got prototyping working, we realized the same principles applied to the next step: turning designs into actual code.</p><p>Accuracy depends on two things: the AI assistant is the obvious one (<em>we’re mostly using </em><a href="https://claude.ai/"><em>Claude Code</em></a><em>, though we keep experimenting with alternatives like we did with prototyping tools</em>) but also the structure and clarity of the design specs themselves. Better context, better output. We’d seen this with prototyping, but it was even more true with code generation.</p><p>Proper design tokens for spacing, sizing, typography… that stuff made handoffs incredibly smoother. We also leaned on <em>Figma’s</em> <a href="https://help.figma.com/hc/en-us/articles/23920389749655-Code-Connect"><em>Code Connect</em></a> to map Design System components directly to our code library, which helped keep generated code consistent across tokens and patterns.</p><p>The small details mattered more than we expected. Clear layer names, actual text content, annotations explaining intent. When designs were well prepared, the code came out cleaner.</p><p>AI can handle ambiguity. But why make it guess?</p><h3>Building a workflow</h3><p>We didn’t want to just throw designs at an AI assistant and hope for the best. So we built a structured process using a <a href="https://docs.claude.com/en/docs/claude-code/slash-commands"><em>Claude slash command</em></a> that breaks things into steps:</p><ol><li>Define the AI assistant’s role, objective, output and success criteria</li><li>Analyze requirements and assumptions, documenting missing context</li><li>Pull design data using <em>Figma MCP</em> for full component and layout context</li><li>Map design elements to our Design System components</li><li>Reference component documentation for usage constraints and implementation notes</li><li>Generate a summary report with mappings, warnings, <a href="https://storybook.js.org/docs"><em>Storybook</em></a> URLs and open decisions</li><li>Add a review checkpoint before implementation</li></ol><p>Following this process made results way more predictable. Less frustration, fewer surprises.</p><h4>Why review matters more than ever</h4><p>Andrej Karpathy has this way of cutting through the hype about AI capabilities. <a href="https://www.youtube.com/watch?v=lXUZvyajciY&amp;t=6223s">He said something recently</a> that stuck with me:</p><blockquote>“[Some models] remarkably resemble a kindergarten student, or an elementary school student or high school student, etc. Somehow, we still haven’t graduated enough where this stuff can take over.</blockquote><blockquote>My Claude Code or Codex, they still feel like this elementary-grade student. I know that they can take PhD quizzes, but they still cognitively feel like a kindergarten or an elementary school student. […] they’re still kids. They’re savant kids. They have perfect memory of all this stuff.</blockquote><blockquote>They can convincingly create all kinds of slop that looks really good. But I still think they don’t really know what they’re doing and they don’t really have the cognition across all these little checkboxes that we still have to collect.”</blockquote><p>And that’s why becoming “<em>AI-native</em>” means embracing iteration. Staying close to the output. Stepping in where it matters. Refining through feedback until it’s right.</p><p>The people who’ve gotten good at guiding these tools: providing context, giving feedback, steering direction, they’re the ones delivering the most value. It’s less about writing every line of code and more about maintaining judgment. Knowing when the output is right. Knowing how to fix it when it’s not. Catching the moments where the “<em>savant kid</em>” confidently does the wrong thing.</p><h3>Guardrails that actually help</h3><p>Even with a solid workflow, AI doesn’t always get it right. So we built some guardrails, rules that keep both AI and humans aligned.</p><p>We built a set of implementation guardrails that helped AI stay in bounds. Here are a few examples:</p><ul><li>Avoid fixed heights: layouts are fluid and hardcoded dimensions break responsiveness</li><li>Enforce design token usage to prevent inline styles and ensure consistency</li><li>Think before applying values that lack a corresponding design token</li><li>Use CSS font shorthand tokens to automatically apply size, weight and line height consistently</li></ul><p>These guardrails don’t replace review, of course. They make it easier to catch issues early and maintain quality across the generated code.</p><h3>Scaling beyond experiments</h3><p>Our first experiments ran locally. <em>Claude Code</em> connected to our Design System repos, pulling design specs via <em>Figma MCP</em>. It gave us the necessary context and let us iterate quickly.</p><p>But local setups don’t scale. They’re great for proving concepts, not so good for rolling out to teams. Our next steps focus on making these workflows accessible to more people:</p><ul><li><em>Prompt library</em><br>Collect examples, screenshots, sketches, and design principles that work. Little notes about what works and what doesn’t. Basically, teach the tools to speak our design language</li><li><em>Internal Design System MCP</em><strong><br></strong>Centralize rules so AI assistants can pull tokens, components, and documentation from one source of truth. This makes it easier for more people to experiment without complex local setups</li><li><em>Better feedback loops</em><strong><br></strong> Automatically compare AI outputs with <em>Figma</em> specs to highlight mismatches instantly and help course-correct before code review.<br>We ran a few iterations with <a href="https://github.com/microsoft/playwright-mcp"><em>Playwright MCP</em></a> but didn’t see any significant results</li></ul><p>Structure and guardrails make this stuff more predictable. And that predictability gives people confidence to move fast while staying in control.</p><h3>What this actually means</h3><p>Every design starts with intent. Every line of code is an attempt to capture that intent. The tools we’re using, from AI-assisted prototyping, to structured workflows, they’re not about replacing <em>craft</em>. They’re about reducing the distance between idea and implementation.</p><p>For us at Pipedrive, this journey showed that the real value of AI isn’t in replacing creativity but in reducing friction, amplifying what experienced people can already do. And it doesn’t remove the need for judgment, it makes judgment more valuable than ever.</p><p>The future belongs to people who can move fluidly between roles. AI makes that possible. Influence now comes from action… and taking action has never been easier.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=995b18aa399c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/how-ai-is-helping-pipedrive-teams-move-from-ideas-to-impact-995b18aa399c">How AI is helping Pipedrive teams move from ideas to impact</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lessons Learned from Developing a Security Incident Management Program]]></title>
            <link>https://medium.com/pipedrive-engineering/lessons-learned-from-developing-a-security-incident-management-program-79ef5f2ad5a9?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/79ef5f2ad5a9</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[program-management]]></category>
            <category><![CDATA[incident-management]]></category>
            <category><![CDATA[standards]]></category>
            <dc:creator><![CDATA[Martha Peterson]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 11:11:20 GMT</pubDate>
            <atom:updated>2025-10-08T11:11:16.282Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OXkDSrnsvQbkMWIgNwwyzA.jpeg" /><figcaption>Image by pch.vector on <a href="https://www.freepik.com/free-vector/team-crisis-managers-solving-businessman-problems-employees-with-lightbulb-unraveling-tangle-vector-illustration-teamwork-solution-management-concept_10613678.htm">Freepik</a></figcaption></figure><p>Security incident management programs are developed over time, through trial and error, and plenty of adrenaline. At Pipedrive, our journey was no different. The program development started out of necessity, in a classic <em>we needed it yesterday</em> kind of way. We responded to incidents, developed playbooks, and defined roles and responsibilities. Above all, we focused on learning from every incident. Ultimately, incident management touches nearly every part of the company, so getting people to trust the processes and work together is what makes the program succeed.</p><p>Over time — and a few <em>Why isn’t this working?</em> moments later — the program matured and the number of stakeholders grew. The program was functioning well, but I became curious how our homegrown approach compared to a formal industry standard. To find out, I went through the <a href="https://www.iso.org/standard/78973.html">ISO/IEC 27035</a> training and certification process.</p><p>Going through the standard and the training was a weird mix of validation and frustration all at once. Our custom-built incident management program was neatly outlined in a globally recognized standard! My first thought was that we could’ve just bought the standard three years ago and implemented that. After the initial shock passed, I realized it was good news; true to the spirit of a post-incident retrospective, I began looking for the lessons learned from it.</p><h3>Lesson 1: Change is Harder Than It Looks</h3><p>Building a program on top of existing processes, adding new roles, or documenting previously undocumented items is always a struggle. If you’re lucky, only a few people will say, <em>We’ve always done it this way, why should we change now?</em> But in reality, many more will be thinking about it.</p><p>Rolling out a standard might have made getting the buy-in easier — after all, it is a globally recognized framework. The downside is the risk of turning the program into a box-ticking exercise, including the boxes you don’t actually need yet. Implementing processes by trial and error may be slower, but it forces you to build processes that really fit your environment. If they don’t, you’ll hear about it soon enough.</p><p>If I could do it over again, I’d involve more stakeholders earlier. That would have cut down the mid-incident “Why are we doing this?” conversations with people caught off guard by unfamiliar processes. Stakeholder management was the most challenging part, especially when so many things were still uncertain, and we didn’t have all the answers figured out. Their questions and demands often felt overwhelming. Having the standard by my side would’ve helped me push through the moments of self-doubt. But even after we had secured buy-in, another challenge quickly surfaced. We still needed to figure out how to connect all the lessons and findings across different teams and programs.</p><h3>Lesson 2: Don’t Build in Silos</h3><p>From the start, we treated every incident, big or small, as a test: did our processes hold up, where did they break, and how could we improve? After-action Review meetings (or retrospectives) gave us plenty of lessons, but even having all the necessary stakeholders at the table didn’t mean we were automatically aligned on how to learn from them. Each program was still generating insights in a silo, and without a way to connect them, the same issues kept resurfacing in different forms. To make real progress, we needed a single system to track and connect them, not a pile of competing lists.</p><p>On paper, alignment sounds simple. In practice, it’s taxing — you need a systematic way to link tasks so they’re clear, easy to find, and easy to act on. Luckily, our Risk Manager thrives on challenges like this, and after some intense planning (picture red string on a wall and life-threatening amounts of coffee), we ended up with an in-house corrective action tracking process.</p><p>Looking back, I should have recognized the need for a systematic link between programs much earlier. By waiting, we had to juggle a backlog of existing corrective actions while also creating a process for new ones. Had I understood that sooner, it would have helped us prioritize alignment and stay more disciplined from the start. The standard highlights this exact point, especially the connection between risk management and incident management. Seeing it play out in cross-domain alignment put it into context, as much of the standard still needed adapting to strike the right balance with our culture.</p><h3>Lesson 3: Context Is Everything</h3><p>As a global standard, ISO 27035 is designed to be broad and universal, as it has to fit many types of organizations. Pipedrive’s culture is fast-moving and pragmatic, so we lean toward clear, usable documentation and faster iterations. The positive side of developing a program without following the standard from the start was that we weren’t immediately weighed down by its full complexity. A universal framework has to cover every possibility, which can feel overwhelming when you’re staring at a blank page and trying to decide what actually fits your organization.</p><p>Our journey forced us to filter those complexities naturally. We built only what our culture could sustain: a pragmatic program that worked in practice, without adding extra administrative layers. Ironically, this approach brought us closer to ISO guidance than we expected. However, having the standard from the beginning would have helped me explain <em>why</em> certain structures matter. For example, documentation can feel like bureaucracy, but framed as a tool for organizational resilience, it suddenly makes sense and is much easier to advocate for. That balance between structure and culture shaped the whole program and set the stage for my final takeaway.</p><h3>The Biggest Takeaway</h3><p>By building the program from the ground up, we gained a level of understanding that a direct implementation of the standard alone could never have given us. If I had to do it again, I’d bring in the standard earlier, not to follow it blindly, but to use it for validation (and to keep my sanity).</p><p>Lessons learned aren’t just about what went wrong; they’re also about what went right and the value of those choices. Building our Security Incident Management program through trial and error taught me a lot about communication, coordination, uncertainty, and organizational complexity. Those lessons didn’t end with the program’s launch; they remain as relevant today. Looking back at it now through the lens of ISO 27035 helped me connect the dots and put words to things we had sensed all along but hadn’t yet articulated. And maybe that’s the biggest lesson I learned: incident management goes beyond playbooks and standards. Its real strength comes from fostering trust and collaboration across the company.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=79ef5f2ad5a9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/lessons-learned-from-developing-a-security-incident-management-program-79ef5f2ad5a9">Lessons Learned from Developing a Security Incident Management Program</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[All Aboard the GitHub Actions Express: Pipedrive’s Big CI/CD Switch (Part 2)]]></title>
            <link>https://medium.com/pipedrive-engineering/all-aboard-the-github-actions-express-pipedrives-big-ci-cd-switch-part-2-fcacf834afd2?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/fcacf834afd2</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[Stéphane Moser]]></dc:creator>
            <pubDate>Fri, 26 Sep 2025 05:30:01 GMT</pubDate>
            <atom:updated>2025-09-26T05:29:58.328Z</atom:updated>
            <content:encoded><![CDATA[<p><em>In the last article of</em> <a href="https://medium.com/pipedrive-engineering/so-long-jenkins-hello-github-actions-pipedrives-big-ci-cd-switch-03be29c75f63">Pipedrive’s CI/CD Switch</a>, we saw that Pipedrive had issues with Jenkins, so we created a custom CI engine to address those issues. However, in the end, the solution proved to be inadequate. We followed the investigation effort led by Gregor and me to implement a self-hosting solution for GitHub Actions using EKS, Karpenter, and ARC. We successfully migrated 600 repositories to GitHub Actions using reusable workflows. Additionally, we did research to understand the potential form of the new CI/CD after experimenting with several tools, including Tekton and Spinnaker. To finally understand that the magical combo will be GitHub Actions plus ArgoCD.</p><p>In this part, I will guide you in our journey to convert that POC into a production-ready solution, the marathon that was to migrate 700 services using automation, and where, at some time, the developers start to be independent and do it alone, and the cracks we got when bots overloaded the system.</p><h3>Chapter 4: Laying the Groundwork: Getting GHA Ready for Prime Time</h3><p>We conclude our research with a prototype for our vision of a new CI/CD, but we knew we weren’t there yet. We had identified three crucial gaps that needed to be addressed before rolling this out to the entire organization.</p><p>First, we needed a reliable way for our GitHub Actions workflows to know the status of deployments managed by Argo CD. When transitioning from a push-change model to a pull-change model, it is necessary to reconsider how we connect the phases where artifacts are created and deployed. As an analogy for the differences between the push and pull models, consider the mail delivery system. The “push” model is like a mail carrier delivering a package to your door. The “pull” model (GitOps) is similar to visiting the Post Office and picking up your mail when you’re ready. The cluster “pulls” the changes, which is safer because you’re not just letting anyone push things directly to your environment.</p><p>The second issue was the scalability of the UI. GitHub provides a nice UI for repository-level management, but in Pipedrive, we have an architecture of microservices and polyrepos. Therefore, if we want to view the deployment flows of 800 services, we need a UI to integrate all the deployments. And third, our new workflows needed to integrate seamlessly with the rest of our development lifecycle systems, a central point not to orchestrate the deployments, but to share the events about deployments, because our concept of deployment stages is slightly different from GitHub’s; we had to inject our new schema of events during the deployment flow.</p><p>To ensure secure communication between ArgoCD and GitHub Actions workflows, we had to be creative and find a common resource available to both systems that allows the transmission of deployment status. And in reality, that resource was right behind our noses, every time we make a Pull Request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/517/1*veVnJRcx0NLy9DkXpfHlDw.png" /><figcaption>Commit Status: The comunication channel from ArgoCD to GitHub</figcaption></figure><p>GitHub Commit Statuses was the right fit for our problem. ArgoCD was able to update the commit status related to the git commit that was being monitored, and the Workflow was aware of the git commit because it was the one that created that commit. We have added loop logic to our workflow to monitor the commit status and configure ArgoCD Notifications to send the correct information to GitHub.</p><p>Using the mail delivery analogy again, it is as if the sender of the package were checking with my Post Office to see if I had already picked up the package. When I go to the Post Office, I leave a message indicating whether I am happy or not with the package. The beauty of this solution is that it was simple to implement and didn’t compromise the security of the clusters, as the cluster pushed the information and not the workflow connecting to the cluster to retrieve it.</p><p>Next, we had to tackle the need for a unified view of all deployments. Even though we already had a service to track all Workflow Job and Workflow Run events from GitHub, that information didn’t align with our concepts of deployments, so we created a deployment registration service, named Deployment Registrar. The primary goal of this service is to record all Pipedrive Deployment events emitted by our workflows, structure them within a database, and provide an API that can answer all questions related to deployments in a way that allows us to feed a UI for developers. With this central registration, we can also emit rich events to other parts of our engineering excellence ecosystem, such as the Remote Dev Environment system, to keep the development environments up to date. With one service, we were able to solve two problems: the UI centralization and the communication with other development-related systems</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/689/1*DN_9PjFNyrx9mxzznf7diA.png" /><figcaption>Deployment view</figcaption></figure><p>The existing gha-data-exporter was a great start for tracking workflow progress, but it didn’t capture the concept of deployments themselves, and it lacked a proper API to build a UI. Therefore, we created the Deployment Registrar as a single point of reference to view the status of all our 800 services. As our workflows evolved, we introduced the concept of deployment events, which were sent at key moments in the deployment lifecycle. The Deployment Registrar tracked these events, providing a rich dataset and exposing an API. This allowed us to build a centralized UI, providing everyone in the organization with a clear view of all deployments.</p><h3>Chapter 5: All Aboard the GHA Express! Moving 800+ Services in 7 Months (Woo!)</h3><p>Now that we have closed the gaps in our solution, it was time to start to have customers. In this case, our engineering group, comprising over 300 engineers, spans multiple departments and teams. Meaning more than 800 services to move to the new platform. As a good problem solver, to tackle a big problem, we need to break it down into smaller chunks.</p><p>We separated the services by team ownership (first, those closer to the platform) and then by service criticality (first, the less critical services for the product, and last, the most critical services). This approach allows us to achieve two things: start with services that are owned by people who know the platform better and can react faster in case of issues, and second, allow us to build confidence in the process by starting with “peanuts services” and then, when we are familiar with everything, migrate the big ones.</p><p>With this plan, we decided to be our own first customers, in other words, some dog fooding, where we consumed the platform with our services, allowing not only deeper testing of the platform and the migration tools. But also giving an opportunity to share knowledge within the team. This step was really important because with every migration we completed, a small improvement was made to the process and automation. Enhancing the reliability of automations and streamlining the migration process to provide a self-service-like experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WlAxEBQB0dcVdyKVQRWEAQ.png" /><figcaption>Mona and Argo conduting our code express to migrate our services</figcaption></figure><p>Ultimately, we delivered a service to our customers, not just a set of tools. The role of the DevOps Engineers was to guide the migrations by coordinating with the teams, providing training, and not executing the migrations themselves.</p><p>The success of this migration process was only possible because of the automations. The logic of the process was encapsulated inside a GitHub Action Workflow, where the only input required by the developer was the service name. With that simple step of clicking, typing, and confirming, a comprehensive process was executed to generate all the configuration files for the new platform, migrate old files to the new format, and reconfigure the repository for the new needs, all without any human error.</p><p>After seven months of work, we completed the migration. It was challenging at the beginning, with some failed deployments and services that had their own quirks, such as custom pipelines for deployment, ad-hoc setups for live tests, or even issues with a service&#39;s name that started with a number. However, in the end, we began to see anxious teams eager to utilize the new platform. They began their migrations independently, following the documentation we had built for training, and successfully migrated to the new platform. And for me, that was the moment that proved we had accomplished our goal of delivering a solution that was not just a platform, but a self-service solution.</p><h3>Chapter 6: So, Was It Worth It? What We Learned, Messed Up, &amp; Our Advice!</h3><p>After seven months of migrations, plus two to three months of research, with countless hours of work, thinking, and sometimes banging our heads on the table, we had a question: was it all worth it?</p><p>Based on conversations with developers and several requests to discuss this topic, I can tell that the developers love our new system. The overall feedback points to a huge success; the developers love the GitHub Actions UI, and the new centralized system was a great improvement from the previous deployments dashboard that we had. The developer experience (DX) of bringing their new features, fixes, and even rollbacks to the users was improved and simplified.</p><p>The new system was so effective that we saw an increase in usage, reaching a point where we had half a million minutes of workflows and 300,000 workflow runs per month, resulting in approximately 6,000 deployments per month. And I can tell you that when we started to see some cracks, we had to introduce new features to mitigate that.</p><p>One of the technical shortcomings of GitHub Actions is the inability to have queues of workflows, so we had to create a lock mechanism to force the rule that we have, that we only allow one deployment per service at the same time, and to avoid conflicts in the environment state, only one workflow can touch the environment state, imagine a single-file line to get into a room. Only one person (deployment) could enter at a time. That lock on the environment state started to become a bottleneck, so we had to be creative. Instead of using the Git client, we started using the GitHub API and some retry logic to introduce changes to the environment state repositories.</p><p>The increased number of deployments made by bots was strangulating the system. As the developers gain confidence in the CI/CD system, they begin to allow bots to create Pull Requests (PRs) and deploy them. In this case, we are referring to PRs from Dependabot to upgrade dependencies and PRs from our system to manage service resources (the autotuner), allowing developers to focus less on the amount of CPU and Memory to provision for their services and let a bot refine resource utilization. We created a priority queue, similar to an express checkout lane in a supermarket, to ensure that a developer’s deployment could always be processed quickly. In short, the Deployment Registrar has a maximum limit on the number of deployments that can be processed in parallel. From this limit, we allocate a quota for deployment submitted by developers, ensuring that no developer is waiting in line behind a bot. This new feature will be vital in our adoption of AI Native engineering, where some PRs with quality-of-life improvements will be delivered by AI agents.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pt5zudjHFNRGDvcdI77qmw.png" /><figcaption>Our bots cloging our deployment pipeline</figcaption></figure><p>This enormous number of deployments begins to reveal some failures in our communication system between ArgoCD and GitHub Actions, built on top of commit status. Although the failure rate was 0.1%, meaning that 1 in 1000 deployments failed due to an unsatisfactory communication issue, it was unacceptable to us. After several hours of troubleshooting and experimentation, we identified incorrect configurations and race conditions in the flow of events, which is basically when two messages get sent at the same time and get their order crossed, causing confusion. First, we modified the ArgoCD notifications to ensure that we send the notification event only once per sync revision. On the other side of the communication channel, we had a fallback logic that, after a timeout, GitHub Actions started to check the order of commit status using a more expensive API to determine if the deployment was successful or not.</p><p>However, I can tell you that the journey to migrate to GitHub Actions didn’t end after those seven months of migrations; we still had to migrate our package release flow and workflows from specialized teams, such as Information Security (InfoSec). At the moment I am writing this blog post, I am on a mission to migrate the CI/CD of our Mobile team to ditch Jenkins and their self-hosted runners based on MacMinis and start using GitHub Actions with a hybrid approach of our Self-hosted and GitHub-hosted Runners.</p><h3>Final Thoughts: Our Journey in a Nutshell (TL;DR)</h3><p>So, what’s the big takeaway from our two-part adventure? For those just joining or wanting a quick recap, here’s the entire journey in a nutshell.</p><p>Our story began with a classic problem: our faithful but aging Jenkins setup was groaning under the scale of 300+ engineers and 100+ daily deployments. It had become a bottleneck. After a brief detour trying to build our own CI engine, we turned our attention to GitHub Actions.</p><p>Our initial experiments were promising, but quickly revealed we needed a self-hosted solution for cost, control, and security. This led us to build a robust, auto-scaling runner platform on Kubernetes with EKS, Karpenter, and ARC. The “eureka moment” came when we paired GitHub Actions for CI with ArgoCD for a GitOps-style continuous delivery, creating a prototype that developers loved.</p><p>But a prototype isn’t a platform. We then matured the solution by bridging the communication gap between GHA and ArgoCD using GitHub Commit Statuses and building a central “Deployment Registrar” for a unified view of all 800+ services.</p><p>The real challenge was the 7-month migration marathon. Success was only possible through heavy automation — creating a nearly one-click migration process — and a focus on empowering our engineering teams to drive their own transitions.</p><p>Was it worth it? Absolutely. We cut our CI compute costs by 50%, quadrupled our deployment frequency, and, most importantly, delivered a seamless, integrated CI/CD experience that our developers genuinely prefer. The path wasn’t perfect — we battled bottlenecks and race conditions as we scaled — but each challenge made our system more resilient.</p><p>Ultimately, this was more than a technical migration; it was a strategic investment in our developer experience and our ability to deliver value to customers faster. It’s a story about people, processes, and finding the right tools to build the future.</p><p>This blog post is based on the talk I did in February 2025 at Pipedrive Talks Lisbon</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fwww.youtube.com%2Fembed%2FVrE1dh-1zEY%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fwww.youtube.com%2Fwatch%3Fv%3DVrE1dh-1zEY&amp;image=https%3A%2F%2Ffd.xuwubk.eu.org%3A443%2Fhttps%2Fi.ytimg.com%2Fvi%2FVrE1dh-1zEY%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2e2509284ccd13888a35f2b7999884f3/href">https://medium.com/media/2e2509284ccd13888a35f2b7999884f3/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fcacf834afd2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/all-aboard-the-github-actions-express-pipedrives-big-ci-cd-switch-part-2-fcacf834afd2">All Aboard the GitHub Actions Express: Pipedrive’s Big CI/CD Switch (Part 2)</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HAL — How Pipedrive leverages RAG for better knowledge sharing]]></title>
            <link>https://medium.com/pipedrive-engineering/hal-how-pipedrive-leverages-rag-for-better-knowledge-sharing-5e427c438212?source=rss----2bd16bce47da---4</link>
            <guid isPermaLink="false">https://medium.com/p/5e427c438212</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[pipedrive]]></category>
            <dc:creator><![CDATA[Ruben Silva]]></dc:creator>
            <pubDate>Tue, 22 Jul 2025 09:38:57 GMT</pubDate>
            <atom:updated>2025-07-22T09:39:27.978Z</atom:updated>
            <content:encoded><![CDATA[<h3>HAL — How Pipedrive leverages RAG for better knowledge sharing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bBo76zwSkpcY68xA" /><figcaption>Interdependency of documents</figcaption></figure><h3><strong>Introduction</strong></h3><p>Finding the right information quickly can often be the difference between frustration and productivity. Companies have a multitude of data sources (<em>such as internal documentation, codebases, services</em>), often requiring users to go through each one of these manually to reach a proper conclusion. What if we could do it smartly with AI?</p><p>At <strong>Pipedrive</strong>, we faced this challenge head-on by developing HAL, our personalized in-house AI assistant allowing our employees to quickly discover and access our vast internal documentation and systems.</p><p>This article will explore how we built <strong>HAL</strong> using <strong>Retrieval-Augmented Generation (<em>RAG</em>)</strong>, the underlying technical architecture behind it, what challenges and limitations we faced, and the overall impact it had on our organization. Whether you are considering implementing a similar solution or just simply interested in practical <strong>RAG</strong> applications, this article will explore the aspects of <strong>AI-powered document discovery</strong> through it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9JFgDMTAnf5dIAbu" /></figure><h4><strong>Huh? RAG?</strong></h4><p><strong>Retrieval-Augmented Generation</strong> (<strong><em>RAG</em></strong><em> for short</em>) combines the power of large language models (<em>statically frozen in time with huge amounts of data</em>) with the ability to incorporate external knowledge WITHOUT the need of fine tuning.</p><p>Traditional LLMs are limited to the data they have been trained upon, and the likelihood of “<strong>hallucination</strong>” (<em>generating plausible, but incorrect information</em>) increases rapidly for data outside its training corpus. RAG addresses these issues through the following:</p><ol><li>Given a user query, retrieve the most relevant documents</li><li>Provide these documents as context to the LLM</li><li>Have the LLM generate the response based on the combined knowledge of its training dataset AND the pasted context (<em>in this case, our external documents</em>)</li></ol><p>This approach significantly reduces hallucinations and allows the AI system to have access to real-time information that otherwise it wouldn’t have.</p><p>Now how can we exactly automate this? Copy pasting documents into an LLM prompt requires some manual labour from the user part. The next section will go over how we went about it.</p><h4><strong>How does it work?</strong></h4><p>Given LLMs do not support infinite context windows (<em>how much information it is able to retain in memory</em>), we have to be smart on what documents are decided to be forwarded to the final system. We have tackled this by combining both Vector search and keyword search on the most likely relevant documents.</p><p>Like all approaches, this has its own caveats. Queries that ask for “<strong>All of the incidents in the last 5 years</strong>” will most likely fail unless there happens to be a Table of contents with such a list OR a tool is used for such purpose (<em>i.e: a tool to return all incidents</em>).</p><p>We decided to go with a full Slack approach. This saved time as we did not need to build a custom UI (<em>easier to maintain the overall layout with Slack blocks, 1 dependency to update, which is the Slack framework</em>), plus we could use a tool every Pipedriver is already familiar with, skipping the need having to go to a specific page to interact with system.</p><p>Given that most of the functionality of HAL is on-demand (<em>i.e: either via commands/modals, shortcuts or DMs</em>), we had a good enough toolset to work with.</p><p>HAL is divided into 2 main components. The data collector portion and the bot function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NJOB6LAeGyRjBeP6" /></figure><h4><strong>Data collector</strong></h4><p>The data collector is responsible for gathering, processing and storing our documentation in embedding and raw format within a Database. The general workflow goes as follows:</p><ol><li>Cronjob to query each sources api to fetch documents</li><li>Check if the document already exists in DB. If so, update them if they are outdated</li><li>Format the docs to markdown</li><li>Chunk them (<em>2000 characters or 512 tokens works pretty well, you can play around with this</em>)</li><li>Embed the chunked documents using OpenAI embedding model or locally</li><li>Store these in a MySQL database as binary vectors and a reference (<em>a url or a hash</em>)</li><li>Store the whole document in DB as well with a reference to the vector (<em>in this case we decided it to be the URL of the document for simplicity</em>)</li></ol><h4><strong>Bot</strong></h4><p>The bot component handles user interactions, query processing and response generation.</p><p>HAL has evolved into supporting different use cases, from summarizing long Slack threads, to Q&amp;A on Google Docs, to running its own playbooks to help investigate our own SLO alerts. (<em>more on that in a separate article</em>)</p><p>I will talk more on the side of RAG and Q&amp;A based on that. A general workflow for users who wish to find information goes as follows:</p><ol><li>User tags the Slack bot or sends a message via Direct message</li><li>Bot processes the query and breaks it down into keywords</li><li>Bot does semantic search in MySQL (<em>you can achieve the same using ChromaDB and other offerings</em>), return <em>top-k</em> most similar chunks (<em>we chose to return at most 5 documents per source</em>)</li><li>Bot takes the most relevant top-k chunks, and gets the whole documents.</li><li>Bot additionally performs keyword search in MySQL whole documents.</li><li>Do reciprocal rerank fusion using vector / keyword results. Vectors have higher weights.</li><li>Bot sends whole documents 1 by 1 into LLM for filtering for relevancy (<em>Yes | No output</em>)</li><li>If LLM filters documents, we send this reduced list. If all results were irrelevant, use vector search results as fallback.</li><li>Send final list of retrieved <strong>WHOLE</strong> documents (<em>not the chunked</em>) into LLM along with the original query for an answer</li><li>Forward answer to user with a list of citations. If a proper answer cannot be formulated based on the list of links, LLM will return “<em>I do not know</em>”.</li></ol><h4><strong>Trade offs and LLM pitfalls</strong></h4><p>There are a couple of tradeoffs with this approach. Knowledge graphs tend to capture more intricate relationships between sets of documents, which traditional RAG won’t retrieve these, however building such a KG typically requires manually labeling documents through tags / labels (<em>you could in theory build a Knowledge Graph on some sources like confluence, where documents typically reference each other via parent/children relations, or by being explicitly mentioned</em>).</p><p>Vector search alone will cover a good portion of use cases, although when paired with Keyword search (<em>Hybrid search</em>), for cases where you are looking for a specific document and you know the exact keywords roughly, Hybrid search typically performs better compared to 1 method alone.</p><p>Sending whole documents to the LLM after this reranking helped improve answer accuracy. At the moment, the more documents the LLM has to leverage for a final response to the user, the more inaccurate it typically is, so this filtering step helps a lot. The beefier the LLM (<em>more parameters</em>), the more accurate this filtering tends to be.</p><p>The problem is essentially a search problem and a LLM problem, but with different weights. No matter how good the LLM might be across a plethora of topics, the truth of the matter is, if the search retrieves irrelevant documents, the answer might prove to be irrelevant, as the LLM has no insider knowledge of a company’s internal workings. However, the same applies in reverse (<em>to a degree</em>) — A good enough search might not be able to save a wrong answer if the LLM is not that good (<em>i.e: too little parameters</em>). However if you can only pick to focus on one, improving search will often yield bigger returns.</p><p>At time of writing, we are using gpt-4o-mini for final inference. It is inexpensive, supports a pretty big context window (<em>128k tokens</em>), and inferences are quick, with a good enough accuracy for our purposes.</p><p>Note: You can sometimes achieve “better” results by swapping the underlying LLM model for something like Gemini models (<em>biggest context window to date, you can have a less than optimal search algorithm, so you can throw more documents at it</em>) or gpt-4o (<em>a step above gpt-4o-mini</em>), at the cost of inference speed and price per token.</p><h4><strong>Impact</strong></h4><p>Devs at Pipedrive leverage HAL to find documentation more quickly. Say for example you are interested in knowing what the root cause was for the last severe incidents, or in the case you are new, how to perform an operation with a given service. The tooling is convenient to use (<em>as it is right in Slack</em>), so no need for custom Frontend UIs, The following are illustrative examples (<em>some stuff has been redacted</em>).</p><p>Overall, employees can find documentation in seconds compared to what would take minutes (<em>or potentially hours waiting for a response in Slack</em>). We conducted a survey and found that it saves 20 minutes on average per information-seeking task. Over the span of 2 weeks, we have had over 100+ unique interactions with the bot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DBMEFNTSB5fIQqQM" /><figcaption>Interaction with HAL on how to retrieve all feature flag rollouts</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iUu56VTQG43HUc6j" /><figcaption>Interaction with HAL on what was the last occured incident</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/0*iJypWp5zp2wXCyc0" /><figcaption>Interaction with HAL on how to register a new Kafka consumer in Fastify</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YBH-knbo5-GVlll9" /><figcaption>Interaction with HAL on how to setup dev environment in Windows and macOS</figcaption></figure><h4><strong>Challenges and Limitations</strong></h4><p>Pairing Vector search / keyword search (<em>something deterministic</em>) to work with a non-deterministic element (<em>in this case LLM</em>) is challenging. A slight adjustment of a query sometimes is the only thing needed to yield appropriate results. The findings are the following:</p><p><strong>Finding 1:</strong> Skip the fluff and go straight into the core of the query. What is the intended output of the query? Provide just enough context necessary to complete the task.</p><ul><li><strong>Example of good query:</strong> How are oncall calculations done and who is responsible for tracking it?</li><li><strong>Example of a bad query:</strong> Hello, hopefully you can help me out. Could you please point me towards the documents that show me how on-call is calculated? I did some hours last week and I am interested to know who is responsible for tracking it.</li></ul><p><strong>Solution: </strong>LLM preprocessing to extract the minimal viable query</p><p><strong>Finding 2: </strong>Answering “<em>Get me all of X</em>” is quite a hard question to answer with traditional RAG, as you will get the semantically closest text, but not exactly dependent documents between each other. You have a couple of options to tackle this:</p><ul><li><strong>Option 1:</strong> You introduce tools that are able to query a DB / APIs to return a list of all elements. You might run out of context if there are many elements.</li><li><strong>Option 2:</strong> You incorporate a knowledge graph with entities and do hybrid RAG (<em>Knowledge Graph + Vector search</em>).</li></ul><p><strong>Finding 3: </strong>Search is far from a solved problem. Queries that work well for one particular data source, might not retrieve relevant content from another. Narrowing down the domain in which your corpus of data improves accuracy and search performance. One size fits all tools will sacrifice reliability for convenience.</p><p><strong>Finding 4:</strong> Context is everything, but can be misleading. LLMs can get distracted by instructions within the query. This ties back to Problem 1.</p><ul><li><strong>Example:</strong> Retrieval fetching 2 documents, 1 that is up to date, and 1 that is outdated. Both are included within the final answer</li></ul><h4><strong>Why MySQL?</strong></h4><p>Previously, we were running <strong>ChromaDB</strong> in production for <strong>HAL</strong>, however due to the lack of documentation (<em>and experience with it</em>), it was hard to work with. Given that at Pipedrive we use MySQL and have pretty good experience playing around with it, it seemed like a good choice. (<em>If you use Postgres, you can check out pgVector</em>).</p><p>MySQL supports Vectors and a couple of vector related functions. This means that we can store embeddings within it and just use raw SQL to do a simple cosine similarity between two vectors.</p><p>Granted, we needed custom tooling to support semantic search. As we also use Fastify, it seemed like a good idea to wrap a plugin around it to allow devs to use semantic search in their projects without much of a hassle of writing the SQL themselves. So a plugin was built for it called <em>fastify-semantic-search</em>.</p><p>The jist was simple. All you had to do was generate embeddings with the plugin, have the appropriate dedicated tables to store the embeddings and raw page content (<em>lets say b_table with (raw_embedding, reference) and raw_table with (content, reference, metadata)</em>), then devs could find the most similar top-k documents via a simple invocation of getClosest(<em>docs, top-k</em>), returning a list of rows and their respective reference</p><p>This allowed us to deprecate ChromaDB and leverage vector search with tooling we were already familiar with.</p><h4><strong>What’s next?</strong></h4><p>We want HAL to become a personalized assistant for everyone. To do so, we are also aiming to leverage different agentic capabilities that are arising from ever more powerful LLMs. The following are on the roadmap:</p><p><strong>Playbooks</strong> — Users write the playbooks with a set of instructions in natural language, LLM picks from a vast array of tools to accomplish this goal, leading to personalized experience</p><p><strong>Agentic action</strong> — HAL is “<strong>read-only</strong>” right now. Eventually, it will be able to perform actions on behalf of the user (<em>No action that mutates state should be run without supervision and acknowledgement of the user, lest the production database gets dropped for such mistake :) )</em></p><p><strong>Expanded data sources</strong> — Connect HAL into more additional internal systems and external resources.</p><h4><strong>Conclusion</strong></h4><p>Building HAL has shown that RAG and state-of-the-art can completely transform how users interact with documentation.</p><p>The<strong> key insights</strong> from our journey include:</p><p><strong>Hybrid search outperforms single methods:</strong> Whether you opt for vector-search, keyword search or Knowledge graphs, combining these methods allows your search to provide more robust results, covering a larger range of queries.</p><p><strong>Interface matters: </strong>Users will have less friction using a tool if its already embedded into their usual workflows / tools. This will increase adoption (users can quickly try), as well as reducing development overhead.</p><p><strong>Filtering: </strong>We have found that LLM-Based relevance filtering significantly improves response quality. Depending on the scale of your userbase, consider adopting it into part of the workflow.</p><p><strong>Trade-offs are inevitable: Search quality, inference speed </strong>and<strong> cost</strong> will need to be balanced according to the use case. For us, search quality matters the most for our internal users, however for production use, focusing on cost / inference speed becomes more important due to larger scale.</p><p>To wrap it off, what are your experiences with RAG systems? Feel free to reach out in the comments and share insights!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e427c438212" width="1" height="1" alt=""><hr><p><a href="https://medium.com/pipedrive-engineering/hal-how-pipedrive-leverages-rag-for-better-knowledge-sharing-5e427c438212">HAL — How Pipedrive leverages RAG for better knowledge sharing</a> was originally published in <a href="https://medium.com/pipedrive-engineering">Pipedrive R&amp;D Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>