OpenResearch

New on YouTube 🚨
*Beyond the Apps: Building iOS Experiences with Widgets, Live Activities & App Intents* 📱

Modern iOS apps don't have to stop at the app icon.

In this OpenResearch Mobile Meetup session, Ermal Bujupaj demonstrates how to build seamless experiences that surface your app exactly when users need it - using a real-world EV charging application as an example.

Topics include:
• Interactive Home Screen widgets with WidgetKit
• Live Activities & Lock Screen experiences
• Dynamic Island integration
• Actionable notifications
• App Intents for app-less interactions
• Best practices for combining these technologies in production

If you're building with SwiftUI or looking to make your iOS app more engaging beyond the app itself, this session is full of practical implementation insights.

▶️ Watch the full talk: https://youtu.be/a34OT5XH3dA

What's your favorite iOS feature for creating experiences beyond the app? Let us know in the comments.

Kafka's basics are straightforward. Its advanced capabilities unlock real power.

Patterns worth mastering:

🔄 Kafka Streams - process events in real-time
📊 Exactly-once semantics - transactions that work
🗂️ Compacted topics - latest state per key
🔗 Kafka Connect - integrate everything
📋 Schema Registry - evolve data safely

Partitioning strategy matters. Key selection determines parallelism and ordering guarantees.

Consumer group rebalancing affects availability. Understand cooperative vs eager rebalancing.

Retention policies need thought. Time-based, size-based, or compaction - each has implications.

Kafka is an event log, not just a queue. That distinction enables event sourcing, replay, and audit trails.

What advanced Kafka patterns do you use?

Python isn't just for web apps. It's become the lingua franca of data science and automation.

At OpenResearch, we use Python for:

📊 Data analysis and transformation
🤖 Machine learning pipelines
🔧 Automation and scripting
📈 BI and reporting systems
🔗 Glue code between systems

The ecosystem is unmatched. Pandas, NumPy, scikit-learn, TensorFlow - there's a library for almost everything.

Is Python the fastest language? No. Is it the most type-safe? No. But for rapid development and data work, it's hard to beat.

We often use Python alongside our core systems for data science work, reporting, and integrations. Right tool for the right job.

How does Python fit into your tech stack?

Clicking through cloud consoles doesn't scale. Terraform changes that.

Why Infrastructure as Code matters:

📋 Reproducible environments - dev matches prod
🔄 Version controlled - review changes like code
🔁 Idempotent - apply multiple times safely
📊 State tracking - know what exists
🌍 Multi-cloud - same workflow everywhere

Terraform's declarative approach: describe what you want, let it figure out how.

Modules enable reuse. Remote state enables collaboration. Plan before apply catches mistakes.

The ecosystem is mature. Providers exist for everything. Community modules accelerate common patterns.

Start small. Terraform one resource. Expand as confidence grows.

Infrastructure deserves the same rigor as application code.

How do you manage your infrastructure?

This year, our team has spoken at conferences about GitOps, connected vehicles, and cloud architecture.

Why do we invest time in speaking?

🎤 Teaching forces deeper understanding
🌐 Connecting with the broader tech community
💡 Sharing what we've learned, and learning from others
🏆 Representing the standards we hold ourselves to

But conferences are just one piece. We also believe in internal knowledge sharing, blog posts, and open source contributions.

The tech industry moves fast. Standing still means falling behind.

We encourage every engineer to find their way of giving back to the community, whether that's speaking, writing, or contributing code.

What's your favorite way to stay current in tech?

Tests aren't about coverage numbers. They're about confidence to change code.

Testing strategies that actually help:

🔬 Unit tests - fast, isolated, many of them
🔗 Integration tests - verify component interaction
🌐 E2E tests - critical paths only, expensive to maintain
📸 Snapshot tests - catch unintended changes
🔄 Contract tests - verify API compatibility

The testing pyramid matters. Too many E2E tests slow you down. Too few unit tests miss edge cases.

Test behavior, not implementation. Tests that break on refactoring are tests that slow you down.

Make tests fast. Slow tests don't get run.

Write the test first sometimes. TDD isn't dogma, but it clarifies thinking.

What's your testing strategy?

"We'll add tests later."

Famous last words. We've all said them. We've all regretted them.

Testing isn't overhead. It's how you ship with confidence and refactor without fear.

Our testing philosophy:

🏗️ Unit tests: Fast, isolated, many
🔗 Integration tests: Verify components work together
🌐 E2E tests: Catch what other tests miss
🔄 CI runs tests on every push
📊 Coverage as a guide, not a goal

The testing pyramid isn't just theory. We apply it to every project because we've seen what happens when tests are skipped.

The investment in tests pays off the moment you need to change something. And you always need to change something.

What's your team's relationship with testing?

Security isn't optional. Spring Security makes it manageable.

Core concepts to understand:

🔐 Authentication - who are you?
🎫 Authorization - what can you do?
🔒 Security filters - the processing chain
🎭 Principal and authorities - the security model
🛡️ CSRF, CORS, XSS protection built in

Spring Security is powerful but complex. The abstraction layers can be confusing at first.

Start with the defaults. Customize incrementally. Understand each change you make.

OAuth2 and JWT integration work well. Social login is straightforward. Method-level security adds fine-grained control.

Test your security configuration. Automated tests catch regressions before production.

Security is a feature, not an afterthought.

What's your authentication approach?

The first month working with a new team is the hardest. Everything takes longer. Questions pile up. Context is missing.

By month six? You're finishing each other's sentences.

This is the compound effect in software partnerships:

📈 Domain knowledge accumulates
🔧 Codebases become familiar territory
⚡ Communication gets faster
🎯 Decisions get sharper
🛡️ Problems get anticipated before they happen

The teams we've worked with for years? We know their systems, their users, their pain points. We can move fast because we've already done the learning.

There's no shortcut to this. No onboarding document replaces years of shared context.

When choosing technology partners, consider the long game. The real value often shows up in year two, three, or beyond.

How long have you worked with your current technology partners?