DEV Community: Tech Talk Augusta

Tech Talk Augusta — August Meetup Recap

Schuster Braun — Fri, 14 Aug 2026 16:06:21 +0000

Tech Talk Augusta — August Meetup Recap: DNS, AI, and Solving the Right Problem

Our August Tech Talk brought together three very different talks, but they shared a surprisingly common thread: understanding the problem before jumping to the solution.

Jason took us deep into DNS troubleshooting, Anish introduced Apoointly, an AI receptionist designed for healthcare practices, and Chris challenged us to reconsider one of our favorite instincts as technologists: writing code.

Jason: Troubleshooting DNS

DNS is one of those technologies that most developers interact with constantly without necessarily thinking much about how it works—until something breaks.

Jason's talk was a practical tour through diagnosing DNS problems and, more importantly, figuring out whether a problem is actually DNS in the first place.

He started with the fundamentals: recursive resolvers, authoritative servers, TTLs, and common record types. We also covered some of the less obvious roles of DNS records. For example, TXT records are heavily used for security, authentication, and proving ownership, while SOA records describe important information about a DNS zone.

Is it actually DNS?

One of the most useful troubleshooting principles was deceptively simple:

Before troubleshooting DNS, make sure the problem is actually DNS.

If a domain resolves correctly but the server isn't responding, the problem may be the IP address, networking, or the service itself.

Jason walked through a number of tools that can help answer that question:

dig — the detailed, powerful option for understanding exactly what DNS is doing.
host — a great quick one-liner.
nslookup — widely available and useful when you need something that's everywhere.
resolvectl — particularly useful for understanding the resolver configuration on Linux systems using systemd.
Resolve-DnsName — the PowerShell equivalent on Windows.

And then there was one of the more memorable quotes of the night:

“dig uses a plus sign for arguments. Don't ask me why I didn't write it.”

Learning to read `dig`

A dig response can look intimidating, but Jason broke down the pieces that actually matter.

The status tells you whether the query succeeded. The flags tell you what happened along the way:

aa — authoritative answer
rd — recursion desired
ra — recursion available
ad — DNSSEC validated

We also covered several important response codes:

NXDOMAIN — the domain does not exist.
SERVFAIL — the server couldn't successfully answer the query.
REFUSED — the server deliberately refused to answer.

Options such as +short, +trace, and +norecurse can turn dig into a much more targeted troubleshooting tool. dig -x is useful for reverse lookups.

DNS has a lot of caches

Another important lesson was that DNS propagation is complicated because there isn't necessarily one cache.

Depending on the environment, caching can occur in the browser, operating system, local resolver, and upstream recursive resolver. Not every machine has every layer, either.

And there's an important limitation:

You can only clear caches that you control.

That is one reason DNS migrations can be frustrating. You can change the authoritative record immediately, but somebody else's resolver may still have the old answer cached.

Which leads to an excellent operational rule:

Don't shut down the old website until the DNS team has confirmed that the record has changed.

Jason also covered search domains, trailing dots, hosts files, split-horizon DNS, DNS-over-HTTPS, captive portals, and the difference between UDP/53 and TCP/53.

Real-world troubleshooting

The talk became especially useful when Jason walked through realistic failure scenarios.

For example:

“The internet is down for me.”

Ping works.
dig times out.
The configured resolver points at the router.
A direct query to another resolver works immediately.

That points toward a local resolver problem rather than an internet outage.

Or consider an email bounce where the website still works. The bounce might specifically identify an MX record problem. From there, you can use dig to determine whether an MX record exists and whether its target resolves.

We also got a reminder of an important DNS rule:

An MX record must point to a hostname—not an IP address and not a CNAME.

The organizational side of DNS

Perhaps the biggest source of DNS confusion isn't technical at all.

When you own a domain, there may be three completely different companies involved:

Your registrar
Your DNS host
Your web or mail host

Understanding who controls what means following the delegation rather than assuming that the company you bought the domain from controls everything.

This becomes particularly important during migrations.

Jason's migration advice included:

Lower TTLs before the migration.
Recreate every record at the new provider.
Be careful with CNAMEs at the domain apex.
Verify delegation.
Don't assume that querying the new DNS server directly proves that the migration is working.

If the new server gives the correct answer but customers don't see it, the problem may be delegation rather than the zone itself.

And, appropriately, Jason ended with a haiku. We unfortunately weren't fast enough to capture it.

Anish: Apoointly — Applying AI to Healthcare

Anish shifted the conversation from infrastructure to an emerging application of AI: the AI receptionist.

The problem Apoointly is targeting is straightforward. Healthcare practices are struggling with an increasingly demanding communication and scheduling workload.

Patients may encounter:

Missed calls
Long response times
No-shows
Language barriers
Difficult scheduling processes
Overwhelmed staff
Increasing staffing costs

The result is a frustrating experience for both patients and healthcare providers.

Anish described a survey suggesting that scheduling can consume a significant portion of staff time—leaving people spending much of their day on the phone rather than on other valuable work.

An AI receptionist

Apoointly is positioned as a HIPAA-aligned AI receptionist designed to operate around the clock.

The system focuses on four major areas:

Call management
Scheduling and intake
Follow-up
Insights

The goal isn't simply to have an AI answer the phone. It's to have the system actually complete useful work.

A typical flow looks something like:

Patient call → AI understands request → Action completed → EMR updated

That could include answering questions with appropriate clinical information, handling prescription refill requests, collecting intake information, verifying patient identity, and scheduling appointments.

The key piece is integration with the practice's existing EMR rather than creating another disconnected system for staff to manage.

It was a good example of an AI application where the value isn't necessarily the model itself. The value comes from connecting the model to an existing workflow and allowing it to take meaningful action.

Chris: Not Every Problem Needs Code

Chris brought us back to a lesson that is easy for technologists to forget:

Sometimes the best technical solution is not to build anything.

With a background spanning product management and engineering, Chris talked about the difficulty of solving problems when the initial request is ambiguous.

One of the biggest challenges is context.

When someone brings you a problem, it's tempting to immediately jump into solution mode. But doing that can mean solving the wrong problem extremely efficiently.

Chris described his role somewhat like “urgent care for manufacturing”—coming into situations where something isn't working and figuring out what actually needs to happen.

Start with the business case

One of the strongest themes was repeatedly asking:

What's the business case?

Before building something, understand why it matters, who needs to be involved, what needs to happen, and when it actually matters.

Chris emphasized mapping the process and making sure you're touching the relevant value streams.

Then start with the simplest possible solution and iterate.

His decision hierarchy was particularly memorable:

Rule → Process → Low-code → Custom code

In other words, don't reach for custom software until you've established that a rule, process change, or low-code solution won't solve the problem.

What do you need from me?

Another useful communication technique was simply asking:

“What do you need from me?”

That question can turn an ambiguous conversation into an actionable one.

Instead of assuming what the other person wants, identify the actual decision, resource, information, or action needed.

Chris also discussed triage: choosing the most effective solution rather than automatically choosing the most sophisticated one.

When speed works against clarity

Agile environments create another challenge. Sometimes stakeholders want something immediately, while the people doing the work don't yet have enough clarity to know exactly what should be built.

Chris suggested that when we choose speed over clarity, we should at least make the assumptions explicit.

That means paying attention to:

Risks
Assumptions
Issues
Dependencies
Resources
Stakeholders
Quality control

We also touched on tools and techniques such as RAID logs and Ishikawa diagrams for understanding the causes and dependencies behind problems.

Three Talks, One Theme

At first glance, DNS troubleshooting, an AI medical receptionist, and project management don't have much in common.

But they all pointed toward the same engineering lesson:

Don't jump to the implementation before understanding the system.

Jason showed this through DNS troubleshooting. Before changing records, determine what is actually failing and understand which layer is responsible.

Anish showed it through AI. The interesting part isn't simply putting an LLM on the phone; it's integrating AI into an existing workflow so that a patient's request can actually result in a completed action.

Chris made the principle explicit: before writing code, understand the business case, map the process, and choose the simplest solution that creates value.

Whether you're debugging a domain, building an AI product, or responding to a request from a stakeholder, the same question keeps coming back:

What problem are we actually trying to solve?

That's a pretty good lesson to take away from this month's Tech Talk.

Three Visions of Innovation: Highlights from Tech Talk Augusta's June Meetup

Schuster Braun — Thu, 11 Jun 2026 15:38:36 +0000

Tech Talk Augusta brought together three fascinating perspectives on how technology is pushing the boundaries of what's possible. From space-based radar to animatronic flowers, here's what we learned.

Seeing Through the Clouds: Kyle McCloud on Commercial Synthetic Aperture Radar

Kyle from Umbra Space opened the evening with a compelling look at how commercial satellite radar is revolutionizing Earth observation. Synthetic Aperture Radar (SAR) technology, originally developed in the 1930s and 40s, has only recently become accessible to commercial operators—and Umbra is leading the charge.

The key advantage of SAR over traditional optical imaging is simple but powerful: it works through clouds and at night. In a world where 70% of Earth is covered by clouds or darkness at any given moment, this capability opens entirely new possibilities for monitoring our planet.

Umbra's current systems can resolve objects the size of a laptop from space, with their parabolic dish technology achieving 25-centimeter resolution. To demonstrate the scale, Kyle noted that they can cover the entire Savannah River in just 7-8 shots. The company recently released 4,000 open-source images, with 16,000 more coming soon.

The practical applications are already emerging. Commercial customers are using SAR imagery to monitor port facilities for stock market implications. Infrastructure monitoring, disaster response, maritime domain awareness, and defense and intelligence applications all benefit from this persistent, all-weather view of Earth. Umbra, headquartered in Santa Barbara with an office in DC, is also planning a hackathon to engage the local tech community around these capabilities.

Where Art Meets Science: Genevieve Lucas on Creative Experimentation

Genevieve Lucas challenged the notion that science and art are separate domains. With a bachelor's degree in computer science and a master's in progress, she's living at the intersection of both worlds as an artist in residence at Westobou, hosted by Gertrude Herbert.

Her current project transforms a local passion fruit plant into a series of animatronic sculptures—flowers that look around and blink, powered by embedded microcontrollers and mechanical precision. The technical journey reveals the hybrid nature of modern creative work:

Hardware & Modeling: Genevieve selected a XIAO ESP32 C3 microcontroller to drive her animatronics. For 3D modeling, she leveraged Autodesk 360, drawing inspiration from the puppeteer industry and open-source animatronics projects. The tight constraints of a small print bed made parallel project management challenging, but Bamboo printing got the job done.

Materials & Fabrication: Working with resin introduced unexpected challenges—managing air bubbles and paint adhesion required experimentation. The real breakthrough came from collaborating with the local maker community: she heat-sealed polyester fabric using the laser cutter at GCC's garage, then hand-airbrushed the petals.

Genevieve sees her work as part of a broader movement where artists are increasingly embracing scientific and technical tools. She highlighted emerging techniques like cellulose printing (imaging vegetables), 3D-printed textiles, and SCOBI leather as examples of this convergence. The result is art that's simultaneously aesthetically compelling and technically sophisticated.

Making Metal Printing Accessible: Shawn Matt and Trusted Metal

Shawn Matt wrapped up the evening discussing Trusted Metal, an additive manufacturing startup founded in 2023 that's tackling one of modern manufacturing's most complex challenges: making metal 3D printing accessible and reliable.

The challenge is significant. Traditional metal printing uses laser powder bed fusion (LPBF)—a process comparable to CNC forging that's expensive, difficult, and opaque. The company's approach centers on a simple framework: Process > Structure > Properties > Performance = Characterization. They're studying every variable, from how cookies bake to how metal behaves before and after heat treatment.

Equipment & Capabilities: Trusted Metal operates two laser powder bed machines that spread metal powder in fine layers, selectively melt it, and weld it into a solid structure. Beyond the printers, they've invested in the characterization infrastructure: optical and electron microscopes, hardness testers, 3D scanners, and vision measurement systems.

The core problem they're solving is vendor lock-in. Unlike CNC machining, which uses the universal G-Code standard, there's no equivalent in laser powder bed fusion. Each of the four major machine manufacturers has its own black box of parameters and workflows, leading to four different potential defect patterns. Machines have different quirks—some slow down at different speeds when making certain geometries. This fragmentation means companies are locked into specific vendors and their proprietary processes.

Trusted Metal's Solution: The company is building an open standard for metal additive manufacturing: a common build file format, common machine quality metrics, and a digital execution log that works across platforms. This democratization of metal printing is the foundation of their business model.

The presentation included striking electron microscope images showing the intricate detail of their work—a visual reminder that innovation often happens at scales invisible to the naked eye.

What's Next?

Both Umbra and Trusted Metal are actively hiring and looking to expand their local presence. The June meetup reinforced what makes Tech Talk Augusta special: access to founders and builders working on cutting-edge problems, from orbital imaging to laboratory characterization.

If you missed this month's talks, mark your calendar for the next meetup—you never know what technical frontier you'll encounter.

Exploring Numbers in Programming

Sarah Matta — Tue, 01 Apr 2025 16:18:32 +0000

Hi! I’m Sarah.

I am a self-taught programmer with a passion for where math meets programming.

This blog post represents a talk I gave at the inaugural Tech Talk Augusta.

As an introduction to my talks, I like to read the intro to Neil deGrasse Tyson’s Starry Messenger because it is applicable as well as impactful to STEM and it really sets the mood to consume and digest STEM considerations that you're about to hear (or read, in this instance). You can read it here: Starry Messenger

What is STEM? (o゜▽゜)o☆

Science, Technology, Engineering, and Mathematics. STEM builds the communities and realities that we live in. It both reflects on the past and propels us forward.

Today, let's focus on the M in STEM - Mathematics!

You Know More Math Than You Think ╰(°▽°)╯

I have always loved math, but I never progressed as far as I would have liked (and still would like to). I’ve heard many programmers say similar things. People often claim they “don’t know math.”

If you just thought to yourself:

(>﹏<)
“Yep, that’s me”

today I’m going to try to convince you that you know more than you realize.

Number Sense ♪(^∇^*)

What is Number Sense? ヾ(＠⌒ー⌒＠)ノ

I believe I have “strong number sense.” Number sense is the intuitive understanding of numbers and their relationships. It starts with grasping concepts like:

Quantities
More & less
Bigger & smaller

To understand these concepts is to understand math logic. Understanding math logic is comparable to understanding programming logic.

Math is Logic (～￣▽￣)～

How many of you know what this symbol is?

\sum

How many of you understand it?

i = 1 \sum n i^{2}

This is Sigma notation, also known as summation. It represents:

Performing an operation (right)
Starting from a defined lower bound (bottom)
Going up to a defined upper bound (top)
Incrementing at each step
Adding each result to an overall sum

How many of you know what this is?

for (let i = start; i <= end; i++) {
    sum += operation(i);
}

Yes! It’s a for loop.

Guess what? They’re the same! Sigma is a For Loop!

i = 1 \sum 4 i^{2}

i = 1 \sum 4 i^{2} = 1^{2} + 2^{2} + 3^{2} + 4^{2} = 30

for (let i = 1; i <= 4; ++i){
    sum += i*i;
}

Now, how many of you understand Sigma notation?

The Power of Number Sense in Programming (⓿_⓿)

Problem-Solving Foundation ( *︾▽︾)

Good number sense is foundational to problem-solving. And how many of us would call programming problem-solving? 🙋‍♂️

Math teaches logical reasoning and problem-solving skills that are essential in programming. It helps in breaking down complex problems into smaller, manageable parts just like writing a program or debugging code.

A friend once said:

“My high school geometry class is what helped me start to excel at programming. My teacher emphasized proof-based geometry, and it really helped me figure out how to break big problems down into smaller ones.”

Math is Logic, Programming is Logic (〃￣︶￣)人(￣︶￣〃)

This talk is focused on numbers specifically, so let’s adventure beyond bits and bytes and explore The Numeric Foundation of Programming.

Precision vs. Accuracy: A Computational Perspective

If precision vs accuracy sounds familiar to you, you have probably taken a physics class! 😆

In programming, they have distinct meanings and can have profound implications.

Precision refers to the level of detail in a measurement or calculation. Example: the number of decimal places a computation can represent.
Accuracy refers to how close a result is to the actual, true value. It’s about correctness, not just detail.

Concept	Definition	Example
Precision	Level of detail in a result	3.1415926535 (high precision, may not be accurate)
Accuracy	Closeness to the true value	3.14 (lower precision, but accurate)

Speed vs. Correctness

Speed depends on numeric type and computation method.
Context determines the right approach.

So what does precision vs. accuracy mean in programming?

Binary vs. Decimal: The Foundations of Numeric Representation ◑﹏◐

Decimal vs. Binary in Csharp

// Decimal vs Binary floating-point comparison

double binaryResult = 0.1 + 0.2;  // 0.30000000000000004 - fast

decimal decimalResult = 0.1m + 0.2m;  // Exactly 0.3 - slow

double binaryResult = 0.1 + 0.2; represents precision because it provides many decimal places but isn't exactly accurate. It’s faster but has a small error.
decimal decimalResult = 0.1m + 0.2m; represents accuracy because it gives exactly 0.3. It’s slower, but mathematically correct.

Binary Numerical Systems (Base-2)

Binary numbers are the native language of computers, representing data using only two states: 0 and 1. This fundamental representation stems from electronic circuitry's on/off nature.

Decimal Numerical Systems (Base-10)

Decimal numbers represent our natural human counting system, using ten distinct digits (0-9).

Performance Considerations

Binary is the most efficient for computer processing.
Decimal calculations are precise but the slowest for computer processing.
Decimal also requires conversion for computer storage.

Common Use Cases:

Type	Used For
Binary	Performance-critical computations, game development, memory-constrained environments
Decimal	Financial calculations, scientific measurements

Conclusion []~(￣▽￣)~*

Math is deeply embedded in programming. Understanding number sense, precision vs. accuracy, and binary vs. decimal can help programmers write more efficient and effective code.

So the next time you think, “I don’t know math”, remember - you already use it every day in programming!