Jessica Lee Bedford

"Bob the Builder! Can we fix it? Yes, we can!"

Remember that catchy song? (Maybe it’s different in your language, but the idea stays the same.)

Now think about your software projects. A stakeholder asks, "Can you add this new feature?" and your immediate thought might be: "Yes, we can!" or "No, we can't!"

But wait—your real answer is often more complex.

A better way:

✅ Explain clearly WHY you can (or can't).
✅ Show what the consequences or impacts will be.

For example:

"Yes, we can add that new login feature, but it will delay our current timeline by two weeks because we'll need additional security testing."

"Unfortunately, we can't integrate that API right now. It’s outdated, which poses serious security risks. However, we can look into alternative solutions."

Clear answers build trust, improve understanding, and help everyone make better decisions.

Next time, don’t just say "Yes" or "No"—explain why clearly!

How would you feel getting feedback from your team on a problem you were facing?

You’d probably appreciate their insights. Even if you didn’t use their idea, it might lead you to a solution.

Now, how would you feel getting feedback from your team on your English?

If that feels uncomfortable, ask yourself: Why not?

If you’re willing to learn from each other on:
Better solutions.
Better testing methods.
Where to implement automation (or not).
Better coding standards.

…then why not help each other with English, too?

Here’s the thing:
Everyone has strengths and weaknesses in English, even native speakers.
By giving and receiving feedback, you create a culture of growth.
You’ll learn from each other’s unique perspectives and experiences.

Imagine a team where everyone feels safe enough to say:
“Can I suggest a better way to phrase that?”
“Here’s a word that might work better.”
“Let me help you with that pronunciation.”

The result? Your whole team improves together.

So, why not start today?

Most software developers aren’t native English speakers yet programming languages are in English.

This can make you feel like you’re “bad at communicating.”

But here’s the truth: It’s not about your ability. It’s about having the right tools.

You have ideas. You have great thoughts. You’re smart. You’re good at your job.

You just need the structure to communicate those ideas effectively.

Here’s the thing:
You already have the ability. You learned a programming language (and many of you are self-taught, which is even more impressive).
Did you become a coding expert by just reading and watching videos? No. You practised. And practised. And practised some more.

The same goes for English.
It takes time.
It takes effort.
It takes hard work.

And if you need to improve your speaking? You need to speak.

**On a side note, the statistics vary quite a lot in terms of countries with the most developers. I'll leave a link for both in the comments and you can read both articles. Either which way, there are a lot of non-native English developers out there!
__________________
If this sounds like you, send me a DM. This is how many of my students felt before we started working together.

Hi, I’m Jessica. With over 9 years of experience teaching and coaching English, I help tech professionals feel more confident while leading their teams.

Let’s turn your ideas into impactful communication.

What Does Communication Actually Mean?

I saw a job description recently that listed “good communication skills” as a requirement for a software developer.

It got me thinking: What does communication actually mean?

Is it:
The ability to talk and share ideas?
The skill of listening deeply?
The power to influence with words?
The flexibility to adapt your message to your audience?
The patience to explain complex things simply?
The effort to truly understand others?

Or is it all of the above?

For me, communication is hard to pin down, but here’s how I’d define it:
→ Feeling truly heard when you speak
(even when others disagree).
→ Truly listening to others
(not just waiting for your turn to talk).
→ Creating a space where everyone feels comfortable to share their thoughts.
→ Asking questions
(from clarifying ones to the hard questions no one wants to ask).
→ Explaining things clearly
(without frustration when others don’t immediately understand).
→ Being open to discussing almost anything
(but also knowing where to draw the line).

Communication isn’t just about words. It’s about connection, understanding, and respect.

Have I Reached My Limit?

A student asked me this last week.

He’s been doing all the things, listening to podcasts, practising grammar, and attending classes but still felt stuck.

“Am I just not improving anymore?”

We talked through everything he was doing (and what wasn’t working). The conclusion? He needed to speak more not just with me, but with others.

But here’s the catch: Starting random conversations isn’t in his nature. It feels awkward, forced, and uncomfortable.

So, we came up with a solution: Group conversation classes.
I’ll pair him with 2 other students.
They’ll talk about topics they care about.
If they hit it off and want to continue outside class? Perfect.

Because my goal isn’t to keep students forever. It’s to make them feel confident and comfortable with their English.

And here’s the kicker: When I suggested a price for the group class, he said: “That’s too cheap. You should at least double it.”

It was a reminder that great students don’t just value your help, they value your time.

Here’s to students who push us to grow, just as we push them.

(And to the student that inspired this, you are fantastic)

We've all been there... the blank stare of the person we are talking to.

The look of complete confusion because they have not understood a single word that we have just said....

“The API’s latency spiked due to a cascading failure in the microservices architecture.”

The person you are talking to, staring blankly. The conversation stalling.

Here's a rule I live by: If you can’t explain it simply, you haven’t understood it well enough.

And here’s how to bridge the gap:

1. Ditch the jargon.
Words like “API,” “latency,” or “microservices” mean nothing to someone outside tech.

2. Use analogies they’ll recognize.
For example
“An API is like a waiter. You tell the waiter your order (request), and they bring your food (data) from the kitchen (server). If the waiter is slow, your food arrives late. That’s latency.”

3. Focus on impact, not mechanics.
Instead of: “The database is overloaded.”
Say: “The system is like a library with too many people checking out books at once. We need to add more librarians or streamline the process.”

4. Check for understanding.
Ask: “Does that make sense?” or “Should I clarify anything?”

The goal isn’t to showcase your expertise, it’s to solve problems together.

Why do people say that their county's English is worse than another country's?

“Our English in Spain isn’t as good as Germany’s.”
“Germans sound more robotic when they talk not as fluid as Italians.”
"Everyone knows that Europe speaks better English than in Asia."

I hear these comparisons often and they drive me a bit crazy.

Here’s the truth... Every country has unique strengths in how they learn and use English.

🇩🇪 Germans focus on structure and precision, pronouncing each word clearly.
🇪🇸 Spanish speakers master the flow and rhythm of English, capturing the emotion in a sentence.
🇰🇷 Koreans understand syllable connections and phonetic patterns intuitively.

But here’s what we all struggle with:
A system that prioritizes reading and writing over speaking. This isn’t a “country problem”, it’s a methodology problem.

Instead of comparing yourself to others, ask:
What unique strengths does my language background give me?
How can I build on them to communicate more effectively?

Your accent, your rhythm, your way of thinking, they’re not flaws. They’re proof that you’ve bridged two worlds.

So, stop saying your country’s English is “worse.” Start saying: “I’m proud of how far I’ve come.”

When ‘That’s a Good Question’ Isn’t Enough

One of my students recently shared a frustrating experience.

During company meetings, he’d ask questions about upcoming changes, only to feel like he wasn’t understanding the answers. At first, he thought it was his English. Maybe something was getting lost in translation.

Then a colleague pulled him aside and said: “I love your questions, but I’m also confused by the answers or lack of answers.”

That’s when it hit him: The problem wasn’t his English. It was the responses he was getting.

Too often, leaders respond to tough questions with:
“That’s a good question.”
“Let me think about that.”
“We’re still figuring that out.”

While these might feel like safe, “political” answers, they’re not answers at all. They leave people feeling unheard, uncertain, and frustrated especially during times of change.

Here’s how to do better:

Be clear and direct.
If you have an answer, share it. If you don’t, say: “I don’t have the answer right now, but I’ll get back to you by [specific time].”

Follow through.
If you promise to follow up, do it. Trust is built on consistency.

Acknowledge uncertainty.
It’s okay to say: “This is still evolving, but here’s what we know so far.”

Change is hard enough without vague answers. Be the leader who provides clarity, not confusion.

Explaining a problem doesn’t have to be a 10-minute monologue. In fact, the simpler you keep it, the faster you’ll get to a solution.

Here’s a 3-step framework I use (and teach):

1. Simplify the problem.
Don’t dive into every detail. Focus on the core issue.
Example: “The API is returning a 500 error when we try to fetch user data.”

2. Explain the impact.
Be clear about what the problem causes.
Example: “This is blocking the frontend team from testing the new feature.”

3. Offer solutions (or ask for help).
Share what you’re doing to fix it—or start a discussion if you’re stuck.
Example: “I’m checking the server logs now. Do you have any ideas on what might be causing this?”

What if you’re not sure about the problem or the solution?

If you’re unsure about the problem, explain what’s happening.
Example: “The app crashes when we click this button, but I’m not sure why yet.”

If you’re unsure about the solution, invite collaboration.
Example: “I’ve tried X and Y, but it’s still not working. What do you think?”

The goal isn’t to have all the answers. It’s to communicate clearly so you can find them together.

Your turn: What’s one problem you’ll explain better this week?

a problem doesn’t have to be a 10-minute monologue. In fact, the simpler you keep it, the faster you’ll get to a solution.

Read about the 3-step framework I use (and teach) in more detail below but it follows these basics:
1. Simplify the problem.
2. Explain the impact.
3. Offer solutions (or ask for help).

What if you’re not sure about the problem or the solution?
Well, there are phrases that we can use to invite collaboration.

The goal isn’t to have all the answers. It’s to communicate clearly so you can find them together.

“Swipe to see why overthinking emails is slowing you down. 👇

📧 Overthought Email:
3 paragraphs of fluff.
10 minutes of editing.
Zero clarity.

📧 Simple Email:
1 clear purpose.
1 concise message.
1 direct call-to-action.

Stop stressing. Start simplifying. 💬

🚀 3 Questions to Fix Boring Sprint Retros

Sprint retros feeling like a chore? 😴
Time to turn “ugh” into “aha!” 👇

1️⃣ “What should we START, STOP, CONTINUE?”
Example: “START daily syncs, STOP skipping docs.”

2️⃣ “If you had a magic wand, what’s ONE fix?”
Example: “Automate deployment!” 🪄

3️⃣ “What’s a win no one’s talked about?”
Example: “Shoutout to Sam for fixing legacy code!” 🏆

Save this for your next retro! 💡

Better questions → Better conversations → Better team.

Want to avoid awkward silences in meetings?

Stop searching for the “perfect” question (which halts conversations and kills momentum).

Try phrases like:
“Tell me more about…”
“What else can you say about…”

Why these work:
✅ They keep the dialogue flowing without pressure.
✅ They signal genuine interest, making others feel heard.
✅ They encourage teammates to elaborate, revealing insights you might miss otherwise.

The best questions aren’t “perfect”, they’re curious.

For example:
If a developer says, “The QA process is taking longer than expected,” instead of scrambling for a “solution-focused” question, ask:
“Tell me more about the challenges you’re facing.”

This opens the door to collaboration, not interrogation.