Like any good geologist, I believe you can't understand where you're going until you've dug through the layers of where you've been. And if you're a Rally admin staring down the October 31, 2026 App SDK end-of-life deadline, you might find it comforting, or terrifying, to know that we've been here before.

This is the story of Rally's platform as I lived it. I was employee number 150-ish, and I spent nearly six years building the tools that are now being retired. I've got the GitHub commits to prove it and the gray in my beard to show for it.

Grab a chisel and a hard hat. We're going digging.

A caveman chiseling code onto a stone tablet, with a primitive kanban board drawn on the cave wall behind him

Epoch I: Before Life Was on Land, When Widgets Ruled the Earth

~2006–2008 | The Precambrian

The fossil record from this period is sparse. Rally had fewer than 100 employees. The office probably smelled like ambition and energy drinks. There was essentially no way to customize Rally, what you got was what you got, and you were grateful for it.

The only artifact we've been able to carbon-date from this era is the Rally REST API 1.0, and its origin story is the kind of thing that could only happen at a startup in Boulder, Colorado.

Some guy named James wrote the entire thing in two beer-infused days during an internal hackathon, because his dev manager Mark Ringer bet him a bottle of scotch that it couldn't be done. James won the bet. The rest of us got an API.

That API, born from hops, hubris, and a wager, became the foundation that everything else was built on. Every custom app, every integration, every widget you've ever used in Rally traces its lineage back to those two days.

A fossilized computer monitor buried underground showing //api/ on screen, alongside a bottle with a skull label, an artifact of the original Rally API

I hadn't arrived yet. I was still in the primordial soup of my previous job, blissfully unaware that I'd soon be crawling onto land.

A cartoon dinosaur nervously working at a computer with a To Do / Doing / Done kanban board on screen

Epoch II: The Dashboard Epoch, First Life on Land

~2009–2011 | The Cambrian Explosion

I joined Rally in August 2009, and it was like watching the first creatures haul themselves out of the ocean. Rally had just introduced Custom Pages, the best feature (see: hack) that could be coded by two engineers in less than a week's work. The idea was simple: serve a single-page webpage inside Rally in an iframe. For the first time, customers could build their own visualizations.

I landed on the Apps & Integrations team. Our job was to build the App SDK 1.0, a framework that would let customers create custom apps for those new Custom Pages.

Let me be very clear about what "framework" meant in 2009: we gave you an iteration dropdown and a component to query data. That was pretty much it. You want a chart? Write it yourself. You want a grid? Figure it out. You want your workflow states in a Kanban board? Hardcode them into the HTML and pray nobody changes their process.

The Kanban Board That Started It All

Speaking of Kanban boards, you kids vibe coding today have no idea. I walked uphill both ways to school and it snowed every day.

During a hackathon, my friend Kyle and I built what became Rally's Kanban board, which included a never-before-seen feature in enterprise software (contested by some modern scholars): drag and drop, supported by a series of unstable JavaScript hacks. The workflow states were literally hardcoded into the HTML file. If your team used "In Progress" and mine used "Doing," one of us was out of luck. There was no AI to ask for help. There was no Stack Overflow thread with the answer. There was just you, a text editor, and the Rally API that James built on a scotch bet.

That janky, hardcoded, held-together-with-duct-tape Kanban board became Rally's official Kanban solution for years. It was, as far as I can tell, the first enterprise Kanban board, a full year before Jira had one (they got theirs through the GreenHopper acquisition in 2012). Back then, Kanban was only for hipsters and Toyota factory managers. We were neither.

The source code is still on GitHub if you want to see what software development looked like before GPT: github.com/RallyApps/Kanban, copyright 2011, App SDK 1.32. Where's my cane.

This was the Cambrian Explosion of Rally apps. Suddenly, terrible but functional custom applications were crawling out of the primordial ooze everywhere. They weren't pretty. They weren't always stable. But they solved real problems, and customers loved them, because for the first time, they could make Rally do what they needed, not just what we'd shipped.

A Renaissance-era gathering of scholars presenting an agile dashboard, blending ancient aesthetics with modern project management

Epoch III: The Renaissance

If the Dashboard Epoch was life crawling onto land, the Renaissance was when things got smart, social, and occasionally dangerous.

We shipped App SDK 2.0, a real framework this time, built on ExtJS (remember ExtJS? No? Lucky you). It had grids, charts, data stores, a proper component model. You could build legitimately sophisticated applications without hardcoding your workflow states into the HTML like a caveman.

The Developer Advocate Program

I transitioned from writing code to something that didn't have a name yet at Rally: Developer Advocacy. I created Rally's Developer Advocate program from scratch, figuring out how to grow an ecosystem around our platform, support the developers building on it, and convince the company that open source wasn't a dirty word.

We moved our code to GitHub. We started answering questions on StackOverflow instead of hiding behind a support ticket system. We solidified an actual open source policy. And we started doing something that changed everything: hackathons.

The RallyOn Hackathons

The RallyOn conference and hackathon brought Rally engineers and customers together, literally paired up, side by side, building apps in 48 hours. If you were there, you remember the zombie-themed posters ("I Survived the RallyOn 48-Hour Hackathon Without Becoming a Brainless Zombie"), the all-night coding sessions in Boulder, and the demos where half the apps crashed on stage and nobody cared because the energy was incredible.

I built KanbanSwimlanes at one of those hackathons. Other teams built dependency boards, portfolio trackers, and tools that went on to become real products.

I created the Rally App Building Workshop and delivered it on three different continents. The developer community on our platform grew tenfold. The Custom Agile GitHub now has over 524 repositories, a monument to what happens when you give smart people a platform and get out of their way.

If you want a taste of what that era felt like, Peri Cope wrote a beautiful piece about finding their RallyOn 2013 badge in a basement a decade later. The comments are full of people who were there, remembering it the same way I do.

This was the golden age. I don't say that with rose-tinted glasses, I say it because I was there, and I have the commit history to prove it.

Epoch IV: The Modern Era, Custom Agile

I started Custom Agile in 2017, taking the institutional knowledge from nearly six years of building the platform and putting it to work for the enterprise teams who still depended on it. We've been doing that for nine years now, for organizations like that charge card company that doesn't leave home without you, the government organization that delivers your mail, an airline that lets you pick your own seat, and a couple of insurance companies that really hope you don't get hurt.

A friendly robot holding a wrench beside a futuristic glowing analytics dashboard

Epoch V: Cyberpunk (We Promise It Won't Be a Dystopia) Era

And here we are. Full circle.

Rally is retiring Custom Pages and the App SDK on October 31, 2026. The replacement is called Custom Views, a modern, widget-based dashboard system where you arrange configurable widgets on a canvas.

Read that again. Widgets.

We started with widgets. Then we replaced widgets with Custom Pages and the App SDK. And now we're replacing Custom Pages and the App SDK with... widgets.

Everything old is new again. The technology changes, the architecture gets cleaner, the JavaScript gets less insane. But the fundamental pattern, give users a canvas and let them build what they need, keeps coming back because it keeps being right.

What This Means for You

The new Custom Views give admins much more powerful controls and flexibility in how they display content. The Custom HTML Widget gives you a clean sandbox for HTML, CSS, and JavaScript with direct access to Rally's WSAPI. No ExtJS. No App SDK abstractions. Just you, the browser, the API, and your trusty AI sidekick. A new frontier, but our team at Custom Agile has already trailblazed the transition to widgets, and we're here to help.

But here's the part that keeps me busy: if your organization has custom App SDK apps running on Custom Pages, they will stop working on October 31, 2026. They can't just be dropped into a Custom HTML Widget, they need to be rewritten. And the complexity of that rewrite depends entirely on what those apps do and how deeply they rely on SDK patterns that no longer exist.

Some migrations are straightforward. A simple grid app that queries stories by iteration? That's a weekend project. But a multi-level portfolio hierarchy viewer with LookbackAPI queries, custom renderers, and cross-project scoping? That's a careful, planned effort.

The hardest part isn't the code, it's knowing what you have. Most organizations don't have a complete inventory of their Custom Pages. Apps were built by people who've since moved on, for teams that may have reorganized, solving problems that may or may not still exist. The first step is always: what do we actually have, and what still matters?

Where to Go From Here

You can start by reading our App SDK to Custom Views migration guide (coming soon), where we break down exactly what changes, what breaks, and how to get from here to there before the deadline.

In the meantime, here's what we've published, and what's coming:

And if you're staring at a pile of custom App SDK apps wondering how you're going to get from here to October 2026, we've been staring at Rally source code so long we see ExtJS components when we close our eyes. If you need a hand, we're here.

The geological record of the Rally platform is still being written. If you'd like to contribute to the next epoch, or just need someone who's been digging through these layers for 15 years, get in touch.

Special thanks to Jenny Slade for giving me the courage to write in my own voice.