SolarisPKN-Labs

🔬 Welcome to SolarisPKN-Labs

What happens if I just try to build it?

That question comes up in my head quite often.

SolarisPKN-Labs was born from exactly that: my need to experiment, investigate, and push an idea as far as I can take it.

I don't always start a project knowing exactly what I'm going to build. Many times, I start with a question.

And from that question, the experiment begins.

---

🧪 It's Not Just a Portfolio

SolarisPKN-Labs wasn't created just to showcase finished projects.

It's a place where I document the process behind them.

When an idea comes to mind, I first try to understand what's behind it: what technologies are available, what alternatives I have, what limitations exist, how efficient a solution can be, and what problems I might encounter along the way.

I investigate.

I experiment.

I break things.

I change strategies.

I try again.

And eventually, when I find a solution that makes sense, I turn it into a project.

That's why Labs can contain finished projects, experiments, proof of concepts, tools, research, and solutions that started simply because I wanted to find out whether something was possible.

---

💡 One Question Can Become an Entire System

A great example is SolarisPKN-Stats.

The original idea was extremely simple:

How can I display statistics on a static website and keep them automatically updated?

The website was static.

I didn't want to rely on a traditional backend.

So the first solution appeared:

API
 ↓
JSON
 ↓
JavaScript
 ↓
Website

Perfect.

But then another question immediately appeared:

So who generates that JSON?

And that's where the real experiment began.

I started researching APIs, automation, GitHub Actions, Cloudflare Workers, different ways of storing and updating information, and different approaches for collecting data from multiple platforms.

Then another question appeared:

How can I make all of this efficient?

And then another:

How can I make it fast?

And another:

How can I make it secure and easy to maintain?

And another:

How can I add new data sources without having to modify the entire system?

One simple question eventually turned into an entire architecture.

                   ┌──────────────┐
                   │     APIs     │
                   └──────┬───────┘
                          │
                          ▼
                 ┌─────────────────┐
                 │    Collectors   │
                 └────────┬────────┘
                          │
                          ▼
                 ┌─────────────────┐
                 │   Processing    │
                 └────────┬────────┘
                          │
                          ▼
                     stats.json
                          │
                          ▼
                 ┌─────────────────┐
                 │   JavaScript    │
                 └────────┬────────┘
                          │
                          ▼
                    🌐 Website

And along the way, technologies and concepts appeared that weren't even part of the original idea.

That's Labs.

---

🔎 Research Before Building

An important part of my projects is the research itself.

Before deciding how to implement something, I try to understand what options are available.

For example:

• REST or GraphQL?
• GitHub Actions or Cloudflare Workers?
• How often should the data be updated?
• Where should the information be stored?
• How can unnecessary writes be avoided?
• How can resource usage be reduced?
• How should errors be handled?
• How can the system remain modular?
• How can a new data source be added without breaking existing ones?
• Which parts should run automatically?
• Which parts should remain static?

I'm not simply trying to make something work.

I'm trying to understand why it works and what the best way to build it is.

And many times, that research ends up being more interesting than the original project.

---

🧠 The Result Isn't Just the Code

Every project leaves something behind.

It leaves knowledge.

An API I researched can become useful in another project.

An architecture I experimented with can become the foundation for another tool.

A problem I solved can save someone else hours of research.

And even a solution I discarded can be useful if it explains why I decided not to use it.

That's why I try to document not only the final result, but also the journey.

Question
   ↓
Research
   ↓
Experiments
   ↓
Problems
   ↓
Alternatives
   ↓
Decisions
   ↓
Implementation
   ↓
Result
   ↓
Learning

---

🌐 Everything Is Open

The projects in SolarisPKN-Labs are meant to be explored.

You can look at the code.

You can try the tools.

You can study the architecture.

You can modify whatever you want.

You can take an idea and turn it into your own project.

And if something you find here helps you solve a problem you were facing, then the experiment has already served another purpose.

You don't have to reproduce exactly what I built.

The idea is that you can start where I left off and take it even further.

---

🧪 A Laboratory in Constant Evolution

SolarisPKN-Labs isn't a finished project.

And it probably never will be.

As long as there is a question that makes me curious, there will probably be an experiment to try to answer it.

Some will work.

Some won't.

Some will become real tools.

Others will remain proof of concepts.

And some will probably teach me much more by failing than they ever could by succeeding.

That's all part of the laboratory.

---

🚀 Welcome to SolarisPKN-Labs

This is where ideas become experiments.

Where experiments become projects.

And where projects become knowledge that can be reused by others.

I don't just want to show you what I built.

I want to show you how I got there.

So explore, experiment, break things, learn, and if you find an idea that interests you...

build your own experiment.

🔬 SolarisPKN-Labs — Experiment. Learn. Build. Share.