Ken Sipe

Cloud Architect & Tech Leader

Ken is a distributed application engineer. Ken has worked with Fortune 500 companies to small startups in the roles of developer, designer, application architect and enterprise architect. Ken's current focus is on containers, container orchestration, high scale micro-service design and continuous delivery systems.

Ken is an international speaker on the subject of software engineering speaking at conferences such as JavaOne, JavaZone, Great Indian Developer Summit (GIDS), and The Strange Loop. He is a regular speaker with NFJS where he is best known for his architecture and security hacking talks. In 2009, Ken was honored by being awarded the JavaOne Rockstar Award at JavaOne in SF, California and the JavaZone Rockstar Award at JavaZone in Oslo, Norway as the top ranked speaker.

Presentations

Architectural Principles: Building the Foundations of Design Excellence

1:30 PM MDT

In the realm of architecture, principles form the bedrock upon which innovative and enduring designs are crafted. This presentation delves into the core architectural principles that guide the creation of structures both functional and aesthetic. Exploring concepts such as balance, proportion, harmony, and sustainability, attendees will gain profound insights into the art and science of architectural design. Through real-world examples and practical applications, this session illuminates the transformative power of adhering to these principles, shaping not only buildings but entire environments. Join us as we unravel the secrets behind architectural mastery and the principles that define architectural brilliance.

Good architectural principles are fundamental guidelines or rules that inform the design and development of software systems, ensuring they are scalable, maintainable, and adaptable. Here are some key architectural principles that are generally considered valuable in software development:

  • Modularity
  • Simplicity
  • Scalability
  • Flexibility
  • Reusability
  • Maintainability
  • Performance
  • Security
  • Testability
  • Consistency
  • Interoperability
  • Evolutionary Design

Adhering to these architectural principles can lead to the development of robust, maintainable, and adaptable software systems that meet the needs of users and stakeholders effectively.

Operationalizing AI: From Prototype to Production

3:15 PM MDT

Building an AI model is the easy part—making it work reliably in production is where the real engineering begins. In this fast-paced, experience-driven session, Ken explores the architecture, patterns, and practices behind operationalizing AI at scale. Drawing from real-world lessons and enterprise implementations, Ken will demystify the complex intersection of machine learning, DevOps, and data engineering, showing how modern organizations bring AI from the lab into mission-critical systems.

Attendees will learn how to:

Design production-ready AI pipelines that are testable, observable, and maintainable

Integrate model deployment, monitoring, and feedback loops using MLOps best practices

Avoid common pitfalls in scaling, governance, and model drift management

Leverage automation to reduce friction between data science and engineering teams

Whether you’re a software architect, developer, or engineering leader, this session will give you a clear roadmap for turning AI innovation into operational excellence—with the same pragmatic, architecture-first perspective that Ken is known for.

Architecting Your AI-Powered Leadership Operating System

5:00 PM MDT

AI agents are not just tools for the IDE; they are the new operating system for high-stakes leadership. In this session, Ken Sipe moves beyond the hype of “AI-assisted coding” to demonstrate what it actually looks like to lead and scale with a personal AI agent. From executive briefings and organizational “pulse checks” to automated travel ops and stakeholder management, Ken provides a practical framework for tech leaders to reclaim 20% of their cognitive load.

Everyone talks about AI strategy for their products. Fewer leaders show what it looks like to actually lead with one.

Ken shares his real-world deployment of a personal executive agent that bridges the gap between high-level strategy and tactical execution. This isn't a session on prompt engineering—it is a masterclass in an Tech Leader Operating Model. You will see how an incrementally built system handles morning situational awareness, privacy-safe calendar synchronization, complex travel logistics, and the automation of professional brand building while you sleep.

The Four-Stage Framework for Leaders:
Build: Curating the “Executive Context” (What your agent knows about your roadmap and team).

Trust: The Autonomy Ramp (Moving from “Assistant” to “Agent”).

Delegate: Identifying high-leverage administrative and strategic hand-offs.

Compound: Building a memory system that scales your decision-making.

Live Demonstrations of Leadership Workflows:
The Executive Brief: Beyond email triage—priority surfacing across Slack, Jira, and GitHub to identify organizational bottlenecks.

Stakeholder & Speaking Pipeline: Automating CFP tracking and abstract generation for conferences, while maintaining a consistent thought-leadership presence.

Travel & Logistics Ops: Auto-detecting conference trips, fare watching, and seamless TripIt/Expensify integration for a zero-friction travel experience.

The Privacy Bridge: Managing a personal-to-work calendar sync that protects your private life while ensuring your team has accurate OOO visibility.

Secure Vault Retrieval: Sudo-style authenticated access to sensitive documents and IDs on the fly.

The Nightly Content Forge: How the agent drafts internal memos, blog posts, or project summaries while you are offline.

Strategic Governance:
We will also tackle the critical “Leader-to-Agent” trust design: how to define “Guardrails vs. Guidance,” managing sensitive corporate data, and building a context-rich memory system that makes the agent a genuine force-multiplier for your leadership style.

Outcomes:
A Leadership Mental Model: How to deploy an agent that complements your specific technical and managerial skill set.

High-ROI Automations: A curated list of “Quick Wins” for tech leaders to implement immediately.

Governance & Control: A realistic roadmap for safety, privacy, and control in autonomous systems.

From Intermittent to Continuous: Inspiration to transition from “using AI” to “operating through AI.”

Architectural Awareness: Engineering Super-skill

8:30 AM MDT

Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.

Within this session we look holistically an engineering, architecture and the software development process. Discussing:

* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs 
* Awareness of application portfolio and application categorization 
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem

The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.

Optimize Your Work and Life with Your Own AI Agent

A practical guide to deploying a personal AI that actually runs things for you

10:30 AM MDT

AI agents are not just for developers. They are personal operating systems for your professional and personal life. In this session, Ken shares what it actually looks like to live and work with a personal AI agent — from morning briefs to travel ops to speaking pipeline automation — and provides a practical framework you can start deploying the same week.

Everyone talks about AI. Fewer people show what it looks like to actually live with one.

In this session, Ken shares his real-world deployment of a personal AI agent that runs across his work, speaking career, and personal life. This is not a demo of ChatGPT prompts. This is an operating model — built incrementally over time — that handles morning briefings, calendar privacy bridges, travel logistics, speaking pipeline automation, secure vault retrieval, relationship nudges, and nightly content creation while he sleeps.

The session covers a four-stage framework: Build (what your agent knows), Trust (the autonomy ramp), Delegate (what to hand off first), and Compound (where the real leverage comes from).

Attendees will see live or recorded demonstrations of real workflows, including:

  • Morning brief: email triage, calendar alerts, priority surfacing
  • Speaking pipeline: CFP tracking, abstract generation, deck outlining
  • Travel ops: auto-detecting conference trips, fare watching, booking checklists, TripIt and Expensify forwarding
  • Personal-to-work calendar bridge: privacy-safe OOO blocking without exposing personal details
  • Secure vault: on-demand retrieval of travel IDs and sensitive data with a sudo-style auth challenge
  • Nightly content forge: agent builds artifacts while you sleep

We also cover safety and trust design — how to define what your agent can do autonomously versus what requires your approval — and how to build a context-rich memory system that makes the agent genuinely useful over time.

Outcomes:

  • A mental model for deploying your own agent at any level of technical skill
  • A starter list of high-ROI automations to implement this week
  • A realistic view of trust, safety, and control for autonomous AI systems
  • Inspiration to stop using AI occasionally and start using it continuously

Note: This talk is best when delivered with live demonstrations. Ken runs this system daily and can demo real workflows in real time. No slides required for the demo sections — the agent speaks for itself.

Books

Spring Recipes: A Problem-Solution Approach (Expert's Voice in Open Source)

by Gary Mak, Daniel Rubio, and Josh Long

With over 3 million users/developers, Spring Framework is the leading “out of the box” Java framework. Spring addresses and offers simple solutions for most aspects of your Java/Java EE application development, and guides you to use industry best practices to design and implement your applications.

The release of Spring Framework 3 has ushered in many improvements and new features. Spring Recipes: A Problem-Solution Approach, Second Edition continues upon the bestselling success of the previous edition but focuses on the latest Spring 3 features for building enterprise Java applications. This book provides elementary to advanced code recipes to account for the following, found in the new Spring 3:

  • Spring fundamentals: Spring IoC container, Spring AOP/ AspectJ, and more
  • Spring enterprise: Spring Java EE integration, Spring Integration, Spring Batch, jBPM with Spring, Spring Remoting, messaging, transactions, scaling using Terracotta and GridGrain, and more.
  • Spring web: Spring MVC, Spring Web Flow 2, Spring Roo, other dynamic scripting, integration with popular Grails Framework (and Groovy), REST/web services, and more.

This book guides you step by step through topics using complete and real-world code examples. Instead of abstract descriptions on complex concepts, you will find live examples in this book. When you start a new project, you can consider copying the code and configuration files from this book, and then modifying them for your needs. This can save you a great deal of work over creating a project from scratch!

What you’ll learn

  • How to use the IoC container and the Spring application context to best effect.
  • Spring’s AOP support, both classic and new Spring AOP, integrating Spring with AspectJ, and load-time weaving.
  • Simplifying data access with Spring (JDBC, Hibernate, and JPA) and managing transactions both programmatically and declaratively.
  • Spring’s support for remoting technologies (RMI, Hessian, Burlap, and HTTP Invoker), EJB, JMS, JMX, email, batch, scheduling, and scripting languages.
  • Integrating legacy systems with Spring, building highly concurrent, grid-ready applications using Gridgain and Terracotta Web Apps, and even creating cloud systems.
  • Building modular services using OSGi with Spring DM and Spring Dynamic Modules and SpringSource dm Server.
  • Delivering web applications with Spring Web Flow, Spring MVC, Spring Portals, Struts, JSF, DWR, the Grails framework, and more.
  • Developing web services using Spring WS and REST; contract-last with XFire, and contract–first through Spring Web Services.
  • Spring’s unit and integration testing support (on JUnit 3.8, JUnit 4, and TestNG).
  • How to secure applications using Spring Security.

Who this book is for

This book is for Java developers who would like to rapidly gain hands-on experience with Java/Java EE development using the Spring framework. If you are already a developer using Spring in your projects, you can also use this book as a reference—you’ll find the code examples very useful.

Table of Contents

  1. Introduction to Spring
  2. Advanced Spring IoC Container
  3. Spring AOP and AspectJ Support
  4. Scripting in Spring
  5. Spring Security
  6. Integrating Spring with Other Web Frameworks
  7. Spring Web Flow
  8. Spring @MVC
  9. Spring RESTSpring and Flex
  10. Grails
  11. Spring Roo
  12. Spring Testing
  13. Spring Portlet MVC Framework
  14. Data Access
  15. Transaction Management in Spring
  16. EJB, Spring Remoting, and Web Services
  17. Spring in the Enterprise
  18. Messaging
  19. Spring Integration
  20. Spring Batch
  21. Spring on the Grid
  22. jBPM and Spring
  23. OSGi and Spring