A little over a year ago, I wrote a post called “The Year of the Kiwi.”
At the time, Kiwi Engine was still mostly an idea.
Not in the “idea guy” sense — but in the sense that the architecture existed more in notebooks, diagrams, experiments, prototypes, and long nights of thinking than in polished products.
It was a collection of philosophies:
- modularity over monoliths
- contracts over assumptions
- pipelines over hooks
- systems over trends
- stewardship over convenience
- architecture over hype
And honestly, at the time, I wasn’t entirely sure how far the idea would go.
I just knew I couldn’t shake the feeling that modern development had become increasingly chaotic.
Every few months:
- a new framework
- a new “must-use” stack
- another rewrite
- another abstraction
- another platform trying to become the platform
- another ecosystem lock-in strategy disguised as “developer experience”
Meanwhile, developers and businesses are left carrying the long-term weight of those decisions.
Over the last year, I’ve spent an enormous amount of time trying to answer a question:
“What would a modern application engine look like if it were designed intentionally from the ground up today?”
Not just a framework.
Not just a CMS.
Not just another JavaScript library.
An actual engine.
An ecosystem designed around:
- portability
- scalability
- infrastructure awareness
- deployment flexibility
- composability
- long-term maintainability
- vendor neutrality
- and developer sovereignty
And over this last year, that vision has evolved dramatically.
Kiwi Engine grew into something much larger than I originally imagined.
The ecosystem now includes:
- WebEngine
- KiwiPress
- Juice
- Nectarine
- GrapeVine
- Sig.js
- Seltzer
- Citrode
- and several internal systems and concepts still actively evolving.
Each one solving a different layer of the stack.
Some are focused on infrastructure.
Some are focused on UI systems.
Some are focused on deployment orchestration.
Some are focused on APIs and data architecture.
Some are focused on application composition itself.
But they all revolve around the same core idea:
Software should be architected like systems — not assembled like temporary trends.
One of the biggest mindset shifts over the last year was realizing I wasn’t trying to compete with existing frameworks.
I was trying to rethink the relationship between:
- applications
- infrastructure
- deployment
- configuration
- runtime behavior
- and developer workflows
That realization changed everything.
The deeper I went, the more I became convinced that the future isn’t about “winning the framework war.”
It’s about reducing fragility.
Because right now the industry is experiencing:
- dependency fatigue
- cloud complexity
- deployment inconsistency
- ecosystem fragmentation
- AI-generated technical debt
- security concerns
- and increasing platform lock-in
And AI is only accelerating that pressure.
That’s actually become one of the most important realizations for me this past year.
I don’t believe AI replaces architecture.
If anything, I think AI exposes bad architecture faster.
Generating code quickly is not the same thing as generating systems responsibly.
And the more I studied this space, the more I became convinced that stewarded systems matter more now than ever before.
That’s part of why so much of this ecosystem is becoming:
- contract-driven
- configuration-based
- adapter-oriented
- infrastructure-aware
- and intentionally modular
I want systems that can:
- move providers
- evolve safely
- swap technologies
- separate concerns properly
- and survive longer than the current hype cycle
I also spent a huge amount of time this year diving deeper into:
- containerized architecture
- infrastructure-as-code
- deployment pipelines
- hybrid cloud systems
- headless CMS architecture
- TypeScript runtimes
- native tooling
- developer ergonomics
- and long-term scalability planning
But honestly?
The most important progress wasn’t technical.
It was mental.
I stopped worrying so much about whether an idea sounded unconventional.
And started focusing more on whether it solved real problems.
Because at some point, you realize:
many “standards” only exist because people stopped questioning them.
That doesn’t mean every experiment succeeds.
But experimentation matters.
Exploration matters.
Systems thinking matters.
And over this past year, I’ve become far more confident that the direction is worth pursuing.
Not because I think I have all the answers.
But because I think the industry desperately needs more conversations around:
- sustainable architecture
- ownership
- portability
- maintainability
- and intentional system design
The Kiwi vision is no longer just a thought experiment.
It’s becoming:
- architecture
- tooling
- infrastructure
- products
- workflows
- deployment systems
- and eventually, platforms.
There’s still an incredible amount of work ahead.
But compared to where this all started a year ago?
The progress has been massive.
And honestly…
I still feel like we’re just getting started.
Year two begins now.
*Take a look at the progress of WebEngine here 👉🏼: https://github.com/citrusworx/webengine