Forem: Pratik Patel

The Power of Saying No (And How It Can Save Your Sanity)

Pratik Patel — Fri, 21 Feb 2025 21:27:18 +0000

The Power of Saying No (And How It Can Save Your Sanity)

Early in my career, I was that engineer. The “Yes Person™.”

“Can you take on this extra feature?”

Yes!

“Can we launch a week early?”

Sure! Why not!

“Can you hop on a quick call at 9 PM?”

Of course!

I thought saying yes to everything made me a team player—someone reliable, indispensable, and on-track for all the accolades. But more often than not, those yeses led me to tight deadlines, late nights, and some… creative technical workarounds (you know, the kind that makes future-you weep).

The turning point? Learning to say no. Or more often, the more diplomatic cousin of no:

“Yes, but we’ll need to adjust the timeline.”
“Yes, if we drop another lower-priority task.”
“No, because that would introduce tech debt that will haunt us forever.”

Turns out, strategic no's transformed me into a better engineer, a better teammate, and a much more effective professional overall. Here’s why—and how you can harness the power of no to elevate your own work and sanity.

The Problem with Always Saying Yes

The tech world often glorifies the Yes Person. They’re seen as flexible, eager, and a team player. But saying yes to everything has some hidden costs, particularly in fields like engineering and project management, where the stakes are consistently high.

Here’s what unchecked yeses can lead to:

Burnout: Saying yes to more commitments than you have time for inevitably results in exhaustion. Constant late nights and rushed work don’t lead to personal or professional growth—they just empty your tank.
Technical Debt: Agreeing to overly ambitious deadlines often means cutting corners. And what looks like success in the short term will leave your team paying interest on those decisions for years.
Chaos over Quality: When everything is a priority, nothing is a priority. Projects finished under the weight of “yes to everything” tend to lack the structure and finesse that truly stand out.

Ultimately, saying yes to everything doesn’t make you a hero; it makes you a hazard—to yourself and your team.

Why Saying No is a Superpower

Saying no strategically isn’t just about protecting your sanity (although, that’s important too). It’s about ensuring long-term success—for yourself, your projects, and your team.

Here’s what saying no can do for you:

Prioritization: Establishing boundaries allows you to focus on the tasks that truly matter. Delivering one product milestone well beats delivering five poorly.
Preserving Quality: Fewer commitments mean more time to work thoughtfully and effectively on the things that count. Instead of sweating over quick fixes, you can build something to be proud of.
Realistic Planning: Pushing back helps prevent impossible timelines and stops burnout culture in its tracks. Deadlines grounded in reality are better for you, your team, and—surprise—for your leadership’s trust in you.

The key lesson? Saying no isn’t about being difficult or resistant; it’s about ensuring decisions align with real constraints, shared goals, and long-term success.

How to Say No Without Burning Bridges

If the thought of saying no sends a wave of anxiety through your body, don’t worry—you’re not alone. Engineers, tech leads, and project managers alike often worry about how saying no might damage their reputation or relationships. But saying no doesn’t have to come across as negative.

Here are practical ways you can say no while still being collaborative and solution-driven:

1. Frame It as a Yes-But

This is one of my go-to strategies. When a request lands on your plate, consider responding with a conditional yes. For example:

“Yes, I can take this on, but we’ll need to extend the launch date by two weeks.”
“Yes, but for this to be delivered on time, we’ll have to postpone feature XYZ.”

This shows you’re being thoughtful and realistic while presenting solutions instead of obstacles.

2. Lean on Data

Pushback becomes a lot easier when it’s backed by facts. For example:

“No, because adding this feature would introduce latency that exceeds our performance benchmarks.”
“No, because we’ve already committed 12 developer hours to the sprint, and squeezing this in would put us over capacity.”

Data makes the conversation less personal and more objective, which helps teammates and stakeholders understand your reasoning.

3. Prioritize Tech Debt

Get comfortable with saying things like:

"No, because rushing this will create tech debt that will haunt us down the line."
“No, because this violates our codebase standard and will slow development in future sprints.”

Every tech lead or product owner encountering these perfectly logical reasons will breathe a secret sigh of relief (whether they admit it or not).

4. Practice Transparency

Don’t just say no; explain the "why." Transparency builds trust. For instance:

"No, because I’m already loaded with task A and task B, and compromising quality isn't something I’m comfortable with."
“No, because this request requires resources we don’t currently have allocated.”

When people understand your reason, they’re more likely to agree with your decision.

5. Default to Diplomacy

Sometimes, the classic “no” can feel abrupt. Instead, try softer alternatives that maintain rapport:

“That’s a great idea, but I think we should revisit it after we finish XYZ.”
“I wish I could help, but unfortunately, I can’t commit right now.”

You’re upholding boundaries without creating friction.

Saying No is Saying Yes (to Better Things)

Every time you say no, you’re simultaneously saying yes—to focus, quality, precision, and meaningful work. Balancing commitments isn’t just healthier for you; it also strengthens your team dynamic and ensures your engineering output always shines.

The ironic truth? Learning to say no strategically makes you far more valuable—far more indispensable—than constant agreement ever could.

If you’re reading this and thinking, "I am the Yes Person," don’t worry. We’ve all been there. The beauty of this lesson is that it’s never too late to start sprinkling in some thoughtful no’s. The difference will amaze you.

Final Thoughts

Whether you’re an engineer, a tech lead, or a project manager, mastering the art of saying no is one of the most powerful skills you can develop. Start small—be strategic—and watch how prioritizing quality over chaos transforms your career.

Remember, saying no isn’t about shutting doors; it’s about opening the right ones. Your best work—your truly impactful work—awaits on the other side.

Own Your Career: 5 Lessons to Drive Your Promotions

Pratik Patel — Thu, 20 Feb 2025 00:25:00 +0000

Early in my career, I made a huge mistake. I thought if I worked hard and hit all my deadlines, my manager would naturally recognize my efforts and drive my career forward. Promotions, salary bumps, new opportunities—they’d all come, right?

Wrong. 🚫

After waiting (and waiting… and waiting) for someone else to advocate for me, I realized I was approaching promotions all wrong. The truth is, no one will fight harder for your career growth than YOU. It's your responsibility to show your value, take ownership of your path, and create opportunities for yourself.

Here are the five biggest lessons I’ve learned about driving my career and earning my promotions.

1. You Own Your Career Path

It sounds obvious, but many professionals (my younger self included) mistakenly assume that their manager or team lead is responsible for charting their career progression. The truth? Nope. That’s all on you. Your growth, development, and career path are in your hands. While managers can provide guidance, feedback, and opportunities, it’s ultimately up to you to set goals, seek out learning experiences, and take the steps needed to advance.

That’s not to say that some managers don’t genuinely want to see you succeed—they absolutely do. But keep in mind, most managers are juggling their own set of responsibilities, goals, and ambitions. They may be focused on hitting deadlines, managing team performance, or achieving personal career milestones. As a result, even the most well-intentioned managers may not always have the time, resources, or bandwidth to give your career growth the dedicated attention it deserves. This is why it’s crucial to take ownership of your own development. By being proactive and self-driven, you’ll be able to move forward regardless of the level of support you receive.

Think of your career as a long-term project. You’re the project manager. Success depends on setting goals, creating a roadmap, and consistently reviewing your progress. Want to move upward in your career? Ask yourself questions like:

What roles interest me in the next 2 or 5 years?
What skills do I need to develop to land those roles?
Who can help me achieve these goals?

The moment you adopt a proactive mindset, you start taking control of your trajectory. Don’t wait for someone to hand you a blueprint. Draft one for yourself and take the lead.

2. Document Your Wins Religiously

People love a good story, and your career is no different—it’s up to you to craft a compelling narrative. That narrative begins with documentation. Every single achievement, no matter how small, deserves a record.

Implemented a new software feature? Write it down. Resolved a high-stakes bug right before launch? Document it. Improved a process that saved your team time or reduced costs? Log it.

Why is this important? When promotion discussions happen (or interview panels for a new job roll around), you’ll have concrete examples to prove your value:

Outline the problem you solved.
Highlight your actions.
Summarize the results (bonus points for measurable outcomes like percentage improvement or dollars saved).

Your wins demonstrate your growth and impact. They’re your ultimate receipts. And when you bring them up in conversations, your contributions go from "implied" to undeniable.

3. Seek Out High-Impact Projects

Here’s a truth bomb I wish someone had dropped on me earlier in my career: the work you do matters, but where you focus your energy matters even more. High-impact projects are your ticket to visibility and leadership opportunities.

What makes a project high-impact?

It solves a major pain point for your team or company.
It affects a large number of people.
It drives measurable results, like saving time, generating revenue, or improving efficiency.

Don’t wait for these projects to come to you—volunteer for them. Offer to tackle that backlog no one wants to touch, spearhead a cross-functional initiative, or run an experiment that aligns with your company’s top priorities.

Pro tip: High-impact projects also showcase your ability to handle bigger responsibilities, making it easier for decision-makers to envision you in advanced roles.

Relevant Aside: While high-impact projects often take center stage, it’s important to recognize that in large companies, not all initiatives need to yield direct, measurable results to be valuable. A prime example of this lies in projects like redesigning or rewriting applications. These efforts, while not always critical in terms of immediate business outcomes, often become what’s colloquially known as “promo projects.” They give employees the opportunity to showcase their technical abilities, lead teams, or experiment with modern frameworks and tools — all of which can serve as stepping stones in career advancement.

The reality is, sometimes you have to play the game—it's about visibility and shaping the narrative. While redesigns or rewrites may not always yield clear, measurable ROI compared to maintenance or incremental updates, they capture attention. Being involved in these high-profile projects can position you as a forward-thinker, someone driving innovation or tackling significant challenges, even if the actual impact is more subtle. The key is finding a balance: embrace these promotional opportunities while also delivering meaningful, substantive work. This ensures you're recognized as a team player who contributes to both the company’s goals and your personal growth.

4. Build Relationships Across Teams

We’ve all heard the saying, “It’s not what you know, but who you know.” While skills and performance are crucial, relationships can play a big role in career growth.

Building relationships isn’t about networking in the stereotypical sense (no one likes forced LinkedIn messages). It’s about creating genuine connections with colleagues, managers, and leaders—within and beyond your immediate team.

Why does this matter?

Advocates and allies: People who see your potential can vouch for you during promotion or hiring discussions.
Opportunities: Opportunities often come from unexpected places, like collaborations or referrals from someone in another department.
Broader perspective: Understanding the challenges and goals of other teams enhances your ability to make a bigger impact in your role.
Promotion support during panels: Building relationships across teams can be crucial when promotion panels or reviews occur. Colleagues and leaders from other areas of the organization who know your work and value your contributions can provide key insights and endorsements. Their voices may carry significant weight in highlighting your impact, helping decision-makers see the broader scope of your achievements.

Start simple. Attend cross-team meetings, schedule a coffee chat with someone who inspires you, or offer to help another department with your unique skillset. Relationships are the bridge between where you are and where you want to go.

5. Ask for Regular Feedback

Here’s something I didn’t realize early enough: Feedback isn’t criticism; it’s guidance. Regular feedback from managers and peers can help you refine your skills, avoid blind spots, and identify areas to improve before they become obstacles.

Don’t wait for your annual performance review to ask, “How am I doing?” Instead, actively seek feedback throughout the year:

After delivering a major project or presentation, ask what went well and what could have been improved.
During 1-on-1 meetings, invite input on your performance and discuss how you can position yourself for growth.
Reach out to trusted colleagues for peer feedback on how you collaborate and contribute.

Remember, feedback is a dialogue, not a one-way street. Use it as a tool to learn, adapt, and grow continuously. Your willingness to evolve demonstrates maturity and leadership potential.

Bonus: Know Your Value and Advocate for Fair Compensation

Understanding your worth in the market is just as vital as pursuing career growth. Your skills, expertise, and contributions have tangible value, and recognizing this is the first step toward advocating for yourself. Research industry standards, salaries within your field, and the pay scales for your role to arm yourself with the knowledge needed to have open and constructive conversations about compensation.

While these discussions can feel daunting, they are necessary. Approach them with confidence and professionalism, outlining the impact you've made and why it merits fair recompense. Remember, advocating for your worth is not selfish—it's about ensuring a balanced exchange for your work and dedication. We’re not working for free, and compensation is a key part of feeling valued and respected in your role. Just as you seek opportunities to grow, seek the compensation that reflects that growth. These conversations are an investment in yourself and your future.

Don’t Wait—Own Your Narrative

Here’s the truth no one (except maybe your most honest mentor) tells you: Career growth isn’t just about being good at what you do. It’s about showing your value, proving your contributions, and taking ownership of your narrative.

Advocate for yourself.
Showcase your skills and initiative.
Build relationships that bolster your career.
Seek opportunities to learn, improve, and grow.

Your next promotion? It’s not a milestone in someone else’s timeline. It’s your achievement to claim. The moment you decide to take control of your career, you level up—a mindset, a skill, a role at a time.

Start now. Decide what’s next for you, map your path, and show the world what you’re capable of.

A Real-World Coding Story: Devin AI as My Co-Pilot

Pratik Patel — Fri, 14 Feb 2025 19:52:01 +0000

I recently took Devin AI for a spin on a real development task, and the experience felt like something between magic and mentorship. I had a straightforward job: implement an API endpoint to generate user access tokens for a third-party service. Normally I’d crank this out in ~15 minutes of coding. This time, I decided to hand it off to my new “AI teammate” and see what happened. Here’s how it went, step by step.

The Task & Initial Plan 🚀

My instruction to Devin was simple:

Implement the backend API based on this documentation [link to 3P website]
Add it to [microservice API name]
Utilize the existing CDK secrets logic to store the 3P API Key.

Devin’s response was almost immediate:

Understanding the goal: It parsed my request and the service docs, and quickly outlined a plan to create the token-generation endpoint.
Collecting details: Devin identified required endpoints and data (thanks to the link I gave) and noted it would need to handle authentication, token storage, etc.
Generating a plan: Before writing code, Devin presented a high-level game plan. This included creating a new route in our backend, calling the third-party API for the token, and returning the result to our app. I was impressed – the plan was thorough and made sense given the task.

In essence, Devin did a great job figuring out what needed to be done without me hand-holding the requirements. It felt like I was working with an autonomous engineer who eagerly drafts a design spec after a short request.

From Prompt to Pull Request 💻

With the plan in place, I gave Devin the green light. It jumped into coding mode. Within minutes, Devin had opened a GitHub pull request on our repository with the new API implementation. I could follow its progress in real-time through Devin’s interface. (The UI actually provides a step-by-step log of what the AI is doing – very cool!).

Watching Devin work was surreal. The UI/UX of the tool is amazing – it felt seamless and intuitive to use. As one early user noted, “Devin feels UI/UX first, not GenAI first,” emphasizing that the surrounding experience is the star. I have to agree. In my case, giving instructions felt as easy as chatting with a colleague, and I could see Devin’s thought process and actions clearly. The combination of a chat interface, an embedded code editor, and live updates made it feel like pair-programming with a supercharged junior dev.

Soon, the PR was ready for review. The code Devin produced was surprisingly solid for a first pass. It had set up the new API endpoint, made calls to the third-party service, and hooked everything into our backend. All of this happened while I was hands-off.

Hiccups and Iterations 🛠️

Of course, it wasn’t perfect out of the box. Upon reviewing the pull request, I spotted a few issues that needed addressing before this code could go to production. Notably:

Missing API key logic: Devin forgot to include the authentication API key when calling the third-party service. A human engineer knows that’s a must for the request to succeed, but the AI overlooked this detail on the first try.
Code style differences: Some of the naming conventions and formatting didn’t match our project’s style guidelines. (Minor issue, but something we’d fix in any code review – even with human contributors.)
Best practice tweaks: I noticed that the API logic for calling the 3P service should have been abstracted into our "clients" library. While Devin’s solution was functional, integrating this logic into the shared library would improve maintainability and align with our standards.

The great thing was that, addressing these issues felt very natural. I went into the PR on GitHub and dropped comments exactly like I would for a human colleague. For example, I pointed out where the API key should be injected, suggested where to move code around, and reminded to clean up some unneeded additions.

Devin took this feedback in stride. It truly felt like collaborating with a keen junior developer: I’d leave a note, and Devin would go off to fix it. Devin was eager to improve and quickly pushed new commits to the PR, incorporating my suggestions.

We went through about 2-3 iterations like this. Each cycle, I’d review the updates, find fewer things to tweak, and comment on the remaining issues. Devin would promptly address them. After this iterative back-and-forth, the API code was production-ready. All tests passed, the style was consistent, and the integration worked flawlessly with the third-party service.

Time Trade-Off: 15 Minutes vs 1 Hour ⏱️

You might be wondering: Was using Devin worth it, time-wise? By the numbers, doing it myself would have been faster – roughly 15 minutes of coding versus about 1 hour to get it done via Devin (including the initial setup, waiting for the AI to do its work, reviewing the PR, and guiding the fixes). That’s a 4x increase in wall-clock time for the task, which sounds like a loss in efficiency.

In fact, others have noted this current limitation of AI coding agents. The waiting and iterative feedback loop can indeed make the process longer than just writing the code yourself, especially for a simple task.

However, here’s the catch: while Devin was working, I wasn’t stuck waiting idly. During that 1 hour I was free to focus on other work. I answered a couple of messages, reviewed a different PR from a teammate, and even started brainstorming a design for an upcoming feature – all while Devin handled the heavy lifting for this task in the background.

In essence, that hour wasn’t me twiddling my thumbs; it was more like delegating to a capable assistant. Yes, the calendar time was longer, but my personal time investment was much less than an hour of active coding. I probably spent only a few minutes giving instructions and about 5 minutes total reviewing and commenting. The rest of the time, Devin was on the job autonomously.

It’s a trade-off: faster solo vs. parallelized teamwork. If I had 10 such small tasks in a sprint, I could theoretically assign them all to Devin and attend to bigger challenges, checking in occasionally for reviews. That ability to multitask is where a tool like this shows its value.

The UI/UX: A Smooth Ride 🎨

I have to come back to Devin’s user experience, because it really enhanced the whole process. The interface made it super easy to interact with the AI:

I gave my instructions in a chat-like format (in our case, through Devin’s Slack integration and then via GitHub PR comments). No complex setup or configuration; it was like talking to a teammate.
Devin kept me updated with a live log and even a “plan file” of notes. I could literally see what it was thinking – the steps it was taking, the commands it ran, files it created or modified, etc. This transparency is huge for trust when an AI is writing your code.
The pull request it opened was clear and well-structured. It included a description of what the change was and even referenced the task (just as a diligent dev would do).
When I left feedback, the UI (and GitHub integration) notified Devin immediately. It felt like the system was built around a smooth feedback loop, which is crucial. I commented and within a minute Devin’s next update had the fix implemented.

The polish and thought put into Devin’s UX did not go unnoticed. It didn’t feel like using a clunky experimental tool; it felt like working in an environment built for developers’ comfort. This level of refinement in developer tools is refreshing – it let me focus on the results rather than wrestling with the tool itself.

Final Thoughts: A Promising Co-Pilot, Not a Replacement 🚧

After this trial run, here’s my reflection: Devin AI is not replacing engineers anytime soon, but it’s certainly a promising co-pilot. The experience was akin to working with a supercharged junior engineer who can execute tasks and learn from feedback. It had its blind spots and needed guidance, but ultimately it delivered real value.

The limitations I encountered (missing a key detail, needing adjustments, slower turnaround) underscore that human expertise is still crucial. In real-world development, context and subtle requirements matter – things an experienced human developer intuitively catches, but an AI might miss without a proper prompt. I had to be the quality control, just like I would with a less-experienced team member. Devin isn’t about to take over my job, and I wouldn’t trust it to run completely unsupervised on anything critical just yet.

That said, the benefits were significant. By offloading a chunk of work to the AI, I freed up mental space and time. I found myself thinking more about what needed to be done, and less about the minute details of how to code it in the moment. It’s a different way of working – more high-level orchestration, less in-the-trenches coding for certain tasks. As the creators of Devin intended, it’s meant to be a collaborative helper rather than a threat.

For a first-gen AI developer agent, Devin exceeded my expectations in UX and autonomy. It felt like I had an eager intern who works blindingly fast and never gets tired, but occasionally needs me to double-check the work. I can live with that! The technology will only get better from here. With more polish and learning from each interaction, I imagine tools like Devin will handle bigger chunks of the development workload, and do so more reliably.

Bottom line: Devin AI isn’t a replacement for an engineer – it’s a new kind of teammate. Using it won’t instantly halve your development time (yet), but it will change how you can allocate your time. I was able to focus on other priorities while it cranked out code. That kind of parallel productivity is game-changing if used right.