Last week, I stepped away from Slack messages and Google Meet to hop on a plane and attend ViVE in Los Angeles. Next week, I’m headed to Las Vegas for HIMSS26, which will be my first time attending and, from the looks of it, it’s massive!!!

There’s something reinvigorating about stepping away from the usual day-to-day and joining rooms full of people who care deeply about what technology can actually do.

Conferences like these introduce us to new ideas, new tools, and new ways organizations are integrating emerging technologies into their platforms.

I enjoy the talks, but if I’m being honest, the most valuable moments typically happen between the sessions. Hallway conversations and one-on-one exchanges often reveal more than the events on the official agenda.

At ViVE, there were a few themes that surfaced again and again.

AI is no longer novel and experimental.

AI was everywhere at ViVE, which probably isn’t surprising. What did surprise me is how the conversation has shifted. The focus is no longer on AI’s potential. We’ve had time to explore and now it’s time to actually deploy AI in real clinical workflows.

At HIMSS, I’m interested to hear more from organizations that are using AI to actively improve healthcare worker efficiency and patient experience. I’m hoping to better understand how companies are currently using AI and what these use cases signal about where software is headed, both within the healthtech space and beyond.

Data is still at the center of everything.

Another theme that surfaced repeatedly at ViVE was data, and I’m looking forward to hearing more about these roadblocks and potential solutions at HIMSS. The overarching challenge is making healthcare data usable.

Healthcare organizations collect and store massive datasets. But when it comes to accessing, structuring, and sharing that information with other systems, there’s work to be done. Interoperability remains one of the biggest barriers to progress.

For software teams, that means the real work happens in the backend. We need to build systems that can reliably move data, maintain integrity, and support meaningful analysis.

I’m excited to learn more about how teams are approaching data architecture, interoperability, and analytics. The lessons we learn here extend far beyond healthcare. Every industry we work with, from public health to nonprofits to education, depends on clean, usable data.

Trust and security are core infrastructure.

One of the most important threads across all of these conversations was the growing emphasis on trust.

As AI tools become more powerful, organizations are paying closer attention to explainability and governance. Healthcare platforms need to be resilient and transparent, especially when they influence clinical decision-making.

Security is also central to these discussions. As technology evolves, so do the threats surrounding it. Building secure systems from the start is a requirement.

Coffee, conversation, and connections.

Above all else, I’m a people person!!! I truly enjoy the one-on-one conversations where we compare notes and talk through what’s actually working (and what’s not).

At ViVE, I learned so much from hallway chats and quick conversations. I'm excited to make more connections next week in Las Vegas.

Looking forward to HIMSS26.

I'm excited to put on my comfortable shoes again (lesson learned!), clip on my attendee badge, and rack up some serious steps at HIMSS! If ViVE is any indication, the conversation will likely continue exploring how organizations are graduating from experimentation to real-world deployment.

I’m especially curious to see how teams are approaching these challenges and developing creative solutions. And of course, I’m excited for more introductions and insightful chats.

If you’ll be at HIMSS and want to connect or grab a coffee between sessions, I’d genuinely love that! These conferences are always a whirlwind, but the real value comes from the conversations we make time for and the lasting connections we build with one another.

Can’t wait to see you there!

Well-designed public health technology can help your program scale and increase your mission's impact.

How can program management software help public health teams scale effectively?

Public health leaders rely on technology to provide services, respond to community needs, and demonstrate results to funders. Generic tools and scattered systems hinder growth. When data lives in disjointed spreadsheets, apps, and inboxes, it can slow down your whole program.

Well-built program management software can make all the difference. Rather than adapting workflows to fit an existing solution, custom software is built to support your data, your partners, and your processes.

As your program grows, the need for clarity grows with it. Your team needs reliable data to understand what’s working, where resources go, and how outcomes shift.

At SmartLogic, we approach custom software development with a focus on shared visibility: real-time insights, transparent reporting, and a system built to scale with your mission.

How does custom software improve reporting, collaboration, and outcomes in public health?

Off-the-shelf reporting tools are convenient, but they can only take your program so far. Custom program management software is built to serve the specific needs of your organization. The right platform can make growth feel effortless, helping your team to clarify, coordinate, and scale.

A unified system helps your organization:

• Track who your program reaches in real time
• Keep your operation, and your critical data, organized
• Deliver accurate, transparent reporting to funders
• Shape policy decisions backed by reliable data

If you want your organization to run reliably, custom software isn’t a luxury. It’s a core operational asset that lets your team focus on shared goals and community outcomes rather than getting stuck in spreadsheets.

How can real-time data improve public health program coordination and delivery?

You don’t need more tools. You need one that works.

Your team is already doing the hard work. The barrier isn’t effort; it’s the drag created by fragmented systems and manual reporting. When data lives in different spreadsheets and apps, even routine tasks take longer than they should.

We saw this firsthand when SmartLogic partnered with World Central Kitchen (WCK). Their food relief teams were moving quickly, but inefficient systems were holding them back. Without unified software, each city had developed their own tracking method. The result: gaps, delays, and coordination challenges.

The SmartLogic dev team built WCK Direct in six weeks. The platform connected restaurants, staff, and volunteers in real time. The impact was immediate: more than one million meals provided across seven U.S. cities in its first year, and rapid expansion into new markets.

With custom-built program management software, WCK didn’t just gain speed, they gained clarity. The new platform offered real-time insights into meals served, partner spending, and city-level operations. Reporting became efficient, coordination improved, and funders gained confidence in the results.

How does custom software strengthen collaboration between funders, staff, and policymakers?

Public health work requires collaboration between program teams, funders, policymakers, and community partners. But, that collaborative effort can break down when everyone is looking at different systems and spreadsheets.

Program staff may track outcomes one way. Funders may receive incomplete or delayed reports. Policymakers may lack clear visibility into real-time program data.

A custom-built public health technology platform can close these gaps and give all stakeholders access to the same reliable information. With the right software, communication is streamlined and results are visible and verifiable.

Our work with Challenge.gov exemplifies what that looks like on a national scale. SmartLogic helped the U.S. government replace a manual, email-driven process with an open-source platform that empowers agencies to run innovation challenges. The system now supports over 800 challenges and one million participants nationwide.

With a streamlined platform, agencies can manage programs independently, and the public can contribute solutions to complex issues in health, climate, accessibility, and more.

This is the value of scalable custom software: clear coordination, smoother operations, and results that stand up to scrutiny.

How can accessible UX design make public health technology more inclusive?

Data only matters when people can use it, and public health work relies on equitable access to information.

Efficient program management software lets every stakeholder engage without needing technical expertise. Program staff should be able to generate insights without waiting for analysts. Funders should be able to check progress without waiting for quarterly reports. Policymakers should see the bigger picture without digging through files.

Accessible UX design makes this possible.

Effective public health technology includes:

• Accessible formats that make complex data easy to understand
• Role-based dashboards that provide stakeholders with relevant information
• Clear guided workflows so users know where to go and what to do next

At Smartlogic, accessible UX design is built into our software development process. Our CARE approach supports clear communication, improves reach, and keeps users engaged.

Whether your platform serves a local program or a national initiative, our goal is the same: making technology work for everyone and helping missions grow stronger.

How can purpose-built public health software strengthen your program’s impact?

Public health teams know what their communities need. The biggest barriers to progress are outdated software, scattered data, and time-consuming reporting processes.

Purpose-built custom software changes that.

The right technology gives your team:

• Clear visibility into daily operations and outcomes
• Stronger coordination between partners and programs
• Verifiable results that build funder confidence
• A future-ready platform that will scale with your mission

SmartLogic works with public health organizations to build custom platforms that accommodate growing programs and make results easy to see. Our development approach keeps your team focused on mission delivery while giving your funders and policymakers the clarity they expect.

If you want your organization to expand, improve reporting, or replace a system that no longer keeps up, we can help you build a platform to support your goals.

Ready to explore what this could look like for your team? Visit our dedicated Public Health page to learn more.

Attending EDUCAUSE 2025 was like stepping into a living laboratory of innovation, energy, and collective imagination. From the very first keynote, my eyes were opened wide. Dr. Joy Buolamini set the tone for the entire conference with a message that was equal parts unsettling and empowering.

She unraveled the uncomfortable truth about AI’s persistent shortcomings around gender and racial bias. I was shocked to learn just how inaccurate facial recognition technology can be, especially for women with darker skin. She spoke about some of the injustices that have occurred, including cases in which people were wrongly accused.

Furthermore, I was surprised to learn that airport facial recognition (you know, the one where you don’t need to show your boarding pass to go through security but simply stand and smile for the camera)  is optional. Her stories and research revealed how biased data and flawed systems can shape outcomes in ways that deeply affect real people. The conversation around ethical AI and responsible data design has never felt more urgent.

Yet she didn’t leave us in fear. She challenged us, deliberately, to question the tools we use, to remain aware, and to approach AI with both responsibility and courage. It was a call not to disengage, but to lead with intention.

Her keynote framed how I experienced the rest of the conference.

Reframing AI: Augmented, Not Artificial

One session that significantly impacted me was Vanderbilt University’s Dr. Jules White, who invited us to rethink our language around AI. Instead of Artificial Intelligence, he urged us to consider Augmented Intelligence.

His metaphor captured it perfectly: AI should be an “exoskeleton for the mind.” Not a replacement. Not a thread. An amplifier! That framing, AI as augmentation, captures the importance of embracing “human-centered AI.”

His perspective resonated deeply, especially as someone who works at the intersection of leadership, technology, and human-centered problem-solving. The idea that AI’s highest value is in elevating uniquely human attributes made me deeply reflect on what mine are… and how I can leverage AI tools differently. A true “hmm…” reflection moment.

Agile Thinking, Everywhere!

Another unexpected delight was seeing how agile software development principles are making their way into higher education leadership, far beyond traditional IT contexts. Institutions like Utah Valley University and accreditation entities like the Higher Learning Commission shared how they are using agile frameworks to reshape strategic planning, modernize change management, and manage cross-functional and cross-university requests.

It was refreshing to see agile not as a rigid process, but as a flexible, human-centered mindset applied in creative, nontraditional ways. It reminded me just how universally relevant these principles are when teams need to adapt, collaborate, and move forward with clarity. Agile methodologies aren’t just for software development, they’re frameworks for adaptive leadership.

The Buzz of Possibility

There was a palpable hum throughout the conference, a kind of intellectual buzz that reminded me of a beehive in motion. Everywhere I turned, someone was experimenting with new ways to leverage AI tools to expand student access, streamline educational delivery, and eliminate barriers that have persisted for years.

It felt like sitting in the front row of an improv show where we were all co-creators, testing ideas in real time, sharing what worked, and imagining what could be built next. The excitement was infectious!

Closing Reflections: Keeping Hope Alive

As powerful as the opening keynote was, I would be remiss not to acknowledge the impact of the closing keynote by Dr. Freeman A. Hrabowski, III, former president of UMBC and an admired leader in Maryland.

His words were a grounding force. He reminded us that:

“The way we think of ourselves… the language we use… the way we interact with each other… the values we hold… we become like the things we love.”

He spoke about dreams, values, and the responsibility each of us has to shape a society rooted in hope. With the world changing as rapidly as it is, his emphasis on focusing on what we can control, our minds, actions, and attitudes, felt both practical and profound. I left his keynote feeling energized, inspired, and aware of my own role in fostering thoughtful leadership in an AI-driven world.

Walking Away (or flying home…)

EDUCAUSE 2025 wasn’t just a conference, it was a collective awakening. It reminded me that, at its best, technology is intertwined with humanity. It requires curiosity, humility, courage, and hope. Conferences like EDUCAUSE reaffirm why accessibility, inclusion, and iterative innovation belong at the heart of AI adoption.

I came home with new ideas, deeper convictions, and a renewed commitment to leading with intention as AI tools continue to evolve. And above all, I left believing more strongly than ever that the future of education and the future of technology are things we shape together.

How AI tools can solve the eternal problem of missing documentation and tribal knowledge

There's a universal truth in software development: the more complex your application becomes, the more likely it is that critical knowledge exists only in someone's head. New developers join the team, ask perfectly reasonable questions about how things work, and get met with uncomfortable silences.

If this scenario sounds familiar, you're not alone. Documentation is one of those things every development team knows they should have, but it's hard to justify spending time and budget on explaining existing features when that same effort could go toward building new ones. The result? Knowledge trapped in individual heads, new team members struggling to understand business logic, and that one person who becomes the unofficial keeper of the knowledge.

Here's how I used AI to tackle this problem head-on, and what it means for teams drowning in undocumented complexity.

The Documentation Dilemma

Every development team faces the same challenge: the people who built the system are busy building the next feature, and documenting what already works feels like time that could be spent on "real" work. But this creates a vicious cycle:

• New developers struggle to understand existing features and business logic
• Knowledge becomes siloed with specific team members
• Maintenance gets risky because nobody fully understands how things connect
• Onboarding takes forever as new hires hunt down the right person to explain each system

The traditional approach to solving this is to schedule "documentation sprints" or assign junior developers to write docs. But these efforts often produce documentation that's either too shallow to be useful or becomes outdated the moment the code changes.

AI-Powered Documentation: A Different Approach

Instead of trying to find time to write documentation, I decided to see if AI could analyze an existing codebase and generate the documentation we actually needed. The results were surprising.

Using AI tools with codebase access, I focused on three key areas that consistently cause onboarding headaches:

1. Business Logic Extraction

Complex applications accumulate business rules that get buried in conditionals, callbacks, and service objects. New developers can see what the code does, but understanding why it does it requires someone to explain the business context.

AI identified these patterns and explained the reasoning behind them. Instead of just documenting that a certain condition exists, it could explain scenarios like "When a user completes a specific action during a particular time window, the system automatically triggers additional processes that might not be obvious from the code alone."

2. Data Relationship Mapping

Modern applications have complex data models with relationships that aren't always obvious from the schema or ERD alone. AI helped create clear explanations of how different models interact, what the relationships mean in business terms, and when certain associations get created or updated.

This turned out to be invaluable for helping developers understand not just the technical structure, but the real-world workflows the data represents.

3. Feature Workflow Documentation

Perhaps most importantly, AI could trace through entire user workflows and document how different parts of the system work together to accomplish business goals. This kind of end-to-end documentation is exactly what new developers need but rarely gets written because it requires understanding both the technical implementation and the business requirements.

The Practical Implementation

The process was straightforward but thorough:

Comprehensive Model Documentation: AI analyzed all major models, their relationships, and their role in the business domain. This created a foundation for understanding how the application represents real-world concepts.

Feature-by-Feature Analysis: Breaking down complex features into digestible explanations of what they do, how they work, and why they exist. This included everything from goal management workflows to administrative customization options.

Permission and Access Control Mapping: One of the most complex aspects of any application - who can do what, when, and under what circumstances. AI helped create clear documentation of the permission system that both developers and stakeholders could understand.

Dead Code Identification: As a bonus, the AI analysis identified unused CSS rules, deprecated components, and placeholder tests that could be safely removed, cleaning up technical debt in the process.

What Makes AI Documentation Different

Traditional documentation often feels like an afterthought because it is one. AI-generated documentation feels different because:

It's comprehensive by default: AI doesn't get tired or skip the "obvious" parts that often trip up new developers.

It connects the dots: AI can trace relationships between distant parts of the codebase and explain how they work together.

It explains the why, not just the what: By analyzing code patterns and business logic, AI can infer and document the reasoning behind implementation decisions.

It stays current: Because it's generated from the actual codebase, it reflects the current state of the system rather than what someone remembered to update six months ago.

The Team Impact

The results are immediate and noticeable:

Faster onboarding: New developers can understand complex workflows without hunting down the right person to explain them.

Reduced knowledge silos: Critical business logic was documented outside of individual team members' heads.

Better technical discussions: Having clear documentation of existing systems made architectural discussions more productive.

Improved maintenance confidence: Developers felt more comfortable modifying code when they understood the business context behind it.

Beyond Documentation: AI as a Development Partner

This project reinforced something I'd learned from previous AI collaborations: the technology is most powerful when it amplifies human expertise rather than replacing it. AI can analyze patterns and generate comprehensive documentation, but it still requires human judgment to validate the output and ensure it captures the nuances that matter.

The real value comes from using AI to handle the systematic, thorough work that humans often skip due to time constraints, freeing up developers to focus on the strategic thinking and creative problem-solving that we do best.

What This Means for Development Teams

For teams struggling with undocumented systems, AI offers a practical solution to a persistent problem. Instead of waiting for the "right time" to document everything, you can generate comprehensive documentation from your existing codebase and iterate from there.

This is particularly valuable for:

Legacy systems where original developers have moved on
Complex business domains with intricate rules and workflows
Growing teams that need to onboard new developers quickly
Maintenance projects where understanding existing code is critical

The Consulting Advantage

At SmartLogic, this approach changes how we deliver value to clients with complex, undocumented systems. We can quickly understand and document existing codebases, reducing the risk and timeline of enhancement projects.

For our clients, this means:

Faster project starts: We can understand existing systems more quickly, reducing discovery time
Better risk management: Comprehensive documentation reduces the chance of unexpected complications
Knowledge transfer: Clients end up with documentation they can use for future development
Team continuity: Reduced dependency on specific individuals who "know how everything works"

The Bigger Picture

Documentation has always been a necessary but neglected part of software development. AI doesn't just make it easier to create documentation - it makes it possible to maintain the kind of comprehensive, current documentation that teams need but rarely have time to create.

This represents a shift in how we think about knowledge management in software projects. Instead of documentation being something we do after building features, it becomes something that happens alongside development, providing immediate value to the team.

Looking Forward

The patterns I learned apply to any complex codebase that needs better documentation:

• Automated business logic extraction for complex domains
• Real-time documentation updates as code changes
• Onboarding documentation tailored to specific roles
• Technical debt identification and cleanup guidance

As AI tools become more sophisticated, the barrier to maintaining excellent documentation continues to drop. Teams that adopt these approaches early will have a significant advantage in managing complex systems and onboarding new developers.

The Bottom Line

Undocumented systems are expensive - they slow down development, increase risk, and create unnecessary dependencies on specific team members. AI provides a practical solution that can generate the comprehensive documentation your team needs without the traditional time investment.

For teams managing complex systems, this isn't just about having better docs - it's about reducing risk, improving maintainability, and enabling faster development cycles.

Struggling with an undocumented legacy system? Let's talk about how SmartLogic can help you understand and improve your existing codebase.

I don’t know how to write code, and if you showed me a terminal window I’d probably ask if I could close it. And yet, a few weeks ago, I built a no-code automation workflow that’s giving us better insight into how our projects are progressing, and I did it all without writing a single line of code.

The Problem: Time Tracking in One Place, Project Work in Another

At SmartLogic, like many teams, we track time to understand how we’re spending our effort across projects. That data lives in CSV files and Google Sheets, but the project management work itself, such as tasks, tickets, deadlines, lives in ClickUp. These two systems weren’t talking to each other.

Every week, I’d manually compare our time tracking spreadsheet against ClickUp tasks  to see if we were on track and where unplanned hours were going. It was tedious, repetitive, and error-prone.

Recently, we’ve been doing more experimentation with AI tools to support our day-to-day roles. This process led me down the automation rabbit hole.

Step One: Finding the Right Tools (and Trusting ChatGPT)

I started researching n8n, a no-code automation platform for project management. The pitch: connect your apps, automate tasks, and do it all with a drag-and-drop interface. I was intrigued, but also intimidated. The UI looked approachable, but I didn’t know where to start. That’s where ChatGPT came in.

I opened a new chat and wrote a prompt like:

“I want to set up an automation workflow in n8n and I am not a technical person and I don't know how to code. Can you help with this?”

ChatGPT walked me through the basics: how to authenticate with Google Sheets and ClickUp, how to set up nodes in n8n, and how to structure the data flow so it made sense. Every time I got stuck or confused, I’d copy-paste the error into the chat, and ChatGPT would help me troubleshoot in plain language.

Step Two: Building the Automation in n8n

Here’s what the workflow looked like in simple terms:

• Trigger: I set the automation to run manually for now, so I could test and iterate easily.
• Google Sheets Node: It pulls a list of time entries from our tracking spreadsheet — each row includes a task identifier and a time value.
• Code & HTTP Nodes:  I used a combination of code nodes to manipulate and format data, and HTTP nodes to interact directly with the ClickUp API. That allowed me to look up each task in ClickUp and send a request to update the "Time Logged" custom field for each task.
• Logging: At the end of the workflow, another Google Sheets node writes a log of which tasks were updated, when, and with how much time — just in case we need an audit trail later.

What I Learned (and Why This Matters)

It was a proud moment to run the full workflow for the first time and see it working: time data from our spreadsheet showing up in ClickUp automatically, with no manual entry.  I could spend less time doing spreadsheet gymnastics.

But here’s the thing: while AI got me most of the way there, it didn’t get me all the way.

Eventually, I hit a wall. I found myself in a frustrating loop — fix one node, and another one broke. I'd go back to ChatGPT, get another suggestion, try the fix, and something else would fail. It started to feel like playing a game of whack-a-mole. There were also sunk costs — I’d invested so much time into one thread that starting over felt painful, even when I knew it might help.

In the end, I still needed one of our developers to step in and help debug the final stretch. They quickly spotted issues I’d spent hours chasing. AI helped me in the first 80% but I needed a human who understood the context, and could see what the AI couldn’t, to get me across the finish line.

Tools like ChatGPT and n8n are empowering non-technical team members to contribute meaningfully to technical workflows, not by replacing developers, but by collaborating with them to enhance efficiency. You don’t need to be a developer; you just need to ask the right questions, act on AI guidance, and know when a human touch is needed to see around the corner.

If you’re a project manager, operations lead, or anyone who finds themselves doing the same tasks over and over, there’s a good chance automation can help. You don’t need to be a technical expert. You just need curiosity, patience, and the right support when you need it.

AI can take you far. But the finish line is still a team effort, and that’s a good thing!

SmartLogic helps teams transform ideas into dependable software. From prototypes to complex systems, we bring the expertise to make it work. Let’s talk about your next project.

A practical guide to leveraging AI for complex codebase migrations without losing your sanity

Picture this: You're staring at a Rails application that hasn't had its JavaScript touched since the Beijing Olympics. The asset pipeline is still running on Sprockets, there's jQuery scattered like confetti at a New Year's party, and somewhere in the depths of the codebase lurk custom plugins that were written by developers who are now probably running a craft brewery in Colorado.

Your client wants it modernized. Yesterday, preferably.

If you've ever inherited a legacy system, you know this feeling. It's that special combination of excitement (new project!) and dread (what fresh nightmare awaits me in this codebase?) that makes our profession so interesting.

This is the story of how I tackled one of these modernization projects using AI as my co-pilot, and what I learned about the changing nature of software development along the way.

The Reality of Legacy Rails Modernization

Let's be honest about what we're really dealing with when we talk about modernizing legacy code. It's not just updating syntax or swapping out old libraries. You're staring down technical debt, compatibility issues, and the uncomfortable reality that the people who originally wrote this code have long since moved on to other projects (or other careers).

Here's what any developer dealing with legacy systems will recognize:

Technical debt everywhere. Years of "temporary" fixes that became permanent, hardcoded logic that made sense at the time, and dependencies that are held together with the digital equivalent of duct tape and good intentions.

Integration nightmares. Legacy systems need to play nice with modern tech stacks, but APIs don't line up, data formats clash, and everything feels like a house of cards.

Data migration headaches. Converting outdated data formats while ensuring compatibility with modern systems is like renovating a house while still living in it.

The knowledge gap. The original developers are gone, documentation is sparse (if it exists at all), and you're left playing detective to figure out why certain decisions were made.

Testing anxiety. Every small change introduces the risk of breaking something elsewhere, and you might not discover it until weeks later.

Fortunately, this particular application wasn't the worst-case scenario, but it had enough of these challenges to make things interesting. It was running on Rails with a Sprockets-based asset pipeline, jQuery dependencies everywhere, React components mixed in seemingly at random, and a number of custom TinyMCE plugins that added custom editing features and interface elements.

Everything worked, but as someone new to this codebase, it was the kind of setup that makes you nervous about changing anything.

Starting with AI-Assisted Planning

Before diving into code, I did something different this time: I used AI to help create a migration strategy.

I fed my AI tool the existing architecture, explained the constraints (zero downtime, maintain all functionality, move to Rails 7.2 standards), and asked for a comprehensive migration plan. What came back wasn't just a to-do list - it was a thoughtful analysis of dependencies, potential pitfalls, and a phased approach that would minimize risk.

The AI suggested:

1. Start with asset pipeline migration (lowest risk, highest impact)
2. Convert React components to vanilla JavaScript (eliminate dependencies)
3. Modernize TinyMCE integration (highest complexity, do last)
4. Create rollback plans for each phase

This wasn't just helpful, it was eye-opening. Instead of spending hours mapping out dependencies and potential issues, I had a solid strategic foundation in minutes. The AI had considered edge cases I might have missed and suggested an order of operations that made sense from both technical and business perspectives.

Where GitHub Copilot Became My Development Partner

With the plan in place, I started the actual migration work. This is where GitHub Copilot transformed from a helpful autocomplete tool into something closer to a development partner.

Pattern Recognition That Actually Understands Context

The first breakthrough came when converting JavaScript files from Sprockets' //= require directives to ES6 modules. Instead of manually updating dozens of files, I showed Copilot the pattern I wanted:

"Convert this Sprockets JavaScript file to ES6 modules while maintaining jQuery as a global variable for backward compatibility."

Copilot didn't just change the syntax - it understood the constraint about jQuery and suggested creating a separate preload bundle that would load first and assign jQuery to the window object. This solved a problem I hadn't even fully articulated yet.

AI as a Debugging Partner

When I hit complex issues - like image paths not resolving correctly after migrating from Sprockets to Propshaft - Copilot became invaluable for debugging. It could quickly suggest what might be wrong, help me grep through files to investigate, and even explain the underlying differences between how the two systems handle asset serving.

This freed me up to focus on architectural decisions while the AI handled the investigative legwork.

Learning from the Existing Codebase

Perhaps most importantly, Copilot helped me understand patterns in the existing code. It could analyze how the custom TinyMCE plugins were structured and suggest the best way to modernize them to ES6 modules. It recognized Rails conventions and proposed solutions that fit the existing codebase's style rather than imposing arbitrary patterns.

The Real Lessons: Mastering AI-Assisted Development

Think Declaratively, Not Imperatively

I learned to describe outcomes rather than step-by-step processes. Instead of: "First update this require statement to use import syntax, then add the export at the bottom, then make sure the function is available globally, then test that inline scripts still work..."

I would say: "Convert this component to use modern ES6 modules while maintaining all existing functionality and jQuery global access."

This approach leverages AI's pattern recognition abilities instead of treating it like an advanced search-and-replace tool.

Build Context Incrementally

Working with a large Rails codebase means the AI needs to understand not just what you're changing, but why. I learned to:

• Start with architectural goals and constraints
• Show examples of the patterns I wanted to establish
• Let the AI extrapolate from those examples
• Iterate until suggestions aligned with the project's specific needs

Know When to Trust, When to Verify

Copilot excelled at repetitive conversions, syntax transformations, and following established patterns. But I learned to double-check anything involving business logic, security considerations, or complex integrations. The key insight: AI is excellent at implementation once you've made the strategic decisions.

From Coding to Conducting

This project crystallized something I'd been sensing for a while: my role as a developer is fundamentally changing.

Beyond Research and Recall

We've been living in what economists call a "knowledge economy" - where your value comes from what you know and your ability to apply that knowledge. But what happens when computers can access and synthesize knowledge faster than we can?

I’ve spent countless hours researching best practices, finding the right documentation, and combining information from various sources. AI can now do this more quickly and often more thoroughly than I can. That's not a threat - it's a liberation from routine cognitive tasks.

The Art of AI Delegation

Instead of being primarily a "maker" of code, I found myself becoming a "manager" of AI capabilities. I was allocating work between myself and Copilot, deciding which tasks to delegate and which required human judgment.

This shift requires developing new skills:

• Quality assessment: Knowing when AI output meets requirements
• Task decomposition: Breaking complex problems into AI-manageable pieces
• Resource allocation: Choosing the right tool (AI or human) for each job
• Strategic oversight: Maintaining architectural vision while AI handles implementation

The New Management Skills

Working effectively with AI requires many of the same skills that make good human managers:

Clear vision articulation: AI works best when you can clearly describe the desired outcome. Vague requirements produce mediocre results.

Quality standards: You need to develop a taste for what constitutes good work and be able to communicate why something doesn't meet standards.

Delegation skills: Knowing which tasks are appropriate for AI assistance and which require human insight.

Integration thinking: Understanding how AI-generated work fits into larger systems and business objectives.

What This Means for Consulting Teams

At SmartLogic, this evolution changes how we deliver value to clients. AI-assisted development isn't just about writing code faster - it's about taking on more ambitious projects with the same resources while maintaining quality.

For this client, the benefits were clear:

• Faster delivery without compromising thoroughness
• Better documentation (AI helped generate comprehensive migration guides)
• Reduced risk through systematic analysis and planning
• Future-proofing with modern tooling and practices

The client got a completely modernized application without the typical disruption of major architectural changes.

Practical Takeaways for Development Teams

For Individual Developers

Master AI collaboration by:

• Learning to communicate outcomes clearly rather than giving step-by-step instructions
• Developing judgment about when to trust AI suggestions versus when to verify
• Building skills in quality assessment and iterative refinement
• Maintaining deep technical knowledge (you can't manage what you don't understand)

For Team Leaders

The competitive advantage goes to teams that adapt quickly to AI-augmented workflows. This means:

• Training developers in effective AI collaboration techniques
• Establishing quality standards for AI-assisted work
• Redesigning project planning to leverage AI capabilities
• Maintaining technical depth while developing coordination skills

For Business Leaders

AI tools make previously risky or expensive modernization projects more feasible. Legacy system owners can now tackle updates that were too complex or costly before, but this requires working with teams that understand how to leverage these tools effectively.

The Bigger Picture

The project revealed something important about the future of software development. We're not moving toward a world where AI replaces developers - we're moving toward one where developers become more strategic, focusing on architecture, quality, and business alignment while AI handles more of the implementation details.

This transition is happening whether we're ready or not. The teams that learn to collaborate effectively with AI will be able to take on larger, more complex projects. Those that don't will find themselves at a significant disadvantage.

Looking Ahead

Legacy system modernization is just the beginning. The patterns I learned apply to:

• Technical debt analysis and prioritization
• Security audit assistance for older applications
• Documentation generation from existing codebases
• Test coverage enhancement with AI-generated test cases

The technology is evolving rapidly, but the core insight remains: AI tools are most powerful when they amplify human expertise rather than replace it.

The Bottom Line

Modernizing legacy systems has always been risky and time-consuming. AI doesn't eliminate those challenges, but it changes the equation significantly. What used to require large teams and extended timelines can now be accomplished with smaller teams moving faster and with more confidence.

For our clients, this means ambitious modernization projects come at a lower cost, and necessary updates become less disruptive to business operations.

The future belongs to development teams that can effectively coordinate human and AI capabilities while maintaining the strategic thinking and domain expertise that remain uniquely human. The question isn't whether AI will change software development - it's how quickly we can adapt to lead that transformation.

Ready to modernize your legacy application? Let's talk about how SmartLogic can help you navigate the transition.

It’s never been easier to get an idea off the ground. With AI tools generating functional apps from just a prompt, founders and innovators can move from concept to clickable in a matter of hours. Whether it’s a chatbot, a custom dashboard, or a new twist on a marketplace idea: "vibe coding" has entered the chat.

While AI-generated prototypes can help you move fast, what gets you to a demo isn’t always what gets you to market. Vibe coding can lead to scaling or security issues, and growing the product from initial release to market fit might not be as easy as it seems. So how do you go from proof-of-concept to a product that lasts?

The Rise of Vibe Coding

"Vibe coding" refers to the new wave of fast, AI-assisted software prototyping. With platforms like ChatGPT, Replit, and dozens of low-friction dev tools at your fingertips, it’s now possible to:

• Spin up a working prototype in a day
• Iterate on ideas in real-time
• Test the waters before making a serious technical investment

It’s exciting. It’s empowering. And for entrepreneurs, it’s seen as a legitimate game-changer.

As a custom software agency, we aren’t dismissing this industry shift. For example, SmartLogic President Yair Flicker used Lovable AI to quickly vibe code a fully functional prototype in response to a TEDCO RFP, all in a matter of hours.

But as powerful as this approach is, vibe coding is just the beginning. Without careful review and expert guidance, these early vibe builds can lack architectural structure, proper data handling, and can easily suffer from long-term scalability issues. They’re designed for minimal investment to gain momentum and show off the tools that build them. Vibe coded software products often do not shift into maturity and long term success without expert intervention.

So, when your prototype starts getting real traction, those cracks start to show.

When the Prototype Isn’t Enough

Prototypes aren’t designed to last; they’re designed to prove a point quickly. Regardless of how they are built, any prototype is likely to face challenges as growth takes off, and most prototypes will eventually hit a ceiling. Over time and growth the shortcuts and assumptions that made the prototype fast to build start colliding with reality.

Failure points are often in the place you least expect, and can include:

• Data model limitations: Early data model decisions might not scale well to handle multi-user concurrency, migrations, or reporting.
  
  
• Scaling bottlenecks: That single-threaded API on a free tier grinds once you have more than a handful of concurrent users, and scaling up might cost you more than you expect at your platform as a service provider.
  
  
• Security gaps: Copy-pasted auth, unvalidated inputs, and wide-open CORS settings work fine in a demo, but not in production. It is easy for issues in authentication and authorization to go unnoticed during a vibe driven build.
  
  
• Integration fragility: Quick and broad API integration can create brittle dependencies that snap when you add more services, more data, or more traffic. Did the AI only select the necessary fields? Are you loading more data into memory than needed? Is the payload size twice what it should be? All fine for now, but they could be the breaking point in the future.
  
  
• Maintainability: Many developers are finding AI is really helpful for testing, but that is with a knowing eye to make sure the test is actually testing the code and will fail should the code no longer work as expected. Is the vibe coded test suite covering your edge cases? If not, every new feature feels like a minefield.

None of this means you should throw away what you’ve built. Even messy code contains valuable lessons about user needs and product direction. The key is recognizing when you’ve hit the ceiling, and then deliberately evolving the prototype into the next phase of your product with architectural decisions carefully made by experts.

Engineering for the Next Stage

Once your vibe-coded AI prototype is available to the world, the real work begins. Getting users, and seeing how it all holds up, not just the engineering of the system, but the acceptance of the product by the masses. Turning a promising idea into a resilient product requires iteration that is driven by user needs, as well as architectural evolution. That usually means focusing on a few key upgrades:

• Architecture and codebase audits: Identifying weak points early prevents expensive rewrites later.
  
  
• Security hardening: Authentication, role management, and data handling need to be airtight, and you need to understand your security posture so that you can mitigate issues and reduce your risk of introducing new ones as you iterate.
  
  
• Deployment pipelines and monitoring: Continuous integration, automated tests, and observability tools need to be in place so you can identify the root cause of issues and iterate quickly.
  
  
• Clean, modular design: A maintainable codebase accelerates future development.

The goal isn’t to scrap what you’ve already built. Even rough prototypes contain valuable logic and insights. The fastest and cheapest path forward is almost always to evolve the existing codebase: refactor, stabilize, and expand to make a product that’s ready to grow with real-world demands.

Building a True MVP: What It Takes

Your MVP isn’t just about getting something launched; it’s about building something that can survive first contact with real users and get you early insights into what features they really want.

A well-built MVP needs:

• Validation of the core product hypothesis: proof that people actually want to use the product you’re building.
  
  
• A modular, maintainable codebase: Keep things simple but structured so iteration doesn’t grind to a halt, the ability to change direction quickly is key in your early days.
  
  
• Real error handling and performance management: Crashes, bugs, and lag erode trust and kill momentum, and when they happen, you have to have good insight into why they occur to be able to resolve them quickly before your early users flee.
  
  
• Infrastructure for quick iteration: Deployment pipelines, automated tests, and monitoring give you confidence to ship your product, hopefully many times per day!

The art of a good MVP is balance: resilient enough to support growth, but lean enough to adapt. Too fragile, and you lose users. Too bloated, and you lose time. Once your MVP proves itself with real users, the challenge shifts: how do you scale without creating tomorrow’s technical debt?

Scaling Beyond the MVP

Once an MVP is live and delivering value, the next hurdle is scale. Growth brings its own set of engineering challenges.

Key considerations include:

• Cloud-native architectures: Design systems that can scale seamlessly with demand, but at a cost you can afford.
  
  
• Observability and incident response: Metrics, logs, and alerting ensure issues are caught before users feel them.
  
  
• Product and platform roadmaps: Align feature growth with the technical foundations needed to support it.
  
  
• Maintainability and team handoff: Write code and design systems that a growing team can understand, extend, and own.

The goal is rapid iteration built on a solid foundation: your MVP should evolve into the backbone of your product, not a throwaway experiment. By thinking about maintenance and growth early, you ensure today’s momentum doesn’t turn into tomorrow’s bottleneck.

Marrying Speed with Stability

The power of getting an idea out of your head and into the cloud with an AI-generated prototype is a gift to innovators. You can build faster, test ideas earlier, and collect user feedback in record time. For early-stage companies, that’s invaluable: building something interactive is the best way to validate whether you’re building the right thing.

The first version of a product is often the most expensive and the highest risk. AI helps mitigate that risk by reducing the time and cost to reach the most valuable asset a new company can have: real market feedback.

As the idea is proven and iterated, priorities shift quickly. Stability, security, DevOps, and scalability are critical when so much outside the core of the app is changing. That quality core will enable you to preserve the momentum that AI enables while your technical foundations keep your product reliable.

The path forward isn’t a fork where you choose between speed and stability. With the right support, you can find the balance to achieve both and build the infrastructure to sustain them.

Schedule a free technical consultation to see how SmartLogic can help you go from proof-of-concept to production-ready MVP quickly, safely, and with confidence.

In 2024, AI became a hot topic. According to Google Trends, the popularity of the search term "AI" increased by 19% from January 2023 to January 2024 and then exploded by an additional 71% from then to now, reaching its peak popularity.

From my perspective, every headline, post, and tool demo mentioned AI and machine learning. I was intrigued, but I wasn't ready to jump in just yet.

Eventually, I downloaded ChatGPT and started to fiddle. Our president kept tossing out ideas in leadership meetings, such as using AI to extract product requirements from initial sales inquiries. The results were decent but left a lot to be desired. However, even with its quirks, I could see the potential.

Sometime in 2025, my little spark turned into a fire. I don't know exactly when the shift happened. It may have happened when I joined the Bureau of Digital's AI & Automation Slack group and saw my colleagues' curiosity and passion. It could have happened as I listened to The Artificial Intelligence Show podcast, where each episode laid bare the speed at which AI was transforming business.

Whatever it was, I was lit up. I was ready.

... But I had no roadmap.

Where Do You Start?

I asked around. (I even asked GPT!)

There was no consensus. Some folks were going full YOLO and trying every tool without concern for governance. That approach didn’t sit right with me or align with our company’s values around security, reliability, and sustainability.

On the flipside, some were staunchly opposed to the use of AI in any capacity. That also seemed like the wrong route. AI is here, whether we like it or not. At the very least, we need to understand it.

So, I did what any COO would do: I made a plan. I pitched it to our leadership team as an “experiment with guardrails.”

Internal Structure: Build the Right Foundations

Before using any of these tools, we wanted to make sure we were doing so responsibly and safely.

I partnered with our Director of Engineering, Dan Ivovich, to draft a high-level Acceptable Use Policy. This wasn’t meant to cover every edge case; it was a North Star to guide how we use AI tools thoughtfully, knowing the landscape is changing fast. (Happy to share it... just ask!)

We also updated our Service Agreement to disclose that we may incorporate AI tools into client work. Transparency builds trust and prevents misunderstanding.

Our clients were grateful for the heads-up, and many welcomed the potential for increased efficiency and ROI.

Creating Space: The Tiger Team

Once we had the proper guidelines in place, we assembled the SmartLogic AI Tiger Team! The Tigers are a volunteer group of team members who are interested in exploring how AI can improve our work.

We weren't chasing moonshots. We simply wanted to learn through curiosity.

Each Tiger was encouraged to journal their experiments:

• What worked?
• What didn’t?
• How much time was saved?

From Play to Purpose: Introducing Tiger Missions

We met regularly to share what we learned, whether from articles or hands-on experiments with AI tools. It was a safe space to explore and grow, with a little support and no pressure.

But I quickly realized that although fun is great, we needed focus.

So we leveled up our approach. I posed two guiding questions to the team:

1. Can AI tools help us maintain and modernize existing codebases more pragmatically?
2. Can we build meaningful agentic applications (not in the future, but today)?

With these principles in mind, the Tigers were assigned their missions. We have some team members using AI to modernize legacy systems written in outdated JavaScript. Others are building agentic tools for client use cases.

These experiments are still underway and evolving. I'm excited to share more as we continue on this journey.

Personal Accountability: Learning by Doing

For this effort to succeed, it demanded something from me: personal commitment.

I needed to commit to this project not just because of my title, but because I can't lead if I'm not actively learning as well. I need to stay sharp, relevant, and inspired.

This commitment inspired me to enroll in Purdue’s Generative AI for Business Transformation bootcamp: a 16-week deep dive into all things AI across business domains, from software development to sales, marketing, operations, analytics, and service.

The wealth of knowledge I gained from this course has been invaluable.

Beyond the Walls: Building External Community

Internally, we were gaining momentum, and I wanted to keep that energy going by sharing what we learn with the broader community.

So I started "AI Did What?!," a monthly show-and-tell I host for the Bureau of Digital. It’s a casual, low-pressure forum where agency and consultancy peers share their personal experiences with AI.

In these sessions, I've witnessed such profound authenticity, creativity, and collaboration. It's been deeply humbling and energizing.

The Common Thread

From the bootcamp, to the Tigers, to “AI Did What?!”, I noticed a common thread: Learn by doing, and learn by sharing.

My role is to keep that momentum going by facilitating discussion and collaboration within our team, and by bringing in ideas from external conversations with peers. This continuous exchange is what keeps us learning and evolving together.

AI is brand new. The only way to understand it is to play, experiment, and explore.

If you're curious, just start. Stay open. Embrace imperfection. Keep going.

We haven’t figured it all out yet, and we don’t have to. We’re moving the needle, together.

If you’re on a similar path or not sure where to begin, I’m always happy to connect, share resources, or just chat.

This work is too important (and too exciting) not to do together.

TEDCO recently put out an RFP to, tldr, “build us a new website.” The requirements include standard CMS fare: events, funding programs, news, updates, and portfolio companies. Nothing too complicated.

I looked at the RFP and thought:

1. They’re going to be inundated with companies tripping over themselves to try to get the business. Godspeed. (We decided against submitting an RFP.)
2. My second thought was: these requirements are basic. Lemme try vibe code this.

Disclaimer: TEDCO has absolutely nothing to do with this blog post. Likewise, TEDCO is not affiliated with SmartLogic.

What is Vibe Coding?

Vibe coding is the time-tested practice of using AI tools to quickly build a prototype or functional application based on vibes, gut feel, and just enough spec.

At SmartLogic, we are increasingly vibe coding when designing / building prototypes for new project ideas. It’s a big time / cost savings.

Vibe coding allows someone like me - who hasn’t written a line of code in a long time - to get something off the ground quickly, without having to trouble developers.

What did I build?

Test out my prototype or check out this youtube video:

What tools did I use to vibe code this?

1. Lovable AI: an AI app builder and vibe coding platform that uses generative AI to build a web application as you continue to prompt it. Each successive prompt builds additional functionality.
2. Supabase: a Postgres database in the cloud. Lovable uses Supabase as its data store.
3. Spreadsheet: nothing beats a spreadsheet for keeping track of requirements!
4. My brain: I pulled it all together using actual intelligence.

How do you actually "vibe code?"

You prompt Lovable much like you'd prompt ChatGPT and Claude. Here's a video of me adding functionality to add, edit, display programs by prompting Lovable:

What I’d change about my approach next time

I confess that I initiated this effort thinking that I could one-shot it - that I’d just upload the RFP to Lovable and it’d build the whole thing for me in a few minutes. We’re not quite there yet.

AI is non-deterministic - you can type in the same prompt and get different results. If your prompts are too broad, the universe of possible answers grows exponentially. For the best results, it’s critical to focus the AI through thoughtful and specific prompting. The narrower your aperture and prompts, the more focused your results will be.

If I embarked on a project like this again, I’d make these changes to better prompt the AI:

1. Start by understanding the domain model: what are the different “things” that we are trying to represent in this website and what are their relationships to each other? In the case of TEDCO: how do funding programs relate to portcos / investments and resources? How do network advisors relate to resources or funding programs, if at all?
2. Identify the different administrative roles: should a subset of functionality (e.g. updating content in the CMS, editing programs, publishing events) only be made available to a subset of admins (i.e. TEDCO employees)? This could shake out from writing up the requirements.
3. Write up all requirements in a spreadsheet: the TEDCO RFP is a great starting point. But the requirements are not super specific, are not organized to my liking (they are scattered throughout the RFP), nor are they written as user stories. (Of course, 100% of the time, every dev shop / web agency / developer will bemoan that the requirements for every project could be more clear.) I do expect that the vendor with whom TEDCO signs a $150-250k contract will enumerate the requirements in a technical format / as user stories.
4. Build some prompt templates: I could have saved time by preparing prompt templates for, in particular, some of the administrative CRUD functionality.

What did this cost?

Short answer: $50 and ~12-16 hours of my time prompting Lovable. If I did this again, I’d expect to spend $25 for Lovable and perhaps ~6 hours of my time setting up prompt templates and prompting Lovable.

Keep in mind that the valuation of these AI / SAAS companies is in direct proportion to their MRR and ARR (monthly / annual recurring revenue). Once you type in that credit card number and hit submit, you’ll be paying until the first of any of these events: you close your credit card account, the sun burns out, or you cancel your recurring subscription.

My takeaways

1. Vibe coding platforms are great for prototyping and maybe even be suitable for building select production applications.
2. If I wanted to build something I thought was within the realm of what these tools were capable of building, my first move would not be to prompt an AI coding platform. Consider this: if you wanted to remodel your bathroom, you wouldn’t first reach for the sledgehammer. You would first reach for a pen, paper, and a measuring tape to sketch ideas and clarify specs.
3. These tools are great at creating sample data. (I think developers do everybody a disservice when putting lorem ipsum text anywhere or when using “asdf” or “qwerty” or “aaaaaaaa” as dummy data, but I digress.) To my great pleasure, Lovable created wonderful dummy data - everything you see in the site was created by Lovable - in many cases after my thoughtful prompting.

It’s all easier than it looks. These tools are remarkable. What are you waiting for? Fire them up and go!

What’s next?

Who knows? The pace of change is accelerating and these tools are becoming more and more useful.

Please reach out to me if you’d like to learn more about how we use AI at SmartLogic and how it might apply to your priorities. I'm always happy to chat. Find me on LinkedIn or book a 1-hr call.

Discovery sits at the heart of how we deliver great software. But, if we're honest, it's easy to fall into a checklist mindset: jot requirements, sketch a flow, build a backlog.

Unfortunately, when we skip the real work of uncovering assumptions, we risk building the wrong thing.

At SmartLogic, we are always looking for ways to sharpen our skills and stay curious. Recently, we partnered with Ti Mougne, an ICF-certified Agile project management coach with a decade of experience leading enterprise transformation efforts across Fortune 50-500 organizations.

Our goal during these sessions was to refine our product discovery process to build a solid foundation before writing a single line of code.

How Do We Define Product Discovery?

Before the workshops, we surveyed the team to gauge confidence around key product discovery activities: framing problem statements, designing experiments, and explaining the value of discovery to clients.

The results highlighted our areas of opportunity. While most team members felt confident in their own skills, we lacked a shared understanding of what discovery is, how it works, and why it matters. These gaps became our starting point.

Discovery vs. Planning: It's Not Either/Or

Early on, we were offered a powerful reframe: discovery and delivery aren't opposites; They're complementary. Discovery embraces ambiguity and experimentation, while planning brings clarity and structure. There's no need to pit the two against one another. The best strategy is a balance of both mindsets, treating them as a "polarity to be managed."

We explored the product discovery process through a six-step flow:

1. Frame the problem
2. Map the assumptions that must hold true
3. Interview stakeholders to surface real needs
4. Run quick experiments to test the riskiest bets
5. Translate the findings into explicit learning goals
6. Package everything into a concise discovery brief

Some reflections from the team:

• The structure helped reduce anxiety around the upcoming discovery process.
• It clarified how to approach discovery more intentionally and collaboratively.
• It encouraged a mindset shift, focusing on uncovering needs rather than rushing into solutions.

Successful projects oscillate between exploration and execution. A structured discovery process reduces uncertainty before locking in milestones and delivery plans.

In week 1, we uncovered the unknowns. Then, it was off to week 2.

From Insights to Product Roadmap

In Week 2, we turned insights into an actionable plan. We began by defining the problem statement and reflecting on our Week 1 approach. This reflection was key: product discovery isn’t just about what to build, but who we’re building for and why.

The second workshop focused on strengthening our "discovery muscles" by:

• Framing the real problem
• Mapping assumptions
• Understanding stakeholder impacts
• Translating insights into a three-month roadmap

Discovery is a cyclical, non-linear process in which you learn, refine, pause, revisit assumptions, and sharpen focus.

Practical breakout exercises guided our team to:

• Link assumptions to affected stakeholders
• Craft testable learning questions
• Define success metrics
• Regroup and reflect on risks, surprises, and mindsets

The takeaway? To optimize the discovery phase, teams must align on purpose, continuously question their beliefs, and ask the right questions for the right people at the right time.

Real Discovery Means Real People

Discovery isn’t just about sticky notes and frameworks, it’s about people.

A prompt we now use more often: “Who is impacted if this assumption is wrong?”

That simple question shifts the focus from abstract features to real consequences.

One example: during the workshop, a team questioned whether a key legacy feature should be retained. By asking, “What evidence would convince us?", we opened the door to better experiments: user interviews, early usage tracking, and timed reevaluation.

Across the board, every assumption became a hypothesis we could test.

The Real Takeaway: Stay Curious, Together

Discovery isn’t a box we tick on the way to delivery, it’s the habit of staying curious long enough to build the right thing, for the right people, at the right moment.

These workshops reminded us that progress comes from pairing bold assumptions with humble questions and letting evidence steer the course. When we surface uncertainties early, tie them to real stakeholders, and test them in lightweight ways, we avoid costly rework and move forward with focus.

As we roll the three-month roadmap forward, we're keeping that learning loop alive. We're celebrating insights, challenging blindspots, and remembering that clarity earned together is the fastest path to impact.

Curious how discovery can improve your product roadmap? We’d love to hear about your product goals. Book a free strategy call with us and let's start the conversation!

I lugged two yellow mystery boxes onto the 25NTC Expo floor and set them on our sponsorship table.

The rules were simple: On a slip of paper, jot down:

1. a tech challenge your nonprofit is wrestling with and
2. your best guess of what's in the box!

We selected two winners:

1. The person with the closest guess
2. The person with the dopest guess

We used some gamification for a chance to win the mystery contents.

The box filled up with nonprofit software challenges faster than our swag table emptied. By the end of the conference, we had almost 100 submissions and, more importantly, a clear snapshot of what’s keeping mission‑driven teams up at night.

Below are the three biggest lessons that stuck with me and how we're using these insights to reshape how our team approaches custom software for nonprofits.

1.  Curiosity Is Currency

A playful prompt opened doors that an elevator pitch never could have. Since I didn't lead with a sales pitch, attendees felt much more free to vent:

• “Too many CRMs.”
• “Being hacked... again.”
• “AI implementation overload!”
• “Development doesn’t value our tech staff.”

Every comment was an unfiltered pain point and an invitation to ask, “Tell me more.” Five follow‑up “whys” later, I often discovered the real blocker had little to do with code. Curiosity let me trade surface chatter for root‑cause honesty.

2.  Build Context Before Code

As I read through the slips on my journey home, patterns leapt off the page:

Integration & Data Silos – “Integrating all our platforms;” “Nothing works with each other.”

Resource & Staffing Gaps – “Not enough tech team members;” “Time to do it all.”

AI Readiness vs. Hype –  “Adopting AI;” “AI overuse.”

Security & Compliance – “Being hacked;” “IODLC compliance.”

Notice anything missing? Hardly anyone mentioned the need for a brand new application. Most wanted their existing patchwork to behave or guidance on whether a shiny AI pilot was worth the distraction. This validated what we preach daily: custom software development should start with context, not code. Sometimes the right answer is an integration layer or a workflow tune‑up, not a six‑figure build. When I share that directly, heads nod, shoulders drop, and trust grows.

Need more ideas for optimizing your nonprofit software without starting from scratch? Check out 6 Simple Software Upgrades to Improve Nonprofit Operations.

3. Quality Questions Lead to Conversions

Having the handwritten feedback in my pocket informed the conversations that followed. Instead of “Let me show you what we do,” I asked:

1. What outcome will make your board cheer next fiscal year?
2. Where does the current process break for frontline staff?
3. What would success look like six months later if we waved a wand and fixed it?

These questions help us uncover valuable information, keep the spotlight on mission impact, and help both sides decide whether a custom engagement (even one as small as a two‑week integration sprint) will pay off.

Saying, “We may not be the right partner, but here’s a lightweight fix” has already filtered in better‑fit leads and spared a few nonprofits expensive detours.

Where We Go From Here

The mystery contents were revealed: a $100 gift card to gift to a nonprofit or organization of the winner's choosing, and Baltimore in a Box, Mr. Trash Wheel edition.  The boxes found their new homes, and the stack of entries with scribbled frustrations lives with me. These insights are a daily reminder that:

• Engagement tactics matter, but only if they unlock empathy.
• Discovery isn’t a phase, it’s a discipline.
• The best "sales pitch" is a good question asked at the right moment.

My challenge for you: Pick your next conference (or even your next client call) and replace one polished slide with a genuine question that reveals the root cause, then listen longer than feels necessary. Mission impact starts there.

Thanks for reading. If any of the challenges above sound familiar, let’s trade notes! If you'd like to connect, shoot me an email: bri@smartlogic.io

Does your organization need help solving a similar nonprofit technology challenge? Whether it's a small integration or a larger rebuild, we help nonprofits like yours with software that works for their mission.

Schedule a free 1-hour strategy call with me.

The Wizards are back, and this time we’re blasting off beyond the BEAM to see how Elixir plays with Rust, Zig, Bluetooth, and whatever else crosses our wiring. Season 14 premieres on Thursday, May 29th, 2025, and new episodes drop weekly on Thursdays through August.

In the Elixirverse, we’re chatting about Elixir’s interoperability with other languages, NIFs and ports, what’s new with ML in Elixir, IoT projects, and more.

Watch the episodes on the SmartLogic YouTube Channel or tune in to the audio episodes on Apple Podcasts, Spotify, or wherever you prefer to stream podcasts.

Check out Elixir Wizards Podcast S14E01 Zigler: Zig NIFs for Elixir with Isaac Yonemoto out now on YouTube and audio.

Looking Back at Season 13: The Creators’ Lab

If you missed out on any of the episodes from Season 13: The Creators’ Lab, never fear! All the episodes are available for your listening pleasure.

Fun fact: In our brainstorming meetings, we initially named Season 13 “Creators Creating Creations.”

S13E01 Creating the Igniter Code Generation Framework with Zach Daniel

Zach introduced us to Igniter, a code generation and project patching framework designed to streamline the Elixir development experience.

After this episode, we were inspired to use Igniter for some of our internal tooling. Check out Owen’s article here: Potions in a Cauldron: Streamline Elixir App Development with Code Generation

S13E02 Creating VintageCell: Nerves, PCBs, and GenStateMachine with Bryan Green

Bryan rebuilt a 1930s rotary phone into a fully functional cell using Nerves, custom PCBs, and a hearty dose of GenStateMachine. He walked us through decoding rotary clicks, hot-swapping SIM cards, and shipping over-the-air firmware updates. Proof that “retro” and “IoT” can coexist in one glorious project.

S13E03 Creating a Local-First Offline-Enabled LiveView PWA with Tony Dang

Tony’s LiveView + Svelte to-do app works perfectly offline thanks to CRDTs, service workers, and Yjs. He explained the utility of offline functionality and how this capability can improve user experience, how to juggle LiveView sockets when connectivity drops, and where CRDT magic trumps last-write-wins headaches.

S13E04 Creating a Terrestrial Telescope using Nerves & LiveView with Lucas Sifoni

Indie developer Lucas Sifoni takes us on a journey of prototyping a remote-controlled terrestrial telescope using Elixir, Nerves, Rust, and custom hardware components. Lucas shares his approach to simulating hardware components, testing assumptions, and balancing educational value with usability.

S13E05 Creating the WebAuthn Components Library for Phoenix LiveView Apps with Owen Bickford

Elixir Wizard and SmartLogic developer Owen Bickford sat in the hot seat for Episode 5 to discuss his work building WebauthnComponents, a library for passwordless authentication in Phoenix LiveView apps.

S13E06 Creating the Standd AI-Native Due Diligence Platform with Stephen Solka

Episode 6 brings Stephen Solka, CTO of Standd.io, to the Wizards' table. Stephen shares the journey of building an AI-native due diligence platform that uses large language models to streamline document analysis for venture capital firms.

S13E07 Creating the Castmagic AI-Powered Content Workflow Platform with Justin Tormey

Justin Tormey joined the Wizards to discuss his AI-powered content creation app that transforms audio and video into engaging social posts, newsletters, and other marketing materials. With Elixir coordinating the backend and Phoenix LiveView powering the frontend, Castmagic leverages OpenAI and Anthropic LLMs to simplify workflows for content creators.

S13E08 Scaling the Daylite Apple-Native CRM Using Elixir with AJ

AJ (Alykhan Jetha) shares how their company built and evolved Daylite, a CRM designed specifically for Apple users. AJ recounts his journey as a self-taught programmer, detailing why Marketcircle migrated Daylite’s backend to Elixir for high concurrency and fault tolerance.

S13E09 Telemetry & Observability for Elixir Apps at Cars.com with Zack Kayser & Ethan Gunderson

Zack and Ethan run observability for millions of monthly users at Cars Commerce. They share the critical role observability plays in diagnosing incidents, tracing system behavior, and improving performance. For engineers tackling large-scale Elixir systems or simply looking to improve app performance, this episode offers a wealth of actionable insights.

S13E10 Creating Horizon: Deploy Elixir Phoenix Apps on FreeBSD with Jim Freeze

Jim Freeze, organizer of ElixirConf and creator of the Horizon deployment library, shares how Horizon simplifies deployment of Phoenix apps with Postgres on FreeBSD, minimizes external dependencies, and provides a fault-tolerant setup. Jim emphasizes the importance of owning your deployment environment and understanding your stack.

S13E11 Building an Open Vehicle Control System using Elixir and Nerves with Marc, Thibault, and Loïc

The Spin42 crew discussed their groundbreaking project: retrofitting a 2007 VW Polo with an Open Vehicle Control System (OVCS). Combining Elixir, Nerves, and Raspberry Pis, the team shares how they’ve transformed outdated vehicle tech into a modern, open-source system. The conversation covers the technical intricacies of OVCS, including building a Vehicle Management System (VMS), reverse engineering CAN messages, and ensuring safety with fail-safe modes.

Join the conversation

Questions or guest ideas? Comment on our YouTube videos or email us at podcast@smartlogic.io.

Enjoying the ride? A quick review helps fellow Elixirists find us!

Follow us on BlueSky @smartlogic.io, on Twitter @smartlogic, and on LinkedIn

Thanks for listening!

Software can help your team operate more efficiently, or it can hinder performance. It all depends on how well it supports your mission and needs. Maybe your team spends hours manually entering data into spreadsheets, copying and pasting donor information between systems, or scrambling to pull reports that should be automatic.

Does this situation sound familiar to you? If so, you’re not alone. Many nonprofits struggle with outdated, disconnected systems that drain time, limit impact, and slow growth. But it doesn’t have to be this way, and you don’t need a full tech overhaul to improve your operations.

Small, strategic tech upgrades can streamline repetitive tasks, save time, reduce costs, and make life easier for your team.

Here are six simple ways to improve your nonprofit’s tech and reallocate time to your mission’s impact:

1. Automate Manual Workflows

Does Your Team Spend Too Much Time on Data Entry?

If your nonprofit relies on spreadsheets and manual data entry, you’re wasting hours every week on work that can be automated. Automation isn’t about replacing people, it’s about freeing them up to do more meaningful work.

Quick Fix:

Set up automated workflows that connect your donor CRM, email marketing tool, accounting software, and volunteer management system. No more manual data transfers.

Example:

A nonprofit using Salesforce for donor management and QuickBooks for finances can integrate the two, so donation data automatically syncs with accounting. This quick fix can save your team hours of tedious work.

2. Get Your Systems Talking to Each Other

Are You Manually Moving Data Between Platforms?

Your nonprofit donor database, event registration platform, and email marketing tool should work together seamlessly. Unfortunately, many nonprofits struggle with disconnected systems that make simple tasks way harder than they should be.

Quick Fix:

Use APIs or middleware to sync platforms so data flows automatically. That means no more downloading CSVs just to re-upload them somewhere else!

Example:

A nonprofit hosting virtual fundraising events might use Eventbrite for registrations, Mailchimp for email, and Neon CRM for donors. Without integrations, the team has to manually update each system. Connecting them through an API means that once someone registers, they’re automatically added to the right email list and CRM record.

3. Make Your Website Work for Everyone

Does Your Website Feel Slow, Outdated, or Hard to Use?

According to research performed by Google, 53% of mobile users leave a website that takes more than three seconds to load. If your site isn’t mobile-friendly, you could be losing donations before the page even loads.

Quick Fix:

• Prioritize WCAG accessibility standards
• Optimize for mobile devices
• Speed things up with faster hosting & image compression

Example:

The Trevor Project redesigned its crisis support site, making it fully mobile-friendly and accessible to ensure that at-risk youth could reach resources quickly.

4. Strengthen Cybersecurity & Protect Donor Data

Are You Doing Enough to Keep Donor & Program Data Secure?

Cyber threats are rising, and nonprofits aren’t immune. But basic security measures go a long way.

Quick Fix:

• Enable MFA (multi-factor authentication) on all accounts
• Use encrypted data storage for donor info
• Run regular security audits & software updates

5. Reduce Tech Debt & Keep Your Systems Updated

When Was the Last Time You Updated Your Software?

Old, neglected software gets slower, riskier, and more expensive to fix over time. Many nonprofits delay maintenance until something breaks, which ends up costing way more in the long run.

Quick Fix:

Adopt a post-launch support plan to keep systems secure, stable, and stress-free.

6. Build for Growth with Scalable Tech

Will Your Current Tech Still Work 5 Years from Now?

Too many nonprofits build software for the present, not the future, and end up replacing entire systems when they outgrow them.

Quick Fix:

Use scalable architectures, modular development, and cloud solutions so your tech grows with you.

Example:

UNICEF moved from legacy systems to cloud-based platforms, allowing for real-time data sharing across multiple countries and faster disaster response.

Tech that Works for Your Organization

You don’t need to rip and replace everything. Small, strategic software upgrades can free up your team, strengthen security, and create more space for impact.

At SmartLogic, we help nonprofits modernize, integrate, and support the software they rely on every day. If your systems could use a tune-up, schedule a free strategy call with us, and let’s talk about it!

Mobile web browsing isn’t the future, it’s the default. According to the data, 62% of website visits are performed on mobile devices. For your nonprofit, mobile devices are the primary way users engage with your website.

If you want users to learn about your mission, sign up to volunteer, and make a donation via your website, make sure they can easily navigate to these pages while browsing on their phone. If your site wasn’t built with mobile in mind, you could be missing these opportunities.

Fortunately, you don’t need a complete website redesign to improve your site’s mobile experience. Small, strategic upgrades can make your site more accessible, more effective, and better aligned with your goals. We’ve compiled this list that you can begin to implement today:

1. Start With a Mobile-First Mindset

A responsive website shouldn’t just shrink your desktop site—it should be designed with mobile users in mind from the jump. That means prioritizing ease of navigation, readability, and clarity on smaller screens. Think bigger buttons, simplified layouts, and clear calls to action that are easy to tap.

💡 Pro tip: Use mobile-specific wireframes early in your design process to avoid retrofitting later.

2. Prioritize Load Speed

Nobody likes waiting, especially on mobile. Slow sites drive visitors away, increase bounce rates, and hurt your SEO rankings. In fact, studies show that 1 in 2 people expect a site to load in less than two seconds. If it doesn’t, they’re gone. [  Source: Google Research ]

Quick wins here include compressing images, reducing unnecessary JavaScript, and enabling caching.

3. Make Navigation Foolproof

Tiny buttons and awkward tap targets are a mobile UX killer. Mobile visitors don’t want to hunt for the Donate button or scroll endlessly to find your latest campaign.

• Use sticky headers and simple menus
• Create a sitemap hierarchy that puts the most important actions front and center
• Avoid drop-downs and mega-menus
• Keep it clean and intuitive
• Stick with large, finger-friendly buttons
• Avoid grouping links too closely
  

4. Embrace Accessibility Standards

Accessibility isn’t just about compliance—it’s about equity. Following WCAG guidelines ensures your content is usable by people with disabilities and improves the experience for everyone. This includes using proper heading structures, adding alt text to images, ensuring strong color contrast, and making sure everything is operable via keyboard or screen reader.

Want to learn more about accessible web design? Read more here: Accessible UX Design: Unlock the Power of Web Accessibility

5. Make Sure Your Forms Are Usable

Forms are a huge pain point on mobile, especially if you’re asking donors or volunteers to type long-form responses on a tiny touchscreen. Refine your forms:

• Minimize the number of required fields
• Auto-format inputs (like phone numbers or zip codes)
• Use the right mobile keyboard (e.g., number pad for phone fields)
  

​​6. Design for Thumbs, Not Mice

Desktop UX often assumes users will hover, right-click, or precisely click small targets. On mobile? It’s all thumbs. Ensure touch targets are large enough (WCAG AAA requires at least 44px by 44px) and spaced far enough apart to avoid accidental taps.

7. Test on Multiple Devices

It’s not just about phones vs. desktops. Your audience is using Androids, iPhones, tablets, and everything in between. Don’t assume what works on one screen will work on all. Use responsive testing tools (like BrowserStack or Chrome DevTools) to simulate different screen sizes and catch bugs before your users do.

8. Measure, Iterate, Repeat

Good mobile design is an ongoing process, not a one-time checklist. Use analytics tools to see where users drop off or get stuck. Track performance metrics like page speed and conversion rates. Then optimize based on real data.

Let’s Talk About Your Mobile Experience

At SmartLogic, we build responsive, mobile-first web apps and custom platforms that help nonprofits do more with less. Whether you're looking to improve your site’s accessibility, speed, or user experience (or build something brand new), we can help you find a solution that fits your mission and budget.

Ready to optimize your user experience? Schedule a free strategy call with our team and let’s talk about it!

The initial deployment of your nonprofit’s custom software isn’t the finish line—it’s the opening of a brand new chapter. What happens post-launch defines your app’s long-term success. While many nonprofits and businesses invest in software development, they often overlook the critical need for post-launch software support agreement. Without it, your organization risks facing frustrated users, operational inefficiencies, and diminishing returns on your investment.

In this post, we’ll detail why post-launch software support is essential, how it maximizes ROI, and what key features to look for in software maintenance services to protect your investment and achieve a lasting impact.

Your Software is Live—Now What?

Launching your nonprofit software is a huge milestone! But, you can't just set it and forget it. Before launch, the engineers and designers behind your platform conduct rigorous testing to deliver a seamless user experience. Still, even with the most meticulous planning, once real people start interacting with the system, edge cases and unforeseen challenges are inevitable.

Your nonprofit software evolves alongside your goals and your users’ needs. As your organization grows, new challenges and opportunities will inevitably arise and demand adaptability from your systems. Features that once worked flawlessly may be strained as your user base increases in volume. Launching new programs or expanding initiatives can also impact your software performance.

Some issues can only be revealed post-launch. Once users are active on your platform, bugs can emerge, bottlenecks can appear during periods of heavy traffic, and usability issues can be uncovered. Without post-launch support, these issues may go unaddressed and hinder your operations, frustrate your staff, and erode the trust of your users.

Address Risks and Build Resilience

Without regular maintenance, your software is vulnerable to malicious actors and technical risks. Every day, new security threats emerge. Outdated systems are the prime targets for security breaches that can jeopardize your donor and program data. Additionally, unsupported frameworks and libraries can cause compatibility issues when integrating new tools or leveraging system upgrades.

Unresolved issues don't go away, they actually compound over time. Without proper maintenance, your software can frustrate your staff, increase your tech debt, and stall your nonprofit's progress. The cost of neglected maintenance is beyond monetary, it prevents you from serving your community.

Luckily, with a software support agreement, you can avoid these common pitfalls. Regular software updates and performance monitoring prevent obsolescence. Well-maintained systems have a better ROI, and routine security patches keep your systems, and your users, secure.

How Ongoing Support Protects Your Investment

Post-launch support goes far beyond simply fixing bugs—it’s about keeping your software reliable, adaptable, and secure. Here’s how it helps your nonprofit thrive:

• Improved Performance: Post-launch support includes regular system diagnostics and performance tuning to address bugs, optimize speed, and maintain smooth operations. The support team monitors resource utilization, resolves database inefficiencies, and fine-tunes APIs to handle higher loads. Proactive performance monitoring identifies bottlenecks and resolves them before they escalate to keep your platform functional during heavy user traffic.

• Adaptability to Change: As your nonprofit grows, post-launch updates keep your software up-to-date with new demands. Supporting engineers integrate third-party tools, add modules, and reconfigure workflows to meet your needs. Effective versioning strategies allow for upgrades without disrupting the user experience.

• Security Updates: New cybersecurity threats emerge on a daily basis and target vulnerabilities in outdated frameworks, plugins, and libraries. Post-launch support mitigates this risk with regular patches, dependency audits, and updates in compliance with the latest security standards. Penetration testing and real-time monitoring add extra layers of protection for donor and program data.

• User Satisfaction: Frustrated users can stall adoption and productivity. Post-launch support prioritizes real-time usability improvements, interface refinements, and cross-platform compatibility. Accessibility compliance (e.g., WCAG standards) is also addressed to expand the reach and usability of your software.
  
  Read Accessible UX Design: Unlock the Power of Web Accessibility to learn more about software accessibility standards.

• Cost Savings: Proactive maintenance prevents expensive, reactive fixes and avoids disruptions by addressing potential issues before they affect your users. Regular codebase reviews lower technical debt, while automated processes—such as backups and update rollouts—further improve cost efficiency.

What Happens When You Skip Support?

Neglecting post-launch software support can have serious consequences for your organization’s operational efficiency and growth:

• Technical Debt: Unaddressed bugs and outdated code can snowball into larger, more expensive issues over time. Missing security updates, for example, can cause cascading failures if malicious actors exploit a known vulnerability. Inadequate database maintenance can lead to data corruption or slow retrieval times as datasets grow.

• User Drop-Off: Poor experiences, such as sluggish response times or broken functionalities, erode trust and lead to disengagement. For example, a fundraising platform with repeated payment gateway errors may deter donors from completing transactions.

• Security Risks: Outdated systems are prime targets for malware and ransomware attacks. Without regular vulnerability scans, dependency updates, or encryption protocol improvements, sensitive data is left exposed, which puts compliance and donor trust at risk.

• Missed Opportunities: Without regular updates, your software may struggle to integrate with new systems or support evolving organizational needs. For instance, failure to add mobile-friendly features could alienate users increasingly reliant on smartphones for communication and engagement.

Inadequate support can lead to costly disruptions. Downtime from improper maintenance will not just stall your operations, it will impact your ability to deliver on your mission. For nonprofits, these risks extend beyond financial costs to negatively impact the communities you serve.

Building a Plan That Works for Your Nonprofit

A strong post-launch support plan keeps your software reliable, scalable, and cost-effective. When evaluating a support partner, prioritize these key features:

• Performance Monitoring: Keeping an eye on system performance allows you to catch and address resource utilization inefficiencies. With this information, your support team can optimize hosting and server costs. These funds can be reallocated to other initiatives.

• Security Updates: Proactive patching and dependency management mitigate risks before they become costly issues. Talk to your support team about conducting regular audits to identify vulnerabilities, maintaining compliance with industry standards, and avoiding the financial and reputational impact of breaches.

• Feature Updates: Flexible support allows you to add or enhance features based on user feedback and evolving organizational needs. Rather than waiting for the system to become outdated, incremental updates keep your software relevant to serve your mission effectively.

• Transparent Communication: A reliable partner provides clear, regular reporting on system health, cost-saving opportunities, and completed updates.

• Scalability: Your nonprofit’s needs will grow and change. Support plans should include strategies to optimize database performance, allocate resources efficiently during traffic spikes, and scale infrastructure as user demand increases.

• Cost Optimization: Beyond maintenance, your support partner should evaluate your hosting and infrastructure setup to identify cost-saving opportunities. For example, moving to a cloud-based environment or implementing auto-scaling can lower ongoing expenses by dynamically adjusting resources based on actual usage.
  
  Read Signs It’s Time to Upgrade Your Business Software: From Refactoring to Cloud Migration to learn more about app modernization.

By combining proactive maintenance, performance optimization, and cost-saving strategies, a reliable support partner can help your nonprofit achieve lasting success without unnecessary overhead.

Protect Your Software Investment and Maximize ROI

Post-launch software support is not optional—it’s essential for maintaining secure, reliable, and impactful systems. By investing in a maintenance plan, your nonprofit can reduce costs, improve software performance, and ensure the long-term success of your mission-critical tools.

Ready to protect your software investment? Contact SmartLogic today to discuss how we can help your nonprofit maximize ROI with tailored support services.