Why Your Custom CSS Breaks in Dumpster Rental Systems
You paste a CSS rule into your booking software, save it, and reload the page. Nothing changes. You check the page source and your rule is sitting right there, exactly as you wrote it. So you write it again, more specific this time, with an !important on the end. Still nothing.
Dumpster Rental Systems runs a find-and-replace over your custom code every time you hit save. It is looking for its own settings tokens, and the matcher is loose enough to eat ordinary CSS. If your custom dumpster rental systems CSS uses square brackets in a selector, the code sitting in your editor may no longer be the code you typed.
Quick Answer · TL;DR
DRS replaces bracketed tokens in custom code at save time, and it cannot reliably tell your CSS apart from its own settings syntax.
- DRS supports settings tokens written in square brackets and swaps them for real values when you save.
- A bare attribute selector like
[id]or[disabled]looks like a token to that matcher. - The rule gets rewritten into something invalid, and browsers discard invalid selectors silently.
- The damage happens on save, not on render, so your original is gone the moment you click the button.
- Selectors with an operator inside the brackets survive, which is why the problem looks random.
- Rewrite the selector without brackets and it works normally.
- Confirm a rule parsed by checking the browser stylesheet, never by reading the editor.
The Symptom
Your CSS Is on the Page and the Browser Is Ignoring It
This one cost me most of an afternoon before I worked out what was happening, so it is worth writing down properly.
I was tidying up the cart page on a dumpster rental booking site. The cart is built from 3 stacked tables that all share a class name. 2 of them hold content and carry an ID. The third is an invisible spacer wrapped around a single hidden input, and it has no ID at all. I wanted a card background and a border on the 2 content tables and nothing on the spacer, so I wrote the obvious thing.
.cart_table_container:not([id]) { border: 0 !important; }Saved it. Reloaded the cart. The spacer still had its border. I assumed a specificity fight with the platform stylesheet, so I opened developer tools, and the rule was not in the computed styles at all. Not overridden, not struck through. Absent.
Then I viewed the page source, and there it was. The exact text I had written, sitting in the head of the document. A rule that is present in the HTML but missing from the browser’s stylesheet means only one thing, which is that the browser read it and threw it away.
The Cause
What DRS Actually Stored
I reopened the custom code editor and read the line again, slowly. It was not what I wrote.
.cart_table_container:not(101) { border: 0 !important; }[id] had become 101.
DRS lets you drop dynamic values into custom code using a token syntax written in square brackets, along the lines of [setting:name]. On save it walks your code looking for those tokens and substitutes the stored value. The matcher behind that feature is not strict about what a token looks like, so a bare word inside brackets qualifies. It found [id], decided it was a setting, looked up a value, and wrote 101 in its place.
:not(101) is not a valid selector. The CSS specification requires a browser to discard a rule it cannot parse, and it does so without a console error, because silently dropping unknown syntax is how CSS stays forward compatible. So the rule vanished quietly, and every assumption I made after that was built on a rule that no longer existed.
The expensive part is not the bug. It is that the editor shows you the corrupted version and your eye slides straight past it, because you know what you wrote. I reopened that panel 3 times before I saw the number sitting there. When a platform can rewrite your input, reading your code back stops being a formality and becomes the thing you have to do most carefully.
Why It Looks Random
Some Bracket Selectors Survive and Some Do Not
Here is why this is so hard to pin down. Plenty of bracket selectors work perfectly well in DRS, which is exactly what stops you suspecting the platform. The dividing line is whether there is an operator inside the brackets.
| Selector | What happens | Why |
|---|---|---|
[id], [disabled], [hidden] | Destroyed on save | A bare word in brackets reads as a settings token |
input[type=button] | Survives | The = stops the token matcher |
body[class^="ers_page"] | Survives | The ^= stops the token matcher |
a[href$=".pdf"] | Survives | The $= stops the token matcher |
The platform’s own stylesheets are full of the second kind. So you look at how DRS writes its CSS, see bracket selectors everywhere, conclude they are supported, and never suspect the one you wrote is different in a way that matters.
This applies to every custom code field, not just CSS
The replacement runs over anything you save in the custom code panels, which includes JavaScript in the body sections. An array index like matches[1] or a loop variable like items[i] is a bare word or number inside brackets, and it is exposed to exactly the same matcher. Write JavaScript for these fields without square brackets. Use collection.item(i) rather than indexing, and pull strings apart with indexOf and substring rather than a regular expression containing a character class.
The Fix
Write the Same Selector Without Brackets
Once you know the constraint, this is rarely hard. Almost any bare attribute selector can be rewritten as a class, an ID, or a chain of exclusions.
In the cart case I knew all 3 tables. 2 had IDs I could name, and the third was the one I wanted to leave alone. So instead of asking for the element with no ID, I excluded the 2 that had one.
.cart_table_container:not(#bx1):not(#bx3) { border: 0 !important; }Same target, same result, no brackets to eat. If you are matching something dynamic and cannot enumerate it, the other route is to add your own class with a line of JavaScript and style that class instead, which keeps the CSS side clean.
Verify it parsed, do not trust the editor
This is the habit worth building, because it turns an afternoon into a few seconds. Load a real page on the booking site, open the browser console, and ask the browser which rules it actually understood. If your selector comes back, it parsed. If nothing comes back while the text is plainly visible in the page source, it was mangled.
for (const sheet of document.styleSheets) {
try {
for (const rule of sheet.cssRules) {
if (rule.selectorText && /cart_table_container/.test(rule.selectorText)) {
console.log(rule.selectorText);
}
}
} catch (e) {}
}The try is there because stylesheets served from another domain throw when you read their rules, and you want the loop to carry on past them rather than stop on the first one.
Do This Now
A 10 Minute Audit of Your Booking Site
- Open every custom code panel and search for an opening square bracket.
- For each hit, check whether there is an operator inside the brackets. No operator means it is already broken, or will break on your next save.
- Rewrite those selectors using classes, IDs, or chained
:not()exclusions. - Check your custom JavaScript for array indexing and rewrite it without brackets.
- Load a real page and confirm each rule parsed using the console loop above.
- Keep a copy of your custom code somewhere outside the platform, because the editor is not a safe original.
How We Handle Booking Software for Dumpster Rental Clients
Booking software is where dumpster rental marketing quietly succeeds or fails. You can rank first for every size and every city you serve and still lose the job at a checkout page that looks like it belongs to a different company. When we take on a dumpster rental client we treat the booking flow as part of the website rather than a separate system, which means matching the branding, fixing the parts that leak trust, and testing the whole path from search result to confirmed order on a real phone.
The Bigger Picture
Assume Any Platform Can Rewrite What You Save
This is not only a DRS story. Any platform that supports template tokens in a field where you also write code has the same class of problem, and most of them handle it about as gracefully. Booking systems, email builders, page builders and review widgets all run some version of this substitution.
The habit that protects you is small. After you save something into a platform you do not control, go and look at what the platform produced rather than at what you typed. For CSS that means the browser stylesheet. For an email template it means a test send. It takes seconds, and it catches a category of bug that is otherwise almost impossible to reason about, because every instinct you have says the code in front of you is the code you wrote.
Want Me to Look at Your Booking Flow?
I will go through your booking pages the way a customer would, on a phone, from a search result to a confirmed order, and tell you where the drop-offs are. Branding, trust signals, broken styling, dead ends, the lot. No charge and no obligation.
The Editor Is Not the Source of Truth
If custom CSS on your booking site has ever refused to work for no reason you could find, this is worth 10 minutes. The rule you have been fighting may not exist any more.
Read what the platform saved rather than what you typed, and check that the browser agrees the rule is valid. Those 2 habits turn an unexplainable afternoon into a 2 minute fix.
Get contractor marketing tips in your inbox
SEO strategies, Google Ads insights, AI SEO updates, and practical marketing guides for home service contractors, delivered monthly. No fluff, no spam.

