Practical Guide to English Tech Presentations — Slide Narration, Q&A Handling, and Demo Expressions

Good morning, everyone. My name is Youngju Kim,
and I'm a software engineer at Upstage.

Thank you for taking the time to join this session.

Today, I'd like to talk about how we improved our inference
pipeline performance by 3x using model quantization.

The goal of this presentation is to share practical lessons
we learned while deploying LLMs in production.

I've divided my talk into three parts:
First, I'll cover the problem we faced.
Then, I'll walk you through our approach.
Finally, I'll share the results and key takeaways.

This should take about 20 minutes,
and I'll leave 10 minutes for questions at the end.

As you can see on this slide, the latency dropped
significantly after we applied batch processing.

This chart shows the comparison between v1 and v2.
The blue line represents throughput, and the red line
represents latency.

I'd like to draw your attention to this particular metric —
the P99 latency went from 800ms down to 250ms.

# Increase/Decrease
"There was a sharp increase in..."
"We saw a gradual decline in..."
"The numbers peaked at 10,000 requests per second."

# Comparison
"Compared to the baseline, this is a 3x improvement."
"If we look at the before and after..."

# Ratios
"This accounts for roughly 40% of total traffic."
"The ratio of reads to writes is approximately 8 to 1."

Let me switch to a live demo now.
I'm going to show you how this actually works in practice.

What you're seeing here is our development environment
running on Kubernetes.

First, I'll spin up the service...
Now I'm sending a request to the API endpoint...
As you can see, the response came back in under 200ms.

Let me zoom in on this part so you can see the details.

# When loading is slow
"It seems to be taking a moment. While we wait,
let me explain what's happening behind the scenes."

# When an error occurs
"That's not what we expected! Let me try that again."
"Looks like we hit a network issue.
I have a backup recording — let me show you that instead."

# Using humor to move on
"Well, this is why we have staging environments, right?"
"As they say, it worked on my machine!"

"Think of a message queue like a post office —
producers drop off letters, and consumers pick them up
at their own pace."

"You can think of containers as lightweight virtual machines,
but they share the host OS kernel."

"Let me break this down step by step."
"At a high level, what happens is..."
"Under the hood, the system does three things..."
"To put it simply, ..."
"In other words, ..."

"On the left side, you have the client application.
It sends requests to our API gateway, shown in the middle.
The gateway then routes traffic to the appropriate
microservice on the right."

"The data flows from left to right:
ingestion, processing, and finally storage."

"That wraps up my presentation.
I'd be happy to take any questions."

"Before we move to questions, let me quickly summarize
the key takeaways..."

# Confirming the question
"That's a great question. Let me make sure I understand —
you're asking about...?"

# Repeating the question (for the whole audience)
"For those who didn't hear, the question was about..."

# Buying time
"That's an interesting point. Let me think about that
for a moment."

# Confident answer
"Based on our experience, ..."
"What we found was that..."

# When you don't know (be honest!)
"That's a great question, and honestly,
I don't have the exact numbers off the top of my head.
Can I follow up with you after the session?"

"I'm not sure about that specific case,
but I can point you to our documentation."

# When it's out of scope
"That's a bit outside the scope of today's talk,
but I'd love to discuss it offline."

# Critical questions
"I appreciate you raising that concern.
You're right that there are trade-offs..."

# Overly long questions
"I think I got the gist of your question.
Let me address the main point..."

# Aggressive questions
"That's a fair challenge. Let me share our reasoning..."

# Summary
"To sum up, the three key takeaways are:
one, quantization can reduce model size by 4x;
two, the accuracy loss is negligible for most use cases;
and three, deployment complexity stays the same."

# Thank you
"Thank you for your time and attention.
I hope you found this useful."

# CTA (Call to Action)
"If you're interested in trying this out,
check out our GitHub repo — the link is on the last slide."

"Feel free to reach out to me on Slack or email
if you have any follow-up questions."

[Opening - 30s]
Good afternoon, everyone. I'm Youngju from the platform team.
Today, I'd like to share how we reduced our API response time
by 60%.

[Problem - 1min]
As you can see from this graph, our P95 latency was hovering
around 2 seconds last quarter. Users were complaining, and
our SLA compliance was dropping.

[Approach - 1.5min]
We took a three-pronged approach:
First, we added Redis caching for frequently accessed data.
Second, we optimized our database queries —
I'll show you the EXPLAIN output in a moment.
Third, we implemented connection pooling.

[Demo - 1.5min]
Let me show you a quick before-and-after comparison.
On the left is the old response time... and on the right,
after our changes. You can see the difference is dramatic.

[Closing - 30s]
To wrap up: with these three changes, we brought our P95
latency from 2 seconds down to 400 milliseconds.
The full write-up is on our internal wiki.
Thank you — happy to take questions.