DEV Community: Dominque Terry

Appaveli Mode: Shipping Every 7 Days Like Makaveli

Dominque Terry — Tue, 06 May 2025 15:11:30 +0000

Appaveli Mode: Shipping Every 7 Days Like Makaveli

How Tupac’s 7-Day Theory Album Inspired My Solo Developer Sprint Strategy

In 1996, Tupac recorded The Don Killuminati: The 7 Day Theory under the alias Makaveli—a raw, powerful album finished in just seven days. He wrote and recorded every track in three days and spent the next four mixing and mastering it. No excuses. No delays. Just focused output with lasting impact.

That energy inspired what I now call Appaveli Mode—a mindset where I build, refine, and ship something every 7 days as a solo developer.

Why the Name “Appaveli”?

By day, I’m the Director of Software Engineering at a sports tech company—leading teams, architecting scalable solutions, and driving delivery at the enterprise level.

But outside the 9–5, I step into Appaveli Mode—a solo developer mindset inspired by Tupac’s Makaveli era.

When I started releasing apps weekly, hip-hop legend Def Jef—a pioneering MC and producer known for his work in the golden era of hip-hop—gave me the nickname Appaveli, saying my work ethic reminded him of 2Pac during The 7 Day Theory era.

That comparison stuck — and so did the mindset.

Makaveli wasn’t just a stage name—it symbolized relentless focus, raw creative output, and urgency. I started channeling that same energy into how I build software.

Now I’m stepping back into that mode—taking a break from dating and shutting out distractions to focus entirely on execution and momentum. That’s why my company is named AppaveliTech Solutions: it’s not just about building apps. It’s about building legacy.

Why 7-Day Sprints?

Most dev teams run on 2-week sprints. But as a solo dev, that rhythm can feel sluggish and bloated. I needed something sharper—leaner.

That’s when I looked to Makaveli.

Inspired by Tupac’s 7-day album sprint, I built a structure where I start every Monday and ship by Sunday. One sprint. One outcome. No excuses.

Here’s why it works:

Urgency breeds momentum.
Decisions get made faster.
Perfection gives way to progress.

My Sprint Structure

Each sprint follows this cadence:

Day	Focus
Monday	Sprint planning + backlog grooming
Tuesday	Build core features
Wednesday	Development + small test cycles
Thursday	UI polish + refactor
Friday	Final dev + prep release notes
Saturday	Code freeze + test + deploy
Sunday	Ship + reflect + light grooming

Tools I use:

Jira for sprint planning and dev tasks
Todoist for personal routines and non-dev priorities

Staying in Appaveli Mode

Makaveli was more than a name—it was a creative philosophy. Lock in. Shut out distractions. Let the work speak.

I’m not just building software—I’m building like I’m running out of time. This mindset fuels consistency, intensity, and a higher standard.

What I’ve Shipped So Far

✅ Appaveli CLI: A code scaffolding tool for Java devs
✅ Sprint-based blog posts and retrospectives
✅ Backend features across my Apps and other internal tools
✅ Early release features for DAO and domain generation

Each week builds momentum. Each Sunday is a checkpoint.

Final Thoughts

Whether you're making albums or writing code—create with urgency. The Makaveli mindset taught me that done is better than perfect, and focused energy can change your output forever.

Don't wait. Create. Ship. Repeat.

Inspired by Makaveli. Built by Appaveli.

Appaveli Mode: Where Control Meets Code

Dominque Terry — Mon, 05 May 2025 13:31:42 +0000

“I don’t just write code. I build with intention. That’s Appaveli Mode.”

There’s a difference between shipping fast and building right. Between stacking libraries and understanding every line. I’ve been in this game long enough to see the hype cycles — new frameworks, new shortcuts, new silver bullets.

Most of them overpromise. Many rot.

That’s why I built Appaveli Mode — my personal philosophy for engineering with discipline, performance, and purpose.

*Why I Created Appaveli Mode
*
I got tired of bloated builds, fragile codebases, and watching devs surrender control to tools they barely understood.

I wanted freedom, not friction. Power, not padding.

So I stripped it all down.

Appaveli Mode isn’t about being anti-framework — it’s about being pro-clarity. Knowing exactly what’s under the hood. Owning every layer.

*The Core Tenets
*

Control Over Convenience
If I can write it myself, I will. I don’t let libraries decide my architecture. I do.
Native > Frameworks
Flutter? Useful. But when precision matters, I go Swift or Kotlin. I don’t fear the low-level. I own it.
Performance-First Thinking
Lightweight code. Direct APIs. Fast, clean, and scalable from day one.
Build Tools That Serve You
I don’t wait for better scaffolding — I make it. Appaveli CLI, AppaveliCore — all built to move how I move.

*What It Looks Like in Practice
*

My Java stack runs on AppaveliCore — no Spring, just pure, efficient code with JWT and encryption built in.
My mobile projects use native codebases when it counts. I don’t settle for lowest common denominators.
I automate the boring with Appaveli CLI, generating DAOs, domain classes, and utilities with zero fluff.

*Appaveli Mode in Real Life
*

It’s more than tech. Appaveli Mode is my 5AM gym grind. My nutrition game. My discipline when no one’s watching.
I don’t just apply it to code — it’s how I operate across life.

But there’s another layer — a deeper shift.

*The Appaveli Manifesto
*

Core Rules of Appaveli Mode

I release something every 7 days.
It doesn’t have to be a full app — a feature, a package, a tool, a blog post, or even a design counts.
My consistency is my therapy. My output is how I process.
I don’t chase, entertain, or invest in anything that drains me.
This season is sacred. My focus is my freedom.
I follow a daily commitment ritual.
A quote. A warm-up. A build session.
Like an MC in the booth — except my verses are code.
I turn pain into product.
I don’t suppress what I feel — I convert it into something that outlives the moment.
I’m not here to impress — I’m here to express.
I don’t need attention. I need execution. I bring heat, not hype.

Final Word

Appaveli Mode builds better software because it builds better engineers.

If you can’t rely on tools, you learn to rely on yourself. That’s the edge.

So if this resonates? Step in.
Start small.
Ditch one crutch. Write one thing yourself. Sharpen one part of your stack. Strengthen one part of your discipline.

That’s Appaveli Mode.

No gimmicks. Just growth.

Frameworks Aren’t the Problem — Our Dependency on Them Is

Dominque Terry — Thu, 24 Apr 2025 00:01:42 +0000

I often get pushback when I share my philosophy: I prefer native development for mobile apps and use core Java without Spring for the backend. Not because I think frameworks are terrible, quite the opposite, but because I think we’ve grown too dependent on them.

This isn’t a hot take or a rejection of modern development. It’s a reflection on where we are as an industry, and where I believe we should be more intentional.

Why I Go Native and Framework-Free

When I build mobile apps, I choose native: SwiftUI for iOS, Kotlin for Android. No Flutter, no cross-platform abstractions. Native gives me fine-grained control over performance, UI/UX, and system APIs. I don’t have to wait for the framework to catch up. I build what I need, when I need it.

On the backend, I use core Java with JDBC, and I built my own internal framework. It handles the essentials such as JWT auth, encrypted passwords, DAO generation without the bulk of Spring Boot or Hibernate. I get full visibility into what’s happening under the hood, and I can optimize for my own use cases, not someone else’s assumptions.

*I’m Not Anti-Framework
*
Let me be clear: I’m not against frameworks.

Spring Boot is incredible for bootstrapping projects. Flutter is a game-changer for MVPs. Laravel, React, Express, etc. All of these have saved time, enabled startups, and leveled the playing field for developers around the world.

But they are tools, not crutches.

The Problem: Blind Dependence

Too often, I see developers rely on frameworks they don’t truly understand. They ship fast, but they can’t explain what’s happening behind the scenes. They use annotations, DI containers, ORM layers and when something breaks, they’re lost in a maze of magic.

I’ve worked on codebases where performance bottlenecks were caused by lazy loading in Hibernate, or where a small Flutter plugin bug held back an entire release. In those moments, the abstraction becomes the problem. And without the foundational knowledge, debugging turns into guesswork.

*Build Your Own Tools (Even If You Don’t Use Them)
*
When I built my internal backend framework, it wasn’t because I wanted to reinvent the wheel. It was because I wanted to understand the wheel and how it’s built, where it breaks, and how to shape it for my needs. I engineered an open-source tool, appaveli-cli, which is a lightweight Java-based code generation tool that helps you scaffold DAO, Domain model classes, JDBC connections, and more. Appaveli-cli generates boilerplate code based on custom templates.

That experience gave me more confidence as an engineer than any framework could.

Even if you use Spring, write a barebones REST API in core Java. Even if you love Flutter, try building the same screen in native Swift or Kotlin. That knowledge pays dividends not just in code quality, but in leadership, architecture decisions, and developer growth.

*Intentional Engineering
*
Frameworks should be chosen with intention, not by default. They should accelerate what you already understand not replace your need to understand it.

I’m not saying everyone should ditch Spring Boot or rewrite their apps in native code. I’m saying: don’t forget how to code without them. Your career, your team, and your software will be better for it.

[Boost]

Dominque Terry — Wed, 16 Apr 2025 19:54:21 +0000

Dominque Terry

Apr 15 '25

🚀 Introducing Appaveli CLI: Instantly Generate Java DAO and Domain Classes from Your Terminal

#programming #java #webdev #softwareengineering

Comments 2

2 min read

🚀 Introducing Appaveli CLI: Instantly Generate Java DAO and Domain Classes from Your Terminal

Dominque Terry — Tue, 15 Apr 2025 00:08:42 +0000

As a Java engineer, one of the most repetitive tasks is writing boilerplate DAO and domain classes — especially when you’re not using heavy frameworks like Spring or Hibernate.

That’s why I built Appaveli CLI— a lightweight, Dart-powered command-line tool designed to automate the creation of Java DAO and domain classes. It’s clean, fast, and perfect for developers who want full control over their backend architecture without sacrificing productivity.

✨ What Is Appaveli CLI?
Appaveli CLI is a developer tool I engineered, crafted for solo developers, startups, or lean teams who don’t want to over-engineer their backend.

With a single command, Appaveli CLI scaffolds fully-structured Java domain and DAO classes that follow clean code principles and work with basic JDBC.

No Spring. No Hibernate. No magic. Just code you can trust and control.

💡 Why I Built It
I wanted a way to rapidly generate backend code that could plug directly into my custom lightweight Java framework, without the bloat of external libraries.

I also wanted to avoid writing the same getters, setters, and JDBC statements over and over, and over, again.

⚙️ How It Works
Once installed, you can use the CLI like this:

Generate a Java domain class

`java -jar target/appaveli-cli-jar-with-dependencies.jar generate-domain \
 - entity User \
 - package com.example.domain \
 - fields "id:int,username:String,email:String,active:boolean"`

Generate a matching DAO class with JDBC CRUD

java -jar target/appaveli-cli-jar-with-dependencies.jar generate-dao \
 - entity User \
 - package com.example.dao

It will create files:

🧠 What Gets Generated
User Domain:

package com.example.domain;

public class User {
    private int id;
    private String username;
    private String email;
    private boolean active;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public boolean getActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
    }


    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                "username='" + username + '\'' +
                "email='" + email + '\'' +
                "active='" + active + '\'' + '}';
    }
}

UserDao:

package com.example.dao;

import java.util.List;
import tech.appavelitech.domain.User;

public interface UserDao {
    void save(User entity);
    User findById(int id);
    List<User> findAll();
    void update(User entity);
    void delete(int id);
}

UserDaoImpl:

package com.example.dao;

import java.util.*;
import tech.appavelitech.domain.User;

public class UserDaoImpl implements UserDao {

    @Override
    public void save(User entity) {
        // TODO: Implement
    }

    @Override
    public User findById(int id) {
        // TODO: Implement
        return null;
    }

    @Override
    public List<User> findAll() {
        // TODO: Implement
        return new ArrayList<>();
    }

    @Override
    public void update(User entity) {
        // TODO: Implement
    }

    @Override
    public void delete(int id) {
        // TODO: Implement
    }
}

🛠️ How to Install

git clone https://github.com/appavelitech/appaveli-cli.git
cd appaveli-cli
mvn clean install

You can also follow the README on GitHub.

🗣️ Let’s Collaborate
If this sounds useful to you:

Drop a ⭐ on the GitHub repo
Try it out and give feedback
Hit me up if you’d like to contribute or suggest a feature