Building a Music Production Ecosystem Instead of Just Releasing Plugins

Most music tech projects stop at:

a plugin
a sample pack
a preset bank
a single release

I wanted to try building something larger.

Over the past months I’ve been building an interconnected ecosystem under TizWildin Entertainment focused on:

music production
DSP/plugin development
AI infrastructure
sound design systems
open-source tooling
sample ecosystems
public technical documentation
creative/developer infrastructure

A lot of the inspiration honestly comes from communities like this:

The producer/developer overlap is getting bigger every year, especially around:

Ableton workflows
DSP experimentation
AI-assisted production
custom tooling
modular infrastructure
experimental sound design systems
The Problem With Modern Creative Software

A lot of creative tooling right now feels fragmented.

Especially in music production.

You constantly see:

disposable AI wrappers
abandoned plugins
isolated workflows
closed ecosystems
trend-cycle software
no interoperability
no long-term architecture

Meanwhile the software that actually changed industries usually evolved into infrastructure:

FFmpeg
Blender
OBS
VLC
Godot
Linux

That’s the direction I’m trying to move toward.

FreeEQ8

One of the current projects is FreeEQ8 — a free/open-source 8-band EQ plugin built around:

workflow
usability
extensibility
transparent development
ecosystem integration

Repository:

FreeEQ8 GitHub

The bigger idea isn’t just “release another EQ.”

It’s proving independent developers can build legitimate audio infrastructure publicly.

ARC + Infrastructure-First AI

Another major focus is ARC, centered around modular AI infrastructure and interoperable systems.

A huge issue in AI right now is fragmentation:

shallow wrappers
disconnected systems
disposable tooling
no searchable architecture
no continuity between projects

The focus instead is:

reusable systems
indexed knowledge
public documentation
modular architecture
long-term infrastructure

AI as infrastructure instead of hype.

Why Public Documentation Matters

One thing massively underestimated by independent creators:

Indexed technical writing compounds over time.

Every public post:

creates searchable history
builds discoverability
strengthens authorship
increases ecosystem trust
improves cross-project association
creates long-tail visibility

That’s one reason platforms like Dev.to matter so much.

Documentation itself becomes infrastructure.

TizWildin Entertainment

TizWildin Entertainment HUB

TizWildin Entertainment acts as the umbrella connecting:

plugins
music production
AI systems
sample development
documentation
branding
experimental tooling
creative infrastructure

Instead of isolated releases, the ecosystem is designed so each project reinforces the others.

That compounding effect is the real goal.

opensource #musicproduction #audio #dsp #ai #plugin #sounddesign #ableton #bassmusic #webdev #gamedev

The Problem We Were Actually Solving

In our case, the problem wasn’t building a user-friendly interface or implementing a payment gateway; it was finding a way to bypass geographical restrictions imposed by major e-commerce platforms. We wanted to empower creators in Tanzania to reach a global audience without worrying about their online activities being monitored or blocked.

Our challenge was threefold: find a way to bypass geo-restrictions, ensure secure and reliable transactions, and mitigate the risks associated with doing business in a restricted environment.

What We Tried First (And Why It Failed)

Initially, we explored the use of Virtual Private Networks (VPNs) to mask our users’ IP addresses. However, this approach had a glaring flaw: it introduced significant latency, which was unacceptable for a real-time e-commerce platform. Moreover, VPNs often failed to mask IP addresses effectively, causing blocks and errors that compromised the entire system. We also tried proxy servers, but they too suffered from performance issues and became a single point of failure.

Our next attempt was to implement a complex setup of load balancers and content delivery networks (CDNs) to distribute traffic and improve resilience. Although this helped mitigate some issues, it added unnecessary complexity to the system, increased costs, and did not fully address the core problem.

The Architecture Decision

After weeks of experimentation and research, we decided to take a different approach. We chose to build our e-commerce platform on a decentralized architecture, leveraging blockchain technology to ensure secure and transparent transactions, as well as to provide a tamper-proof record of all transactions.

We also opted for a microservices-based architecture, separating the payment processing, inventory management, and order fulfillment components into distinct, loosely-coupled services. This allowed us to scale each component independently, improve fault tolerance, and reduce the blast radius in case of failures.

To handle geo-restrictions, we implemented a smart routing mechanism that dynamically redirected traffic to avoid blacklisted IP addresses. We also used a geoproxy network to mask our users’ IP addresses and enable them to access the platform without being blocked.

What The Numbers Said After

Our new architecture was a game-changer. The latency issues that plagued our previous attempts with VPNs and proxy servers disappeared almost entirely, with an average response time of under 200ms. The system’s availability and uptime improved significantly, with an uptime of 99.99% over a 30-day period.

We also observed a substantial reduction in errors related to geo-restrictions, with a 30% decrease in blocked transactions and a 25% decrease in failed payments. The transaction throughput increased by 40%, allowing us to process more online sales without adding additional infrastructure.

What I Would Do Differently

If I had to do it all over again, I would prioritize even more the importance of testing in a production-like environment before deploying the system in a restricted country. We learned the hard way that a well-crafted proof-of-concept in a controlled lab environment can fail spectacularly in the real world.

I would also consider adopting a more gradual, incremental approach to building the system, with a focus on iteratively refining and improving each component rather than trying to launch a complete, monolithic system. This would have allowed us to catch errors and bottlenecks earlier in the development cycle and made the system more robust and reliable from the start.

Native Module Integration: Why Is It So Hard?

Cross-platform development has gained massive popularity in recent years, especially thanks to frameworks like Flutter. Being able to develop apps for both iOS and Android with a single codebase shortens development cycles and reduces costs. However, behind this bright picture lies the unexpected challenges brought by native module integration. This situation, which I have encountered countless times in my own mobile apps and client projects, can cause the development process to turn into a literal “black hole.”

In this article, I will share my experiences on why this integration process is so complex, where I got stuck, and whether it is worth paying this price. Specifically, we will take a detailed look at the native integration issues I experienced while developing an Android spam blocker app.

Challenges of Accessing Native Features

Cross-platform frameworks allow us to easily use many native features thanks to the abstraction layer they provide. However, things get complicated when we need to access a specific native library or a feature that the framework does not directly support. At this point, we need to build bridges to establish communication between platforms. In Flutter, these bridges are usually built using Method Channels.

Method Channels enable data exchange between Dart code and native (Java/Kotlin or Objective-C/Swift) code. While they are very useful for simple tasks like showing a Toast message, transferring data and managing errors over this channel can become highly tedious when accessing more complex native APIs or integrating third-party native SDKs. In particular, managing platform-specific callbacks, synchronizing asynchronous operations, and correctly converting data types can consume a significant amount of time.

ℹ️ Method Channel Example

A simple Method Channel usage might look like this:

// Dart side
static const platform = MethodChannel('com.example.myapp/native_utils');

Future<String> getNativeGreeting() async {
  try {
    final String result = await platform.invokeMethod('getNativeGreeting');
    return result;
  } on PlatformException catch (e) {
    print("Error: ${e.message}");
    return "An error occurred";
  }
}

// Kotlin side (Android)
override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.example.myapp/native_utils")
        .setMethodCallHandler { call, result ->
            if (call.method == "getNativeGreeting") {
                val greeting = "Hello from the native world!"
                result.success(greeting)
            } else {
                result.notImplemented()
            }
        }
}

While this simple example shows the basics of communication, things may not go this smoothly in the real world.

Native SDK Integration: Dependency Hell

Integrating third-party native SDKs into our project is usually the most time-consuming and frustrating part. Every SDK has its own dependencies, build configurations, and platform-specific requirements. When integrating an SDK into Android, messing with build.gradle files, dealing with compatibility issues between different Gradle plugins, and sometimes even struggling with missing or incorrect information in the SDK’s own documentation becomes inevitable.

For example, when integrating an ad SDK, you need to download, configure, and include the SDK for both Android and iOS. In this process, even understanding which versions of the SDK are compatible with which Android SDK versions can be a research topic on its own. These dependency conflicts not only prolong the build time of the project but can also sometimes cause the app to run unstably or crash.

Performance and Optimization: Overlooked Details

Although performance is one of the biggest promises of cross-platform development, native module integration can jeopardize this promise. Heavy data transfers through Method Channels can lead to performance bottlenecks, especially with large datasets or frequently called functions. Every call requires a “context switch” between platforms, which introduces overhead.

Once, I needed to implement real-time location tracking in an Android app. Flutter’s geolocator package was not sufficient for this task, so I had to develop a native solution and call it via Method Channel. However, because I was receiving location updates very frequently (10-15 times per second), the Method Channel calls started blocking the main thread. This caused the user interface to freeze and rendered the app unusable.

⚠️ Solving Performance Issues

To solve such performance issues, you generally need to follow these strategies:

1. Reduce Data Transmission: Send only the data that is absolutely necessary.
2. Manage Asynchronous Operations: Run operations in the background on the native side and report results to the Dart side less frequently.
3. Optimize Callback Mechanisms: Use platform-specific event channels or broadcast receivers if necessary.
4. Optimize Native Code: Pay attention to writing the native module itself in the most performant way possible.

When faced with such issues, instead of trying to optimize the native code directly for performance, I usually focused on developing a smarter data processing strategy on the Dart side. For example, by filtering location updates (e.g., sending an update only if a certain distance has been covered or a certain amount of time has passed), I reduced the load on the main thread.

Platform-Specific Debugging

One of the most challenging aspects of native module integration is the debugging process. When an issue occurs, you need to investigate deeply to understand which side the error is on. Is the error in the Dart code? In the Method Channel communication? Or in the native code itself? To make this distinction, you might need to use the debugging tools of both platforms (Android Studio’s debugger, Xcode’s debugger, and the Dart debugger) simultaneously.

Once, while doing a payment integration, callbacks from a native SDK were not triggering at all. It took days to find the issue. The problem was a threading issue on the native side. The SDK was performing an operation in its own background thread and was supposed to report the result of this operation to the main UI thread, but because this notification was not done properly, the Dart side never received the information. Such situations are quite common, especially when using complex SDKs or deep native APIs.

// Native (Kotlin) debugging example
// Let's assume there is a threading issue in this code
override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.example.myapp/payment")
        .setMethodCallHandler { call, result ->
            if (call.method == "processPayment") {
                // This operation might take a long time and should be done in the background
                Thread {
                    val paymentResult = performComplexPaymentOperation()
                    // ERROR: This part should be on the UI thread but is executed on another thread.
                    // Therefore, the Dart side cannot receive the result.
                    result.success(paymentResult)
                }.start()
            } else {
                result.notImplemented()
            }
        }
}

fun performComplexPaymentOperation(): String {
    // Real payment operations...
    Thread.sleep(5000) // Simulation
    return "Payment Successful"
}

While debugging this code, it was necessary to use the debugger to see that the Thread.sleep(5000) line did not block the main thread, but the result.success call was not made on the correct thread.

Cost Analysis: Time, Money, and Sanity

Native module integration is not just a technical challenge, but also a significant cost item. Prolonged development times, extra debugging efforts, and sometimes requiring platform-specific expertise can significantly increase the project’s budget. Especially for small teams or startups, these additional costs may not be sustainable.

For example, in a project where we needed to access a native device feature (such as a custom hardware sensor), writing a custom native module for this feature and integrating it with Flutter could require weeks of work from a single developer. Every problem encountered during this process means a new learning curve and a loss of time.

💡 Alternative Approaches

To avoid the challenges of native module integration, you can consider these alternatives:

• Using Existing Packages: Search for well-written and maintained existing Flutter packages for the feature you need.
• Web Technology Solutions: If possible, consider Progressive Web App (PWA) or WebView-based solutions to reduce the need for native features.
• Platform-Specific Apps: If the project requirements demand highly specific native features, it might make more sense to develop platform-specific apps from the start.

Conclusion: When to Choose Native Integration?

The productivity advantages offered by cross-platform development are undeniable. However, the challenges and costs of native module integration should not be ignored. In my experience, it is important to ask the following questions before resorting to native integration:

• Is there an existing, reliable Flutter package already written for this feature?
• Is it absolutely necessary for this feature to be native, or can it be solved with web technologies?
• Is the time and cost to be spent on this integration acceptable within the project’s overall budget and timeline?
• Does the team have sufficient experience in platform-specific native development?

If the answers to these questions are “yes,” then native module integration can be a part of your project. However, remember to be patient when starting this process, make good use of debugging tools, and be prepared for potential challenges. Sometimes, the convenience offered by cross-platform must be balanced against the complexity introduced by native integration.

One of the greatest lessons I learned in this process was that the urge to “do everything in a single codebase” sometimes makes things unnecessarily difficult. Every technology has its own strengths and weaknesses. The important thing is to find the balance that best fits the project’s requirements.

Here is my prediction: AI-native apps will swallow the web. Not in ten years, but before 2026 is over – and the transition is already underway.

MCP – the Model Context Protocol Anthropic introduced in November 2024 – has already been adopted by Google, Microsoft, and the W3C. Every major LLM speaks it. The browser vendors are integrating it directly: WebMCP is a draft at the W3C with an early implementation already shipped in Chrome. The naming is still loose – agentic apps, agent-native apps, in-chat applications – but the category is real.

MCP is going to swallow the web just as the web did the desktop. AI-native apps (or whatever they come to be called) are the next web.

MCP is going to swallow the web just as the web did the desktop.

The web we have will not vanish. It will be subsumed. Before 2026 is over, AI-native-only will be a viable path: a product that exists as MCP-callable tools and machine-readable state, with no browser, no mobile app, no human-facing surface – and a real customer base. The agents are already there. The protocol is in place.

Users will pull this forward because the AI becomes both the access point and the source of enrichment. One conversation instead of a dozen tabs. The AI knows the sneakers, knows the cars, knows how you like to travel. Like the whole of the web, the merchant’s site becomes raw material.

Like the whole of the web, the merchant’s site becomes raw material.

This sounds extreme, but it is also already underway. Shopify has built a Storefront MCP for AI-mediated commerce. AI-native apps are bringing back the constraints that shaped the early web – stateless protocols, server-side logic, forms for input – for a new class of consumer.

It is because of this seismic shift that our client work has reorganized around it, and it is why we just published a new cluster of MCP guides – eight pieces written for product leaders deciding whether and how to be present inside leading AI clients. We start with the working vocabulary the category has not yet settled, lay out a strategic decision framework that determines posture, set the client comparison matrix for choosing where to ship first, walk through the embedding-types breakdown that distinguishes read-only from actions from agent-resident, frame the auth and security expectations enterprise procurement actually wants, work the build-vs-buy economics of in-house engineering versus a development partner, give you a partner evaluation checklist for a category too young for the usual portfolio signals, and tie it together in a hub guide. The category is moving fast enough that vague advice ages quickly. These guides are specific, current, and built to be useful for the decisions our clients are making right now.

AI-native apps will swallow the web.

Originally published at launchdayadvisors.com

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

I picked the wrong Gemma 4 model. Twice.

A 72-hour speedrun through E2B, E4B, and 31B-via-cloud — and the decision tree I wish I’d had on hour one.

Three days before the deadline, I sat down to build a multimodal Gemma 4 app for the challenge. I’d already decided which variant I’d use: E4B, because bigger is better, right?

I shipped on E4B. Then I shipped on E2B. Then I added OpenRouter’s 31B as a third option and let users pick.

Here is what each move cost me, what I learned, and the decision tree I’d hand to anyone starting today.

Quick context before the story: Gemma 4 is Google’s open AI model family — Google publishes the model weights for free, you download them and run them yourself, no API key required. It ships in four sizes; the two smallest (E2B and E4B) are tiny enough to run inside a browser tab via WebGPU (the browser’s graphics-card API), while the 31B Dense and 26B MoE variants are server-class. All four are multimodal — they read images and audio, not just text. That last part is why a real app inside a browser tab is suddenly possible: the model that categorizes your text transactions can also read a photo of a receipt, with no extra download.

The setup

The app — a private personal-finance dashboard that runs Gemma 4 entirely in the browser — needed three things from the model:

1. Categorize transaction text (“STARBUCKS #1234” → restaurants).
2. Read paper receipts (image → merchant, amount, date).
3. Answer free-form questions about a year of statements in one prompt.

So: multimodal, long context, must run client-side (in the user’s browser, not on a server I rent). That’s how I narrowed to the E-series Gemma 4 variants in the first place. The 31B Dense and 26B MoE were never candidates — they’re just too big for a browser tab. That left E2B (~1.5 GB on disk once quantized) and E4B (~2.5 GB).

I picked E4B without thinking. That was mistake #1.

Pick #1: E4B, because “bigger is better”

E4B is the larger of the two browser-tier Gemma 4 models. It scored higher on every benchmark in Google’s release. I figured the extra GB of weights would buy me cleaner categorization and smarter answers, and I’d ship a more impressive demo.

It worked. Categorization was crisp. The chat panel handled “which restaurant did I visit the most?” without breaking a sweat. I wrote the entire project around the assumption that E4B was the right call and shipped a first cut.

Then a user opened the deployed link.

Cold-load was a 2.5 GB download. On a normal connection that’s somewhere between three and ten minutes of staring at a progress bar before the app does anything. My first beta tester typed “is there other solution its time consuming” before the model had finished downloading.

I’d optimized for what the model could do and ignored what the user would experience before it did anything. That’s mistake #1.

Pick #2: E2B, because respecting people’s bandwidth is part of the product

E2B is the smaller browser variant. Same multimodal capability. Same 128K context window (meaning it can read about a 300-page book in one prompt — important if you want to ask questions across a whole year of bank statements). Same compression. About 40% less to download. Slightly thinner reasoning on multi-step questions.

The swap was a one-line code change:

// before
export const MODEL_ID = "onnx-community/gemma-4-E4B-it-ONNX";

// after
export const MODEL_ID = "onnx-community/gemma-4-E2B-it-ONNX";

The interesting thing wasn’t the code — it was the trade-off math.

The “thinner reasoning” I was worried about cost me maybe 5–10% of categorization accuracy on long-tail merchants. That’s a tiny gap. The “40% less to download” turned a five-minute wait into a two-minute wait, which is the difference between a user trying your app and a user closing the tab.

The general lesson, written down where I won’t forget it:

The smaller capable model usually wins. Cold-load time is the most expensive thing your app does. Trim it ruthlessly.

This held even when the larger model would have produced marginally better outputs. The output gap was invisible to the user. The download gap was the only thing they could see.

That should have been the end of it. It wasn’t.

Pick #3: 31B in the cloud, because some users won’t wait at all

The same user came back: “no user wait for loading 1.5 gb 2.5 gb will add selection and add openrouter selection also.”

They were right. Even E2B’s ~1.5 GB is a wall for someone on a phone, on a flaky connection, or just trying a demo for thirty seconds to decide if it’s worth more attention. The honest answer was that the right model depends on who’s using the app right now.

So I added a third option: Gemma 4 31B Dense via OpenRouter’s free tier. OpenRouter is a service that lets you call lots of different AI models through one API. They expose Gemma 4 31B on a free tier — no credit card, no download. Zero download. Highest quality of the three. The trade-off is brutal and has to be explicit: your prompts and receipt photos are sent to a third-party server for inference. Privacy goes from “on-device, never uploaded” to “trust OpenRouter’s logs policy.”

Two practical things bit me adding the cloud path:

The free tier is 16 requests per minute. My categorization loop fired one API request per transaction. For a 71-row sample statement, that hit the rate limit in three seconds. Fix: batch up to 25 transactions per prompt — instead of asking the model “what category is this?” 71 times, ask it “here are 25 transactions, classify each” three times. With Gemma 4’s 128K context, this is free — the model handles a whole statement in one shot, and your three batched requests stay comfortably under any free-tier limit.

// One prompt, 25 transactions, one response. Free-tier safe.
const prompt = `Classify each transaction with one category from this list.
Output ONE LINE per transaction as "<n>. <category>".

${chunk.map((t, i) => `${i + 1}. ${t.rawDescription} (${t.amount})`).join("n")}`;

The model ID format is strict. OpenRouter wants google/gemma-4-31b-it:free (the :free suffix matters). Hit the /v1/models endpoint with your key once to confirm the exact ID before you spend an hour debugging 400 errors.

The decision tree I wish I’d had

Here it is, no theory, just the thing I’d tape to my wall:

You can stop here. Most projects only need the first two rows.

The real answer: don’t pick. Let the user pick.

What I actually shipped in the end was a model picker. Three cards. Each one shows: name, download size, where inference happens (on-device vs cloud), and one sentence on the trade-off.

The picker doesn’t avoid the decision; it moves it to the person who has the right information to make it. The product manager in me cringed at exposing a “model selection” UI to consumer users. The engineer in me realized that the alternative — picking one model for everyone — meant always being wrong for somebody.

“Intentional model selection” is one of the Gemma 4 Challenge’s judging criteria. I’d bet that on most submissions, that intention lives in the writeup, not in the product. In mine, it lives in the user’s first click.

If you’re starting a Gemma 4 build right now, I’d save yourself the 72 hours and start there.

The app is PocketCFO — open source, MIT. Drop a CSV bank statement and pick a model. Built for the Gemma 4 Challenge. Live demo · code.

Tags: #gemmachallenge #ai #webgpu #javascript

Just over a month ago, we kicked off #100DaysofSolana, a program designed to walk hackers from “I’ve heard of blockchain” to “I built something on it.” As an introduction to Solana, we spent Epoch 1 working through the basics and giving all of our participants the chance to get comfortable with concepts that, for most developers, have always lived behind a wall of jargon.

As we get ready for Epoch 2, we invite you to learn about the opportunity and consider joining us: The beauty of #100DaysofSolana is that you can do just that. Start today. Walk away in another 70 days with a new set of skills, a new understanding of web3, and an understanding of how to build on Solana’s blockchain.

What is Solana?

Solana is a blockchain platform – part of the broader web3 ecosystem that also includes Bitcoin and Ethereum. (If you’re not familiar, a quick explanation on web3 can be found here, and you can explore more in DEV’s web3 tag. And here’s a blockchain explanation too.)

What makes Solana different is speed and cost. Blockchain platforms have struggled with both; at one point, Bitcoin’s annual electricity consumption was higher than the country of Switzerland. Solana was built to make everyday transactions practical rather than purely theoretical – which is what makes it a useful place to actually build.

The platform also supports small programs that run on-chain when a transaction calls for them. They are the building blocks for some of the most interesting work happening on the chain.

Why #100DaysofSolana Right Now?

Web3 is still in its youth as a concept and a practice. And we often get the question from next gen developers who are still learning, “How can I learn more?” The honest answer is that the path to learning in this one case is a bit more challenging than most: A lot of the available material – including Solana’s own documentation – is written for people who already understand it, and the existing community has a vernacular all its own, where familiar words can mean unfamiliar things. A developer who is curious about web3 can spend a long time bouncing off resources that assume they already “get it” to a certain extent.

We wanted to close that gap and #100DaysofSolana was developed to help do just that.

The program assumes a participant already knows the world of web and mobile development, and can bridge from there into Solana. For instance, we started off our program by aligning the idea of Solana with the idea of a global database. And then we worked through accessing and reading data from it as you would learn how to find and read data in a database you are familiar with navigating.

Solana is exactly the right partner for this kind of program.

• Compared with earlier blockchains, it is faster and more affordable to use, which makes it practical for real applications rather than purely theoretical ones.
• It hosts a meaningful share of stablecoins – digital currencies pegged to traditional ones – and the things people are building on it span payments, digital assets, loyalty and incentive systems, and ownership models with no obvious Web2 parallel.
• The platform is still early enough that developers working with it now have a real chance of being part of figuring out what works.

And 100 days, rather than a weekend or a month, is deliberate. Learning Solana isn’t just learning a new library…it is a different mental model so you need more than a few days to really wrap your mind around it and let it sink in. Smart contracts, on-chain data, token economics, and digital assets don’t map cleanly onto anything most developers have built before, so that shift takes time. The career math lines up too: as AI reshapes entry-level software work, picking up a specialization is one of the most useful things an early-career developer can do, and a hundred days of hands-on Solana experience is something concrete to point to.

What #100DaysofSolana Looks Like for Participants

We built #100DaysofSolana with our participants in mind, and the belief that a little bit every day goes a long way to learning new skills. Every week follows a pattern that’s designed to be flexible (with even more flexibility on the weekend because we know you need rest).

• Monday – Try: A new topic gets introduced.
• Tuesday – Build: Participants put hands on the keyboard and put the idea into practice.
• Thursday – Stretch: A deeper challenge that pushes the week’s concept further.
• Saturday – Document: Participants write about what they’ve learned on DEV.
• Sunday – Amplify: Engage with other participants on DEV or social platforms and see what everyone else is learning and trying out.

The structure is built so no participant has to complete all 100 days perfectly to benefit. A developer who does just Try and Build in a given week still walks away with enough to understand the topic and move on. The Saturday and Sunday rhythm – write it down, share it – borrows from the way working developers actually build expertise: in public, with feedback.

We just finished Epoch 1 where we focused on the fundamentals: where Solana data lives, how to read it, and how to get oriented in the ecosystem. The goal was less about writing code and more about building familiarity – making the platform feel less like a black box and more like something a developer can actually navigate.

We’re just getting started with Epoch 2.

What’s Next for #100DaysofSolana in Epoch 2

Next we are going to move from reading to writing. Participants start manipulating data on Solana, beginning with concepts like token economics, incentives, and digital assets. The first challenge asks a deliberately concrete question: What would it look like to build a tokenized reward system on Solana, like a supermarket loyalty card? Or a Reddit-style karma system?

Those questions are also the door into the concept of NFTs, which, despite their reputation, aren’t limited to expensive jpegs of memes and monkeys. An NFT is a unique token recorded on a blockchain, usually with metadata that points to or describes a specific digital or real-world item, and the range of practical uses is much wider than the headlines suggest. This is the point in the program where the learning starts to feel applied. Participants are no longer just reading from the chain. They’re putting things on it.

Where #100DaysofSolana Goes Next

Epoch 3 moves into writing programs on Solana directly. This is where the foundational concepts from the first two epochs become tools, and participants start building software that runs on-chain.

Epoch 4 is shipping and exploring. The structure loosens, the projects get more independent, and participants get the chance to combine everything they’ve learned into something of their own design.

By the end of the 100 days, the goal is to have moved a hacker from curiosity about Web3 to confidence in actually building on it.

There is no shortage of opinions about Web3. But there is a need for patient, sequenced learning material that gets a working developer from the outside of the conversation to the inside without asking them to take anything on faith. #100DaysofSolana is built to be that material: a guided path, paced for someone learning from scratch, designed around the assumption that the best way to understand any new technology is to spend enough time with it to form an actual opinion.

Hackers can follow along, join in late, or come back at any epoch. The program is built to accommodate all of those. More information, and signup, is available at https://mlh.link/solana-100. You can also explore our DEV content for the program here: https://dev.to/100daysofsolana

FAQ

Do I need to know anything about Solana or Web3 to join 100 Days of Solana?

No. The program is built for developers who already know web or mobile development but have never worked on a blockchain. Epoch 1 covers the fundamentals from scratch – what Solana is, where its data lives, and how to read from it.

Can I join now that the program is already underway?

Yes. The weekly structure is designed to accommodate people joining late, taking breaks, or moving at their own pace. A developer who picks it up partway through can still go back and work through earlier epoch material on their own time.

How much time does 100 Days of Solana take per week?

The week has five themed days (Try, Build, Stretch, Document, Amplify), but no participant is expected to do all five every week. Completing just Try and Build is enough to walk away with the week’s concept and move on to the next one.

What do I need to participate?

A computer, a code editor, and a Solana wallet for the on-chain challenges. The program guides participants through wallet setup as part of Epoch 1.

Is 100 Days of Solana free?

Yes.

Do I need to buy SOL to participate?

No, you don’t need to buy SOL. Just like Web2 development, Solana gives you the equivalent of a dev environment where you can practice. It’s called devnet and you can request free devnet SOL from a system called the faucet.

Why Solana, and not Ethereum or Bitcoin?

Solana was built to be faster and cheaper to operate than earlier blockchains, which makes it practical for everyday transactions rather than purely theoretical ones. The program is specifically Solana-focused, but most of the underlying concepts – smart contracts, on-chain data, token economics – apply broadly across Web3.

What happens after the 100 days?

Epoch 4 is shipping and exploring – the structure loosens and participants are given room to combine what they’ve learned into independent projects. The work and writing produced during the program become portfolio pieces showing real, hands-on Solana experience.

I recently shipped TinyHab, an ADHD-friendly habit tracker for iPhone.

The idea was simple: most habit apps look clean on day one, but they become stressful the moment you miss a day. I wanted to build something calmer. Something focused on today, small wins, reminders that actually work, and a recovery path when routines fall apart.

So I built the full product myself: the iOS app, backend, landing page, admin panel, push notifications, subscriptions, App Store setup, and the release process.

App Store link: https://apps.apple.com/app/tinyhab-adhd-habit-tracker/id6770136917

The Stack

TinyHab is built with:

• Flutter for the iOS app
• Django for the backend API and admin panel
• PostgreSQL for the database
• Firebase Auth / Cloud Messaging for auth support and push notifications
• Apple Sign In and Google Sign In
• RevenueCat for App Store subscriptions
• Dokploy + Docker for deployment
• Django Admin for managing users, campaigns, tokens, and notification logs

I like this stack because it lets me move fast without giving up structure. Flutter gave me a clean app surface, Django gave me a reliable backend and admin panel, and Firebase/RevenueCat handled the parts that are painful to rebuild from scratch.

What I Wanted the App to Feel Like

TinyHab is not trying to be a loud productivity app.

I wanted the app to feel quiet and practical. The core flow is:

1. Open the app
2. See what matters today
3. Mark a habit done
4. Move on

No guilt-heavy streak system. No overwhelming dashboard. No complicated setup before the user gets value.

The app includes habit scheduling, daily progress, reminders, insights, profile settings, App Store subscriptions, home screen widgets, and a small admin system behind the scenes.

The Hardest Part Was Not the UI

The hardest parts were the production details.

Apple Sign In had to work from both login and registration. Push notification tokens had to be saved correctly after permission was granted. Firebase Cloud Messaging had to be connected to APNs correctly. App Store subscriptions had to sync with the backend. The backend needed enough logging so I could see what actually happened when something failed.

One example: push notifications were not just “install Firebase and done.” I had to handle APNs token timing on iOS, register the FCM token with the backend, store device tokens per user, connect Firebase to the correct APNs key, and test direct backend sends from production.

When it finally worked, I could send a notification from the admin panel and see it arrive instantly on the device. That was a good moment.

App Store Review Was a Real Test

The first submission did not go through.

Apple rejected the app because the Continue with Apple button was unresponsive in one flow. The login screen was fine, but the registration screen had a button that looked ready and was not wired to the Apple auth flow yet.

That was a useful reminder: App Review will test the product like a real user, and any visible control needs to work.

I fixed the Apple Sign In flow, checked the release build again, fixed a few production issues around push token registration and profile plan display, rebuilt the IPA, uploaded a new build, and resubmitted.

The next review passed.

What the Backend Handles

The Django backend is not just a simple auth API.

It handles:

• User accounts and auth sessions
• Habit CRUD
• Habit completions
• Reminder settings
• Device notification tokens
• Push notification campaigns
• Push notification logs
• Daily summaries
• Subscription state
• Legal documents
• Landing page content
• Admin workflows

I also added admin tooling so I can inspect device tokens, see failed push messages, send campaigns, and debug real user issues without guessing.

That saved a lot of time during launch.

What I Learned

Shipping a real mobile app is mostly about the small details that do not show up in screenshots.

The UI matters, but production readiness matters more:

• Does Apple Sign In work in every auth flow?
• Does the app still work after a fresh install?
• Are push tokens saved after permission changes?
• Can the backend send to the latest device token?
• Can I see why a push failed?
• Does the App Store build match the version I think I uploaded?
• Does the landing page point to the live App Store URL?

None of these are exciting individually, but together they decide whether the app feels real.

Why I Built TinyHab

I built TinyHab because I wanted a habit tracker that is easier to come back to after a bad day.

Most habit apps are optimized for perfect consistency. TinyHab is designed for imperfect consistency: missed days, low energy, friction, and restarting without shame.

That product direction shaped both the design and the engineering. The app needed to be simple on the surface, but reliable underneath.

Final Thoughts

This was a full-stack mobile build from zero to App Store approval.

I worked across Flutter, Django, Firebase, APNs, RevenueCat, Docker deployment, admin tooling, and App Store Connect. The result is now live on the App Store, and I am continuing to improve it based on real usage.

If you are building a mobile app, my biggest advice is simple: test the boring production flows early. Login, registration, push notifications, subscriptions, release builds, and admin visibility are where most launch problems hide.

TinyHab is live here:

https://apps.apple.com/app/tinyhab-adhd-habit-tracker/id6770136917