Tech League – Détails, épisodes et analyse

In this episode, Toby and Krisztian kick off an ongoing series exploring the EU cloud and software stack. Following a previous episode on EU digital sovereignty, they have set themselves a challenge: build their side projects entirely on EU-based services. This episode covers hands-on experience with Forgejo for source code management, Scaleway as a cloud provider, and Hanko for authentication. They share honest feedback on what works, what doesn't, and where the gaps are compared to the big American hyperscalers.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction and the EU sovereignty challenge

1:48 Finding EU alternatives: european-alternatives.eu

3:47 Looking for a GitHub replacement

5:50 Forgejo: the open-source Gitea fork

8:27 What works in Forgejo and what doesn't

10:46 Hosting Forgejo on Scaleway

13:48 The gap between self-hosting and a managed service

15:18 Scaleway overview: regions, services and Terraform support

20:35 Scaleway serverless functions and containers

25:02 Service-to-service authentication

28:34 Deploying Forgejo, databases and runners on Scaleway

36:04 Logging, metrics and Cockpit observability

40:27 Scaleway regions: Amsterdam, Paris, Warsaw

42:25 IAM limitations and enterprise considerations

44:14 Hanko: EU-native user authentication

48:32 Comparing EU stack total cost vs AWS plus Datadog

50:05 What's next: OVH, Hetzner, Infomaniak

Technologies Mentioned

- EU alternatives: https://european-alternatives.eu

- Codeberg: https://codeberg.org

- Forgejo: https://forgejo.org

- Scaleway: https://www.scaleway.com/en/

- OVHcloud: https://www.ovhcloud.com/en/

- UpCloud: https://upcloud.com

- Hetzner: https://www.hetzner.com

- Elastx: https://elastx.se/en

- Hanko: https://www.hanko.io

In this episode, Toby is joined by Xavier (Zavi) for a relaxed conversation about OpenClaw, an open-source project that lets you build a personalised, memory-aware AI assistant running on your own hardware. They share hands-on experiences setting it up with Telegram, Claude and local models, and discuss what makes it feel different from a standard chat interface: persistent memory in markdown files, heartbeat schedules, proactive check-ins, and a soul file that shapes personality over time. The conversation also covers security, prompt injection risks, the skill ecosystem, local model options, and the cultural questions around long-running AI companions.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:33 What is OpenClaw?

1:40 Why does it feel different from a standard AI chat?

3:51 Setting it up: first impressions

4:45 Practical use cases: standups, workshop manuals, tractor parts

7:04 How the heartbeat and memory systems work

9:15 Cron jobs, proactive tasks and the soul file

12:06 The internals: TypeScript, service daemon, CLI and web UI

14:23 Security model: token auth, Tailscale, least-privilege access

17:42 Prompt injection risks

21:30 The skill ecosystem and supply chain risks

28:25 Local model support and failover between providers

32:55 Running local models: gaming laptops, Apple Silicon, VRAM

38:35 Different bot instances developing different personalities

41:45 Long-running AI companions and what they mean for society

44:55 Manipulation risk and the corporate AI companion future

48:15 Practical advice: what to give it access to, and what not to

Technologies Mentioned

OpenClaw - https://openclaw.dev

Claude (Anthropic) - https://www.anthropic.com

Telegram - https://telegram.org

Ollama - https://ollama.ai

Tailscale - https://tailscale.com

In this episode, Toby and Krisztian take a deep dive into the world of principal engineers. Krisztian, himself a principal engineer, breaks down what the role actually involves: translating business strategy into technical direction, mentoring without micromanaging, building mental models of complex systems, and interpreting between engineering and senior leadership. They explore the difference between principal engineers and architects, the IC versus management career path, what makes a great versus a toxic principal engineer, how to interview for the role, and what aspiring engineers should focus on to get there.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

1:51 Where does principal engineer sit in the career ladder?

3:30 IC versus management track: the fork in the road

6:05 Why the industry created the IC path

7:06 What does a principal engineer actually do day to day?

8:27 Principal engineer versus architect

10:48 Leading by influence, not authority

12:59 Translating business goals into technical direction

16:20 Building a mental model of the whole system

18:20 Communication: 80% of the job

20:47 Teaching and knowledge sharing

22:01 Mentoring versus knowledge sharing

24:57 How to become a principal engineer

31:44 Red flags: arrogance and decision-making from authority

36:33 Avoiding the gatekeeper trap

39:46 The servant leader mindset

42:32 When to insert your authority: tiebreaking and escalation

45:00 Why principal engineers should not own production code

53:14 Skills to develop on the path to principal

56:25 The importance of breadth across industries

59:23 Spotting fake experience in interviews

1:02:00 How principal engineers are interviewed

1:06:39 Summary: what the role is really about

In this episode, Toby and Krisztian tackle the challenges of startup engineering, drawing on experience helping companies scale from nothing to tens of developers. They explore the two main startup archetypes: the bootstrapped zero-to-one prototype phase and the well-funded one-to-many scaling phase. Topics include picking the right tech stack, when to use vibe coding versus proper infrastructure, the danger of over-engineering early, unit economics, multi-account cloud environments, avoiding the trap of rebuilding your data centre in the cloud, and why unblocking other teams is always the highest-value activity.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:26 Setting the scene: two types of startup

2:07 Phase one: zero to one, get out the door fast

5:33 Defining MVP and avoiding scope creep

9:57 Zero to one vs one to many: different problems

13:42 Real startup examples: from vibe coding to Kubernetes

15:48 Security, compliance, ISO 27001, GDPR

17:58 Build vs buy

20:00 Practical tech stack for a solo founder MVP

22:56 Scaling with three developers and early funding

24:47 Unit economics: know your cost per user

28:04 Managing technical debt consciously

30:04 Use boring tech and popular languages

33:14 Organisational structure first, then tech

36:16 Standards, contracts and avoiding API chaos

40:41 Multi-account cloud strategy from day one

43:57 The real cost of blocking engineers

47:52 Unblocking other teams is always highest priority

50:03 Data architecture to avoid cross-domain dependencies

54:14 When to use consultants and fractional expertise

56:03 Summary and key takeaways

Technologies Mentioned

Replit - https://replit.com

Next.js - https://nextjs.org

Vercel - https://vercel.com

Supabase - https://supabase.com

GitHub Actions - https://github.com/features/actions

AWS EKS - https://aws.amazon.com/eks

Kubernetes - https://kubernetes.io

In this episode, Toby and Krisztian explore vibe coding — building software using AI tools and natural language rather than writing code directly. Krisztian shares hands-on experiments with Replit and Cursor, the hosts discuss the impressive speed of prototyping versus the frustration when things go wrong, and they dig into the hidden security risks of putting powerful development tools in the hands of non-technical users. The conversation also covers AI-assisted cyberattacks, supply chain vulnerabilities, and what the explosion of AI-generated apps means for the software industry.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:50 What is vibe coding?

1:47 Krisztian's experiment with Replit

3:54 Building a microservice diagramming tool with AI

6:55 Toby's experience with Lovable

10:09 Cursor vs Replit

14:00 Getting stuck in loops and losing flow state

23:16 The mainframe parallel: computing cycles and AI costs

28:42 Pricing and the race to the bottom

33:27 Why you still need developers in the loop

40:05 Supabase and Lovable integration, vendor lock-in

44:29 Security risks of vibe coding

47:28 AI-assisted cyberattacks and the arms race

59:05 Supply chain attacks and model poisoning

1:01:34 The explosion of AI slop

1:05:08 Prompt engineering and LLM manipulation

1:08:00 Summary and recommendations

Technologies Mentioned

Replit - https://replit.com

Cursor - https://www.cursor.com

Lovable - https://lovable.dev

Supabase - https://supabase.com

Claude (Anthropic) - https://www.anthropic.com

React - https://react.dev

TypeScript - https://www.typescriptlang.org

GitHub Copilot - https://github.com/features/copilot

OpenRouter - https://openrouter.ai

In this episode, Toby and Krisztian dig into one of software engineering's most debated topics: monoliths versus microservices. They break down what each architecture actually means, where the industry went wrong by treating microservices as a default, and when a well-structured monolith is the smarter choice. The conversation covers real-world scaling challenges, infrastructure complexity, team organisation, Kubernetes fatigue, and the hidden costs of over-engineering early-stage products.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:40 What is a monolith?

2:31 What are microservices?

3:50 The case for monoliths

7:46 Scaling problems with monoliths

8:17 Running a monolith like a microservice

14:00 The infrastructure cost of microservices

19:15 Pros and cons of microservices

22:03 Infrastructure as code and service ownership

24:00 Architectural mistakes and migration pain

28:41 Technology diversity: freedom or fragmentation?

33:25 The danger of nano-services

35:21 When should you use a monolith?

39:39 When should you use microservices?

42:44 ECS Fargate vs Kubernetes

43:01 The history of container orchestration

51:06 Is the complexity worth it?

58:13 Conclusions and takeaways

1:01:36 How to build a monolith you can grow out of

Technologies Mentioned

Docker - https://www.docker.com

Kubernetes - https://kubernetes.io

Amazon ECS - https://aws.amazon.com/ecs/

AWS Fargate - https://aws.amazon.com/fargate/

AWS Lambda - https://aws.amazon.com/lambda/

Terraform - https://www.terraform.io

Apache Mesos - https://mesos.apache.org

Google Cloud Run - https://cloud.google.com/run

Helm - https://helm.sh

In this episode, Toby and Krisztian take a deep look at DevOps and SecOps: where the ideas came from, what they were supposed to mean, how they got warped by the industry, and what good looks like in practice. They cover the waterfall origins of ops as a separate team, the shift-left movement, the build-it-you-run-it principle, why DevOps as a job title makes no sense, platform engineering, and how security is going through the same transformation. They also cover common anti-patterns, DORA metrics, how to get buy-in for a transformation, and what it looks like when it works at scale.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:28 What DevOps was actually supposed to mean

1:57 The waterfall origins: why ops and dev were separate

5:45 Full stack and the rise of the developer-operator

8:40 Why the old model produced poor software quality

11:04 The move to agile and SaaS changed everything

14:15 DevOps as a term: what went wrong

16:08 Platform engineering: the natural next step

21:00 Breaking down the dev vs ops cultural divide

25:47 Real-world example: 10x performance improvement through shared ownership

30:29 Security is going through the same transformation

32:49 Shifting security left: from IDE to CI/CD pipeline

37:02 Reachability scanning and avoiding false positives

40:25 The strangler pattern for security posture improvement

43:34 SecOps as enablers, not gatekeepers

45:34 Common DevOps anti-patterns

53:48 Four-eyes principle done right vs done as Jira ping-pong

1:00:00 DORA metrics: how to measure if your DevOps is working

1:05:39 Management buy-in: why it matters and why it's hard

1:11:43 Real transformation stories

1:20:00 Internal platforms and giving teams real autonomy

Technologies Mentioned

Kubernetes - https://kubernetes.io

AWS - https://aws.amazon.com

Grafana Cloud - https://grafana.com/products/cloud

Checkov - https://www.checkov.io

GitHub Actions - https://github.com/features/actions

In this episode, Toby and Krisztian dive into how to structure and scale engineering organisations effectively. Drawing on years of consulting experience, they cover autonomous teams, domain-driven ownership, reducing cross-team handovers, internal platform teams, Conway's Law, the dangers of gatekeeping in ops and security, why self-service tooling is non-negotiable, and what it looks like when organisations are run like a portfolio of internal startups. A practical guide for engineering leaders and anyone building out an eng org.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

1:43 When does an organisation become the bottleneck?

3:39 Starting with the problem space: divide and conquer

6:22 Autonomous teams and moving away from top-down command

8:03 How to detect misalignment: count the handovers

9:15 Conway's Law: use it intentionally

12:27 Single ownership and full accountability per domain

14:32 Internal service teams: when to spin one up

17:09 Each department as its own startup

19:57 Hero syndrome and knowing what not to build in-house

25:13 Self-service tooling: make it so good they choose it

28:33 KPIs, review cadences and cost visibility

36:24 Common anti-patterns: top-down command, founders who don't let go

41:42 Internal tooling teams as natural monopolies

45:26 The operations and security gatekeeper trap

48:20 Shifting from gatekeeper to enabler

53:02 Why developers must own production

57:34 How to set cross-divisional standards

1:07:09 Good internal platforms embed standards in golden paths

1:14:29 Entrepreneurial mindset within organisations

1:18:45 Summary and closing thoughts

Technologies Mentioned

AWS EKS - https://aws.amazon.com/eks

Apache Airflow - https://airflow.apache.org

Terraform - https://www.terraform.io

Kubernetes - https://kubernetes.io

In this episode, Toby and Krisztian dig into EU digital sovereignty: why it matters now more than ever, the legal landscape around the EU Data Act and the EU Cloud Sovereignty Framework, and the very real risk of European economies being dependent on US-controlled cloud infrastructure. They cover the contradictions between US and EU data law, the limitations of US hyperscalers setting up European entities, the current state of European cloud providers, the opportunity for EU tech to leapfrog incumbents, and what engineers can do right now to contribute to a more sovereign European digital stack.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:49 The cloud landscape: why it's all American

2:35 The conflict between US Cloud Act and EU GDPR

5:09 How the EU has responded: the Data Act explained

9:31 What the EU Cloud Sovereignty Framework actually measures

21:02 Are US hyperscaler EU entities really sovereign?

27:01 The current state of European cloud providers

30:06 The leapfrog opportunity: skipping legacy infrastructure

33:03 The geopolitical shift: trust in the US has broken

40:30 Europe's quiet power and how it fights back

44:24 What this means for the tech industry

47:13 The financial sector dependency and existential risk

51:03 What does the transition actually look like?

53:00 What engineers can do right now

Technologies Mentioned

AWS - https://aws.amazon.com

Microsoft Azure - https://azure.microsoft.com

Google Cloud - https://cloud.google.com

In this episode, Toby and Krisztian drop the technical polish and get honest about the biggest mistakes of their careers. From wiping a month of startup data with a single wrong command, to nearly electrocuting himself pulling a chassis from a live rack, to a rounding error in financial software that ended up in front of the CFO — the stories are equal parts hilarious and painful. They also cover bad search-replaces on live Cassandra clusters, taking on management too early, a wrong-direction DD command, and accidentally generating a massive AWS bill. A candid episode about how experience is often just accumulated failure.

https://techleaguepodcast.com/

LinkedIn: https://www.linkedin.com/company/techleague-podcast/

Instagram: https://www.instagram.com/techleaguepodcast/

Apple Podcasts: https://podcasts.apple.com/us/podcast/tech-league/id1852602975

Spotify: https://open.spotify.com/show/1zx8UIe2EjawuVU3I31fdP

Chapters

0:00 Introduction

0:51 The search-replace that corrupted a Cassandra cluster

2:20 Migrating a print shop to Linux in the 90s

5:45 Data centre migration disaster: wrong rack, 3am

8:27 Wiping a month of startup code with DD in the wrong direction

10:24 Tape backups and old-school data loss

13:16 Descending into a coal mine without the tools

18:07 The accidental text that went to the boss

20:33 The kill switch that locked out a paying customer

25:07 Pushed into management too early

28:35 Not surrounding yourself with business people soon enough

38:26 The AWS bill that dwarfed the customer contract value

41:08 The rounding error that ended up in front of the CFO

45:54 The ClickHouse lesson: check managed services first

48:25 Nearly electrocuted pulling a live power supply

51:30 Airport runway lighting and the buffer overflow

1:02:30 Mission command, autonomy and lessons from other industries

1:04:45 Summary: own up fast, learn, and keep doing things

Technologies Mentioned

Cassandra - https://cassandra.apache.org

AWS - https://aws.amazon.com

ClickHouse - https://clickhouse.com

Kubernetes - https://kubernetes.io